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

package/dist/cjs/functions/setRecord.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const normalise_1 = require("../utils/normalise");
+const recordHelpers_1 = require("../utils/recordHelpers");
+async function default_1({ 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 = (0, normalise_1.namehash)(name);
+    const call = (0, recordHelpers_1.generateSingleRecordCall)(hash, resolver, type)(record);
+    return {
+        to: resolver.address,
+        data: call,
+    };
+}
+exports.default = default_1;

package/dist/cjs/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/cjs/functions/setRecords.js

@@ -1,22 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
+const normalise_1 = require("../utils/normalise");
 const recordHelpers_1 = require("../utils/recordHelpers");
-async function default_1({ contracts, provider, getResolver, }, name, records) {
+async function default_1({ 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_1.ethers.utils.namehash(name);
-    const calls = (0, recordHelpers_1.generateRecordCallArray)(namehash, records, resolver);
-    return resolver?.multicall(calls);
+    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+    const hash = (0, normalise_1.namehash)(name);
+    const calls = (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver);
+    return resolver.populateTransaction.multicall(calls);
 }
 exports.default = default_1;

package/dist/cjs/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/cjs/functions/setResolver.js

@@ -1,24 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-async function default_1({ contracts, provider }, name, contract, resolver, options) {
-    const address = await provider
-        ?.getSigner(options?.addressOrIndex)
-        .getAddress();
-    if (!address) {
-        throw new Error('No signer found');
-    }
+const normalise_1 = require("../utils/normalise");
+async function default_1({ 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_1.ethers.utils.namehash(name), resolver);
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.populateTransaction.setResolver((0, normalise_1.namehash)(name), resolver);
         }
         case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
-            return nameWrapper.setResolver(ethers_1.ethers.utils.namehash(name), resolver);
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            return nameWrapper.populateTransaction.setResolver((0, normalise_1.namehash)(name), resolver);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/cjs/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/cjs/functions/transferName.js

@@ -1,29 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-async function default_1({ contracts, provider }, name, newOwner, contract, options) {
-    const address = await provider
-        ?.getSigner(options?.addressOrIndex)
-        .getAddress();
-    if (!address) {
-        throw new Error('No signer found');
-    }
+const normalise_1 = require("../utils/normalise");
+async function default_1({ 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_1.ethers.utils.namehash(name), newOwner);
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.populateTransaction.setOwner((0, normalise_1.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_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]));
+            return baseRegistrar.populateTransaction['safeTransferFrom(address,address,uint256)'](address, newOwner, ethers_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]));
         }
         case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
-            return nameWrapper.safeTransferFrom(address, newOwner, ethers_1.ethers.utils.namehash(name), 1, '0x');
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            return nameWrapper.populateTransaction.safeTransferFrom(address, newOwner, (0, normalise_1.namehash)(name), 1, '0x');
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

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

@@ -1,5 +1,15 @@
 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>;
+import { Expiry } from '../utils/wrapperExpiry';
+declare type BaseArgs = {
+    owner: string;
+    resolverAddress?: string;
+    contract: 'registry' | 'nameWrapper';
+};
+declare type NameWrapperArgs = {
+    contract: 'nameWrapper';
+    expiry?: Expiry;
+} & BaseArgs;
+declare type Args = BaseArgs | NameWrapperArgs;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract, owner, resolverAddress, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
+export {};

package/dist/cjs/functions/transferSubname.js

@@ -1,23 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-async function default_1({ contracts, provider }, name, contract, address, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+const normalise_1 = require("../utils/normalise");
+const wrapperExpiry_1 = require("../utils/wrapperExpiry");
+async function default_1({ contracts, signer, getExpiry, }, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
     const labels = name.split('.');
     const label = labels.shift();
     const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = ethers_1.ethers.utils.namehash(labels.join('.'));
+    const parentNodehash = (0, normalise_1.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, owner);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            return nameWrapper.setSubnodeOwner(parentNodehash, label, address, '0');
+            const expiry = await (0, wrapperExpiry_1.makeExpiry)({ getExpiry }, labels.join('.'), 'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined);
+            return nameWrapper.populateTransaction.setSubnodeOwner(parentNodehash, label, owner, '0', expiry);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/cjs/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/cjs/functions/unwrapName.js

@@ -1,27 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-async function default_1({ 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');
-    }
+const normalise_1 = require("../utils/normalise");
+async function default_1({ contracts, signer }, name, { newController, newRegistrant, }) {
     const labels = name.split('.');
     const labelhash = ethers_1.utils.solidityKeccak256(['string'], [labels[0]]);
-    const parentNodehash = ethers_1.utils.namehash(labels.slice(1).join('.'));
+    const parentNodehash = (0, normalise_1.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);
     }
 }
 exports.default = default_1;

package/dist/cjs/functions/wrapName.d.ts

@@ -1,6 +1,10 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import type { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, wrappedOwner: string, fuseOptions?: FuseOptions | string | number, resolverAddress?: string, options?: {
-    addressOrIndex?: string | number;
-}): Promise<ethers.ContractTransaction>;
+import { Expiry } from '../utils/wrapperExpiry';
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { wrappedOwner, fuseOptions, expiry, resolverAddress, }: {
+    wrappedOwner: string;
+    fuseOptions?: FuseOptions | string | number;
+    expiry?: Expiry;
+    resolverAddress?: string;
+}): Promise<ethers.PopulatedTransaction>;

package/dist/cjs/functions/wrapName.js

@@ -6,59 +6,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
 const hexEncodedName_1 = require("../utils/hexEncodedName");
-async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address) {
+const wrapperExpiry_1 = require("../utils/wrapperExpiry");
+async function wrapETH({ contracts }, labels, wrappedOwner, expiry, decodedFuses, resolverAddress, signer, address) {
     const nameWrapper = await contracts?.getNameWrapper();
     const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
     const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]);
-    const data = ethers_1.ethers.utils.defaultAbiCoder.encode(['string', 'address', 'uint96', 'address'], [labels[0], wrappedOwner, decodedFuses, resolverAddress]);
-    return baseRegistrar['safeTransferFrom(address,address,uint256,bytes)'](address, nameWrapper.address, labelhash, data);
+    const data = ethers_1.ethers.utils.defaultAbiCoder.encode(['string', 'address', 'uint32', 'uint64', 'address'], [labels[0], wrappedOwner, decodedFuses, expiry, resolverAddress]);
+    return baseRegistrar.populateTransaction['safeTransferFrom(address,address,uint256,bytes)'](address, nameWrapper.address, labelhash, data);
 }
-async function wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address) {
-    const nameWrapper = await contracts?.getNameWrapper();
+async function wrapOther({ contracts }, name, wrappedOwner, resolverAddress, address, signer) {
+    const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     const registry = await contracts?.getRegistry();
     const hasApproval = await registry.isApprovedForAll(address, nameWrapper.address);
     if (!hasApproval) {
         throw new Error('NameWrapper must have approval to wrap a name from this address.');
     }
-    return nameWrapper.wrap((0, hexEncodedName_1.hexEncodeName)(name), wrappedOwner, decodedFuses, resolverAddress);
+    return nameWrapper.populateTransaction.wrap((0, hexEncodedName_1.hexEncodeName)(name), wrappedOwner, resolverAddress);
 }
-async function default_1({ contracts, provider }, name, wrappedOwner, fuseOptions, resolverAddress, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    const address = await signer?.getAddress();
-    if (!signer || !address) {
-        throw new Error('No signer found');
-    }
+async function default_1({ contracts, signer, getExpiry, }, name, { wrappedOwner, fuseOptions, expiry, resolverAddress, }) {
+    const address = await signer.getAddress();
     let decodedFuses;
-    switch (typeof fuseOptions) {
-        case 'object': {
-            decodedFuses = (0, generateFuseInput_1.default)(fuseOptions);
-            break;
-        }
-        case 'number': {
-            decodedFuses = fuseOptions.toString(16);
-            break;
-        }
-        case 'string': {
-            decodedFuses = fuseOptions;
-            break;
-        }
-        case 'undefined': {
-            decodedFuses = '0';
-            break;
-        }
-        default: {
-            throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`);
-        }
-    }
     const publicResolver = await contracts?.getPublicResolver();
     if (!resolverAddress)
         resolverAddress = publicResolver.address;
     const labels = name.split('.');
-    if (labels.length < 3 && labels[labels.length - 1] === 'eth') {
-        return wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address);
+    if (labels.length === 2 && labels[1] === 'eth') {
+        switch (typeof fuseOptions) {
+            case 'object': {
+                decodedFuses = (0, generateFuseInput_1.default)(fuseOptions);
+                break;
+            }
+            case 'number': {
+                decodedFuses = fuseOptions.toString(16);
+                break;
+            }
+            case 'string': {
+                decodedFuses = fuseOptions;
+                break;
+            }
+            case 'undefined': {
+                decodedFuses = '0';
+                break;
+            }
+            default: {
+                throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`);
+            }
+        }
+        const expiryToUse = await (0, wrapperExpiry_1.makeExpiry)({ getExpiry }, name, expiry);
+        return wrapETH({ contracts }, labels, wrappedOwner, expiryToUse, decodedFuses, resolverAddress, signer, address);
     }
     else {
-        return wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address);
+        if (fuseOptions)
+            throw new Error('Fuses can not be initially set when wrapping a non .eth name');
+        if (expiry)
+            throw new Error('Expiry can not be initially set when wrapping a non .eth name');
+        return wrapOther({ contracts }, name, wrappedOwner, resolverAddress, address, signer);
     }
 }
 exports.default = default_1;