@ensdomains/ensjs 3.0.0-alpha.1 → 3.0.0-alpha.10

package/dist/esm/functions/getProfile.d.ts

@@ -26,5 +26,8 @@ declare type ProfileOptions = {
     texts?: boolean | string[];
     coinTypes?: boolean | string[];
 };
-export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper'>, nameOrAddress: string, options?: ProfileOptions): Promise<ResolvedProfile | undefined>;
+declare type InputProfileOptions = ProfileOptions & {
+    resolverAddress?: string;
+};
+export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: InputProfileOptions): Promise<ResolvedProfile | undefined>;
 export {};

package/dist/esm/functions/getProfile.js

@@ -2,6 +2,7 @@ import { formatsByName } from '@ensdomains/address-encoder';
 import { ethers } from 'ethers';
 import { decodeContenthash } from '../utils/contentHash';
 import { hexEncodeName } from '../utils/hexEncodedName';
+import { namehash } from '../utils/normalise';
 import { parseInputType } from '../utils/validation';
 const makeMulticallData = async ({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
     let calls = [];
@@ -40,23 +41,51 @@ const makeMulticallData = async ({ _getAddr, _getContentHash, _getText, resolver
     const prRawData = await resolverMulticallWrapper.raw(calls.map((x) => x.data));
     return { data: prRawData.data, calls };
 };
-const makeHashIndexes = (data, name) => [...data.matchAll(ethers.utils.namehash(name).substring(2))].map((x) => x.index / 2 - 1);
-const getDataForName = async ({ contracts, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
+const fetchWithoutResolverMulticall = async ({ multicallWrapper }, calls, resolverAddress) => {
+    const callsWithResolver = calls.map((call) => ({
+        to: resolverAddress,
+        data: call.data.data,
+    }));
+    return (await multicallWrapper(callsWithResolver)).map((x) => x[1]);
+};
+const getDataForName = async ({ contracts, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options, fallbackResolver, specificResolver) => {
     const universalResolver = await contracts?.getUniversalResolver();
     const { data, calls } = await makeMulticallData({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper }, name, options);
-    let resolver;
+    let resolvedData;
+    let useFallbackResolver = false;
     try {
-        resolver = await universalResolver?.resolve(hexEncodeName(name), data);
+        if (specificResolver) {
+            const publicResolver = await contracts?.getPublicResolver(undefined, specificResolver);
+            resolvedData = await publicResolver?.callStatic.multicall(calls.map((x) => x.data));
+        }
+        else {
+            resolvedData = await universalResolver?.resolve(hexEncodeName(name), data);
+        }
     }
     catch {
-        return;
+        useFallbackResolver = true;
+    }
+    let resolverAddress;
+    let recordData;
+    if (useFallbackResolver) {
+        resolverAddress = specificResolver || fallbackResolver;
+        recordData = await fetchWithoutResolverMulticall({ multicallWrapper }, calls, resolverAddress);
+    }
+    else {
+        resolverAddress = specificResolver || resolvedData['1'];
+        if (specificResolver) {
+            recordData = resolvedData;
+        }
+        else {
+            ;
+            [recordData] = await resolverMulticallWrapper.decode(resolvedData['0']);
+        }
     }
-    const [recordData] = await resolverMulticallWrapper.decode(resolver['0']);
     const matchAddress = recordData[calls.findIndex((x) => x.key === '60')];
     return {
         address: matchAddress && (await _getAddr.decode(matchAddress)),
         records: await formatRecords({ _getAddr, _getContentHash, _getText }, recordData, calls, options),
-        resolverAddress: resolver['1'],
+        resolverAddress,
     };
 };
 const formatRecords = async ({ _getText, _getAddr, _getContentHash, }, data, calls, options) => {
@@ -66,7 +95,7 @@ const formatRecords = async ({ _getText, _getAddr, _getContentHash, }, data, cal
             key: calls[i].key,
             type: calls[i].type,
         };
-        if (itemRet.type === 'addr' || itemRet.type === 'contenthash') {
+        if (itemRet.type === 'contenthash') {
             decodedFromAbi = ethers.utils.defaultAbiCoder.decode(['bytes'], item)[0];
             if (ethers.utils.hexStripZeros(decodedFromAbi) === '0x') {
                 return;
@@ -142,10 +171,10 @@ const formatRecords = async ({ _getText, _getAddr, _getContentHash, }, data, cal
     }
     return returnedResponse;
 };
-const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
+const graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress) => {
     const query = gqlInstance.gql `
-    query getRecords($name: String!) {
-      domains(where: { name: $name }) {
+    query getRecords($id: String!) {
+      domain(id: $id) {
         isMigrated
         createdAt
         resolver {
@@ -155,18 +184,52 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
           addr {
             id
           }
+          address
+        }
+      }
+    }
+  `;
+    const customResolverQuery = gqlInstance.gql `
+    query getRecordsWithCustomResolver($id: String!, $resolverId: String!) {
+      domain(id: $id) {
+        isMigrated
+        createdAt
+      }
+      resolver(id: $resolverId) {
+        texts
+        coinTypes
+        contentHash
+        addr {
+          id
         }
       }
     }
   `;
     const client = gqlInstance.client;
-    const { domains } = await client.request(query, { name });
-    if (!domains || domains.length === 0)
+    const id = namehash(name);
+    let domain;
+    let resolverResponse;
+    if (!resolverAddress) {
+        ;
+        ({ domain } = await client.request(query, { id }));
+        resolverResponse = domain?.resolver;
+    }
+    else {
+        const resolverId = `${resolverAddress}-${id}`;
+        ({ resolver: resolverResponse, domain } = await client.request(customResolverQuery, { id, resolverId }));
+    }
+    if (!domain)
         return;
-    const [{ resolver: resolverResponse, isMigrated, createdAt }] = domains;
+    const { isMigrated, createdAt } = domain;
     let returnedRecords = {};
-    if (!wantedRecords)
+    if (!resolverResponse)
         return { isMigrated, createdAt };
+    if (!wantedRecords)
+        return {
+            isMigrated,
+            createdAt,
+            graphResolverAddress: resolverResponse.address || resolverAddress,
+        };
     Object.keys(wantedRecords).forEach((key) => {
         const data = wantedRecords[key];
         if (typeof data === 'boolean' && data) {
@@ -178,28 +241,40 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords) => {
             }
         }
     });
-    return { ...returnedRecords, isMigrated, createdAt };
+    return {
+        ...returnedRecords,
+        isMigrated,
+        createdAt,
+        graphResolverAddress: resolverResponse.address || resolverAddress,
+    };
 };
-const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
-    const usingOptions = !options || options?.texts === true || options?.coinTypes === true
-        ? options || { contentHash: true, texts: true, coinTypes: true }
+const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options) => {
+    const { resolverAddress, ..._options } = options || {};
+    const optsLength = Object.keys(_options).length;
+    const usingOptions = !optsLength || _options?.texts === true || _options?.coinTypes === true
+        ? optsLength
+            ? _options
+            : { contentHash: true, texts: true, coinTypes: true }
         : undefined;
-    const graphResult = await graphFetch({ gqlInstance }, name, usingOptions);
+    const graphResult = await graphFetch({ gqlInstance }, name, usingOptions, resolverAddress);
     if (!graphResult)
         return;
-    const { isMigrated, createdAt, ...wantedRecords } = graphResult;
+    const { isMigrated, createdAt, graphResolverAddress, ...wantedRecords } = graphResult;
+    if (!graphResolverAddress && !options?.resolverAddress)
+        return { isMigrated, createdAt, message: "Name doesn't have a resolver" };
     const result = await getDataForName({
         contracts,
         _getAddr,
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
-    }, name, usingOptions ? wantedRecords : options);
+        multicallWrapper,
+    }, name, usingOptions ? wantedRecords : options, graphResolverAddress, options?.resolverAddress);
     if (!result)
         return { isMigrated, createdAt, message: "Records fetch didn't complete" };
     return { ...result, isMigrated, createdAt, message: undefined };
 };
-const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, address, options) => {
+const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, address, options) => {
     let name;
     try {
         name = await getName(address);
@@ -218,6 +293,7 @@ const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
+        multicallWrapper,
     }, name.name, options);
     if (!result || result.message)
         return;
@@ -228,7 +304,7 @@ const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr
         message: undefined,
     };
 };
-export default async function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, nameOrAddress, options) {
+export default async function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, nameOrAddress, options) {
     if (options && options.coinTypes && typeof options.coinTypes !== 'boolean') {
         options.coinTypes = options.coinTypes.map((coin) => {
             if (!isNaN(parseInt(coin))) {
@@ -252,6 +328,7 @@ export default async function ({ contracts, gqlInstance, getName, _getAddr, _get
             _getContentHash,
             _getText,
             resolverMulticallWrapper,
+            multicallWrapper,
         }, nameOrAddress, options);
     }
     return getProfileFromName({
@@ -261,5 +338,6 @@ export default async function ({ contracts, gqlInstance, getName, _getAddr, _get
         _getContentHash,
         _getText,
         resolverMulticallWrapper,
+        multicallWrapper,
     }, nameOrAddress, options);
 }

package/dist/esm/functions/getRecords.d.ts

@@ -3,6 +3,7 @@ declare type ProfileOptions = {
     contentHash?: boolean;
     texts?: boolean | string[];
     coinTypes?: boolean | string[];
+    resolverAddress?: string;
 };
 export default function ({ getProfile }: ENSArgs<'getProfile'>, name: string, options?: ProfileOptions): Promise<{
     isMigrated: boolean | null;

package/dist/esm/functions/getSpecificRecord.js

@@ -1,13 +1,14 @@
 import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder';
 import { ethers } from 'ethers';
 import { decodeContenthash } from '../utils/contentHash';
+import { namehash } from '../utils/normalise';
 export const _getContentHash = {
     raw: async ({ contracts }, name) => {
         const publicResolver = await contracts?.getPublicResolver();
         return {
             to: '0x0000000000000000000000000000000000000000',
             data: publicResolver.interface.encodeFunctionData('contenthash', [
-                ethers.utils.namehash(name),
+                namehash(name),
             ]),
         };
     },
@@ -45,7 +46,7 @@ export const _getText = {
         return {
             to: '0x0000000000000000000000000000000000000000',
             data: publicResolver.interface.encodeFunctionData('text', [
-                ethers.utils.namehash(name),
+                namehash(name),
                 key,
             ]),
         };
@@ -77,10 +78,18 @@ export const _getAddr = {
             coinType = 60;
         }
         const publicResolver = await contracts?.getPublicResolver();
+        if (coinType === 60 || coinType === '60') {
+            return {
+                to: '0x0000000000000000000000000000000000000000',
+                data: publicResolver.interface.encodeFunctionData('addr(bytes32)', [
+                    namehash(name),
+                ]),
+            };
+        }
         if (bypassFormat) {
             return {
                 to: '0x0000000000000000000000000000000000000000',
-                data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [ethers.utils.namehash(name), coinType]),
+                data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [namehash(name), coinType]),
             };
         }
         const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
@@ -91,7 +100,7 @@ export const _getAddr = {
         }
         return {
             to: '0x0000000000000000000000000000000000000000',
-            data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [ethers.utils.namehash(name), formatter.coinType]),
+            data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [namehash(name), formatter.coinType]),
         };
     },
     decode: async ({ contracts }, data, _name, coinType) => {
@@ -104,7 +113,15 @@ export const _getAddr = {
         const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
             ? formatsByName[coinType]
             : formatsByCoinType[typeof coinType === 'number' ? coinType : parseInt(coinType)];
-        const [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32,uint256)', data);
+        let response;
+        if (coinType === 60 || coinType === '60') {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32)', data);
+        }
+        else {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32,uint256)', data);
+        }
         if (!response)
             return;
         if (ethers.utils.hexStripZeros(response) === '0x') {

package/dist/esm/functions/getSubnames.js

@@ -1,6 +1,6 @@
-import { namehash } from 'ethers/lib/utils';
 import { truncateFormat } from '../utils/format';
 import { decryptName } from '../utils/labels';
+import { namehash } from '../utils/normalise';
 const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }) => {
     const client = gqlInstance.client;
     let finalQuery = gqlInstance.gql `
@@ -53,7 +53,7 @@ const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     });
     return {
         subnames: subdomains,
-        subnameCount: domain.subdomainCount
+        subnameCount: domain.subdomainCount,
     };
 };
 const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy }) => {
@@ -140,7 +140,7 @@ const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDir
     });
     return {
         subnames: subdomains,
-        subnameCount: domain.subdomainCount
+        subnameCount: domain.subdomainCount,
     };
 };
 const getSubnames = (injected, functionArgs) => {

package/dist/esm/functions/setName.d.ts

@@ -1,4 +1,5 @@
 import { ENSArgs } from '..';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, address?: string, resolver?: string, options?: {
-    addressOrIndex?: string | number;
-}): Promise<import("ethers").ContractTransaction | undefined>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { address, resolver, }?: {
+    address?: string;
+    resolver?: string;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/setName.js

@@ -1,14 +1,9 @@
-export default async function ({ contracts, provider }, name, address, resolver, options) {
-    const signerAddress = await provider
-        ?.getSigner(options?.addressOrIndex)
-        .getAddress();
-    if (!signerAddress) {
-        throw new Error('No signer found');
-    }
-    const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(provider?.getSigner());
+export default async function ({ contracts, signer }, name, { address, resolver, } = {}) {
+    const signerAddress = await signer.getAddress();
+    const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(signer);
     if (address) {
         const publicResolver = await contracts?.getPublicResolver();
-        return reverseRegistrar?.setNameForAddr(address, signerAddress, resolver || publicResolver.address, name);
+        return reverseRegistrar.populateTransaction.setNameForAddr(address, signerAddress, resolver || publicResolver.address, name);
     }
-    return reverseRegistrar?.setName(name);
+    return reverseRegistrar.populateTransaction.setName(name);
 }

package/dist/esm/functions/setRecord.d.ts

@@ -0,0 +1,18 @@
+import { ENSArgs } from '..';
+import { RecordInput, RecordTypes } from '../utils/recordHelpers';
+declare type BaseInput = {
+    resolverAddress?: string;
+};
+declare type ContentHashInput = {
+    record: RecordInput<'contentHash'>;
+    type: 'contentHash';
+};
+declare type AddrOrTextInput = {
+    record: RecordInput<'addr' | 'text'>;
+    type: 'addr' | 'text';
+};
+export default function <T extends RecordTypes>({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
+    to: string;
+    data: string;
+}>;
+export {};

package/dist/esm/functions/setRecord.js

@@ -0,0 +1,24 @@
+import { namehash } from '../utils/normalise';
+import { generateSingleRecordCall, } from '../utils/recordHelpers';
+export default async function ({ contracts, provider, getResolver, signer, }, name, { record, type, resolverAddress, }) {
+    if (!name.includes('.')) {
+        throw new Error('Input is not an ENS name');
+    }
+    let resolverToUse;
+    if (resolverAddress) {
+        resolverToUse = resolverAddress;
+    }
+    else {
+        resolverToUse = await getResolver(name);
+    }
+    if (!resolverToUse) {
+        throw new Error('No resolver found for input address');
+    }
+    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+    const hash = namehash(name);
+    const call = generateSingleRecordCall(hash, resolver, type)(record);
+    return {
+        to: resolver.address,
+        data: call,
+    };
+}

package/dist/esm/functions/setRecords.d.ts

@@ -1,4 +1,6 @@
-import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { RecordOptions } from '../utils/recordHelpers';
-export default function ({ contracts, provider, getResolver, }: ENSArgs<'contracts' | 'provider' | 'getResolver'>, name: string, records: RecordOptions): Promise<ethers.ContractTransaction | undefined>;
+export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { records, resolverAddress, }: {
+    records: RecordOptions;
+    resolverAddress?: string;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/setRecords.js

@@ -1,19 +1,21 @@
-import { ethers } from 'ethers';
+import { namehash } from '../utils/normalise';
 import { generateRecordCallArray } from '../utils/recordHelpers';
-export default async function ({ contracts, provider, getResolver, }, name, records) {
+export default async function ({ contracts, provider, getResolver, signer, }, name, { records, resolverAddress, }) {
     if (!name.includes('.')) {
         throw new Error('Input is not an ENS name');
     }
-    const resolverAddress = await getResolver(name);
-    if (!resolverAddress) {
-        throw new Error('No resolver found for input address');
+    let resolverToUse;
+    if (resolverAddress) {
+        resolverToUse = resolverAddress;
+    }
+    else {
+        resolverToUse = await getResolver(name);
     }
-    const address = await provider?.getSigner().getAddress();
-    if (!address) {
-        throw new Error('No signer found');
+    if (!resolverToUse) {
+        throw new Error('No resolver found for input address');
     }
-    const resolver = (await contracts?.getPublicResolver(provider, resolverAddress))?.connect(provider?.getSigner());
-    const namehash = ethers.utils.namehash(name);
-    const calls = generateRecordCallArray(namehash, records, resolver);
-    return resolver?.multicall(calls);
+    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+    const hash = namehash(name);
+    const calls = generateRecordCallArray(hash, records, resolver);
+    return resolver.populateTransaction.multicall(calls);
 }

package/dist/esm/functions/setResolver.d.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers';
 import { ENSArgs } from '..';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, contract: 'registry' | 'nameWrapper', resolver?: string, options?: {
-    addressOrIndex?: string | number;
-}): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, resolver, }: {
+    contract: 'registry' | 'nameWrapper';
+    resolver?: string;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/setResolver.js

@@ -1,22 +1,16 @@
-import { ethers } from 'ethers';
-export default async function ({ contracts, provider }, name, contract, resolver, options) {
-    const address = await provider
-        ?.getSigner(options?.addressOrIndex)
-        .getAddress();
-    if (!address) {
-        throw new Error('No signer found');
-    }
+import { namehash } from '../utils/normalise';
+export default async function ({ contracts, signer }, name, { contract, resolver, }) {
     if (!resolver) {
         resolver = (await contracts?.getPublicResolver()).address;
     }
     switch (contract) {
         case 'registry': {
-            const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
-            return registry.setResolver(ethers.utils.namehash(name), resolver);
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.populateTransaction.setResolver(namehash(name), resolver);
         }
         case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
-            return nameWrapper.setResolver(ethers.utils.namehash(name), resolver);
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            return nameWrapper.populateTransaction.setResolver(namehash(name), resolver);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/esm/functions/transferName.d.ts

@@ -1,5 +1,6 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, newOwner: string, contract: 'registry' | 'nameWrapper' | 'baseRegistrar', options?: {
-    addressOrIndex?: string | number;
-}): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, contract, }: {
+    newOwner: string;
+    contract: 'registry' | 'nameWrapper' | 'baseRegistrar';
+}): Promise<ethers.PopulatedTransaction>;

package/dist/esm/functions/transferName.js

@@ -1,27 +1,23 @@
 import { ethers } from 'ethers';
-export default async function ({ contracts, provider }, name, newOwner, contract, options) {
-    const address = await provider
-        ?.getSigner(options?.addressOrIndex)
-        .getAddress();
-    if (!address) {
-        throw new Error('No signer found');
-    }
+import { namehash } from '../utils/normalise';
+export default async function ({ contracts, signer }, name, { newOwner, contract, }) {
+    const address = await signer.getAddress();
     switch (contract) {
         case 'registry': {
-            const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
-            return registry.setOwner(ethers.utils.namehash(name), newOwner);
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.populateTransaction.setOwner(namehash(name), newOwner);
         }
         case 'baseRegistrar': {
-            const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(provider?.getSigner(options?.addressOrIndex));
+            const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
             const labels = name.split('.');
             if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
                 throw new Error('Invalid name for baseRegistrar');
             }
-            return baseRegistrar['safeTransferFrom(address,address,uint256)'](address, newOwner, ethers.utils.solidityKeccak256(['string'], [labels[0]]));
+            return baseRegistrar.populateTransaction['safeTransferFrom(address,address,uint256)'](address, newOwner, ethers.utils.solidityKeccak256(['string'], [labels[0]]));
         }
         case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
-            return nameWrapper.safeTransferFrom(address, newOwner, ethers.utils.namehash(name), 1, '0x');
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            return nameWrapper.populateTransaction.safeTransferFrom(address, newOwner, namehash(name), 1, '0x');
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/esm/functions/transferSubname.d.ts

@@ -1,5 +1,6 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, contract: 'registry' | 'nameWrapper', address: string, options?: {
-    addressOrIndex?: string | number;
-}): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, address, }: {
+    contract: 'registry' | 'nameWrapper';
+    address: string;
+}): Promise<ethers.PopulatedTransaction>;

package/dist/esm/functions/transferSubname.js

@@ -1,21 +1,18 @@
 import { ethers } from 'ethers';
-export default async function ({ contracts, provider }, name, contract, address, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+import { namehash } from '../utils/normalise';
+export default async function ({ contracts, signer }, name, { contract, address, }) {
     const labels = name.split('.');
     const label = labels.shift();
     const labelhash = ethers.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = ethers.utils.namehash(labels.join('.'));
+    const parentNodehash = namehash(labels.join('.'));
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.setSubnodeOwner(parentNodehash, labelhash, address);
+            return registry.populateTransaction.setSubnodeOwner(parentNodehash, labelhash, address);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            return nameWrapper.setSubnodeOwner(parentNodehash, label, address, '0');
+            return nameWrapper.populateTransaction.setSubnodeOwner(parentNodehash, label, address, '0');
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/esm/functions/unwrapName.d.ts

@@ -1,4 +1,5 @@
 import { ENSArgs } from '..';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, newController: string, newRegistrant?: string, options?: {
-    addressOrIndex?: string | number;
-}): Promise<import("ethers").ContractTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newController, newRegistrant, }: {
+    newController: string;
+    newRegistrant?: string;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/unwrapName.js

@@ -1,24 +1,20 @@
 import { utils } from 'ethers';
-export default async function ({ contracts, provider }, name, newController, newRegistrant, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    const address = await signer?.getAddress();
-    if (!signer || !address) {
-        throw new Error('No signer found');
-    }
+import { namehash } from '../utils/normalise';
+export default async function ({ contracts, signer }, name, { newController, newRegistrant, }) {
     const labels = name.split('.');
     const labelhash = utils.solidityKeccak256(['string'], [labels[0]]);
-    const parentNodehash = utils.namehash(labels.slice(1).join('.'));
+    const parentNodehash = namehash(labels.slice(1).join('.'));
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     if (labels.length === 2 && labels[1] === 'eth') {
         if (!newRegistrant) {
             throw new Error('newRegistrant must be specified for .eth names');
         }
-        return nameWrapper.unwrapETH2LD(labelhash, newRegistrant, newController);
+        return nameWrapper.populateTransaction.unwrapETH2LD(labelhash, newRegistrant, newController);
     }
     else {
         if (newRegistrant) {
             throw new Error('newRegistrant can only be specified for .eth names');
         }
-        return nameWrapper.unwrap(parentNodehash, labelhash, newController);
+        return nameWrapper.populateTransaction.unwrap(parentNodehash, labelhash, newController);
     }
 }