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

package/dist/cjs/generated/index.js

@@ -23,16 +23,44 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniversalResolver__factory = exports.StaticMetadataService__factory = exports.ReverseRegistrar__factory = exports.PublicResolver__factory = exports.NameWrapper__factory = exports.ETHRegistrarController__factory = exports.factories = void 0;
+exports.UniversalResolver__factory = exports.StaticMetadataService__factory = exports.NameWrapper__factory = exports.Multicall__factory = exports.TLDPublicSuffixList__factory = exports.SHA256Digest__factory = exports.SHA1NSEC3Digest__factory = exports.SHA1Digest__factory = exports.RSASHA256Algorithm__factory = exports.RSASHA1Algorithm__factory = exports.Root__factory = exports.ReverseRegistrar__factory = exports.PublicResolver__factory = exports.P256SHA256Algorithm__factory = exports.ETHRegistrarController__factory = exports.ENSRegistry__factory = exports.DNSSECImpl__factory = exports.DNSRegistrar__factory = exports.DefaultReverseResolver__factory = exports.BaseRegistrarImplementation__factory = exports.factories = void 0;
 exports.factories = __importStar(require("./factories"));
+var BaseRegistrarImplementation__factory_1 = require("./factories/BaseRegistrarImplementation__factory");
+Object.defineProperty(exports, "BaseRegistrarImplementation__factory", { enumerable: true, get: function () { return BaseRegistrarImplementation__factory_1.BaseRegistrarImplementation__factory; } });
+var DefaultReverseResolver__factory_1 = require("./factories/DefaultReverseResolver__factory");
+Object.defineProperty(exports, "DefaultReverseResolver__factory", { enumerable: true, get: function () { return DefaultReverseResolver__factory_1.DefaultReverseResolver__factory; } });
+var DNSRegistrar__factory_1 = require("./factories/DNSRegistrar__factory");
+Object.defineProperty(exports, "DNSRegistrar__factory", { enumerable: true, get: function () { return DNSRegistrar__factory_1.DNSRegistrar__factory; } });
+var DNSSECImpl__factory_1 = require("./factories/DNSSECImpl__factory");
+Object.defineProperty(exports, "DNSSECImpl__factory", { enumerable: true, get: function () { return DNSSECImpl__factory_1.DNSSECImpl__factory; } });
+var ENSRegistry__factory_1 = require("./factories/ENSRegistry__factory");
+Object.defineProperty(exports, "ENSRegistry__factory", { enumerable: true, get: function () { return ENSRegistry__factory_1.ENSRegistry__factory; } });
 var ETHRegistrarController__factory_1 = require("./factories/ETHRegistrarController__factory");
 Object.defineProperty(exports, "ETHRegistrarController__factory", { enumerable: true, get: function () { return ETHRegistrarController__factory_1.ETHRegistrarController__factory; } });
-var NameWrapper__factory_1 = require("./factories/NameWrapper__factory");
-Object.defineProperty(exports, "NameWrapper__factory", { enumerable: true, get: function () { return NameWrapper__factory_1.NameWrapper__factory; } });
+var P256SHA256Algorithm__factory_1 = require("./factories/P256SHA256Algorithm__factory");
+Object.defineProperty(exports, "P256SHA256Algorithm__factory", { enumerable: true, get: function () { return P256SHA256Algorithm__factory_1.P256SHA256Algorithm__factory; } });
 var PublicResolver__factory_1 = require("./factories/PublicResolver__factory");
 Object.defineProperty(exports, "PublicResolver__factory", { enumerable: true, get: function () { return PublicResolver__factory_1.PublicResolver__factory; } });
 var ReverseRegistrar__factory_1 = require("./factories/ReverseRegistrar__factory");
 Object.defineProperty(exports, "ReverseRegistrar__factory", { enumerable: true, get: function () { return ReverseRegistrar__factory_1.ReverseRegistrar__factory; } });
+var Root__factory_1 = require("./factories/Root__factory");
+Object.defineProperty(exports, "Root__factory", { enumerable: true, get: function () { return Root__factory_1.Root__factory; } });
+var RSASHA1Algorithm__factory_1 = require("./factories/RSASHA1Algorithm__factory");
+Object.defineProperty(exports, "RSASHA1Algorithm__factory", { enumerable: true, get: function () { return RSASHA1Algorithm__factory_1.RSASHA1Algorithm__factory; } });
+var RSASHA256Algorithm__factory_1 = require("./factories/RSASHA256Algorithm__factory");
+Object.defineProperty(exports, "RSASHA256Algorithm__factory", { enumerable: true, get: function () { return RSASHA256Algorithm__factory_1.RSASHA256Algorithm__factory; } });
+var SHA1Digest__factory_1 = require("./factories/SHA1Digest__factory");
+Object.defineProperty(exports, "SHA1Digest__factory", { enumerable: true, get: function () { return SHA1Digest__factory_1.SHA1Digest__factory; } });
+var SHA1NSEC3Digest__factory_1 = require("./factories/SHA1NSEC3Digest__factory");
+Object.defineProperty(exports, "SHA1NSEC3Digest__factory", { enumerable: true, get: function () { return SHA1NSEC3Digest__factory_1.SHA1NSEC3Digest__factory; } });
+var SHA256Digest__factory_1 = require("./factories/SHA256Digest__factory");
+Object.defineProperty(exports, "SHA256Digest__factory", { enumerable: true, get: function () { return SHA256Digest__factory_1.SHA256Digest__factory; } });
+var TLDPublicSuffixList__factory_1 = require("./factories/TLDPublicSuffixList__factory");
+Object.defineProperty(exports, "TLDPublicSuffixList__factory", { enumerable: true, get: function () { return TLDPublicSuffixList__factory_1.TLDPublicSuffixList__factory; } });
+var Multicall__factory_1 = require("./factories/Multicall__factory");
+Object.defineProperty(exports, "Multicall__factory", { enumerable: true, get: function () { return Multicall__factory_1.Multicall__factory; } });
+var NameWrapper__factory_1 = require("./factories/NameWrapper__factory");
+Object.defineProperty(exports, "NameWrapper__factory", { enumerable: true, get: function () { return NameWrapper__factory_1.NameWrapper__factory; } });
 var StaticMetadataService__factory_1 = require("./factories/StaticMetadataService__factory");
 Object.defineProperty(exports, "StaticMetadataService__factory", { enumerable: true, get: function () { return StaticMetadataService__factory_1.StaticMetadataService__factory; } });
 var UniversalResolver__factory_1 = require("./factories/UniversalResolver__factory");

package/dist/cjs/index.d.ts

@@ -226,10 +226,9 @@ export declare class ENS {
         }>;
         decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
             fuseObj: {
-                [k: string]: any;
+                [k: string]: boolean;
             };
-            vulnerability: any;
-            vulnerableNode: null;
+            expiryDate: Date;
             rawFuses: ethers.BigNumber;
         } | undefined>;
     }>;
@@ -370,11 +369,18 @@ export declare class ENS {
         } | undefined>;
     }>;
     getExpiry: GeneratedRawFunction<{
-        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string) => Promise<{
+        raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: {
+            contract?: ("nameWrapper" | "registrar") | undefined;
+        }) => Promise<{
             to: string;
             data: string;
         }>;
-        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
+        decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: {
+            contract?: ("nameWrapper" | "registrar") | undefined;
+        }) => Promise<{
+            expiry: Date;
+            gracePeriod: null;
+        } | {
             expiry: Date | null;
             gracePeriod: number;
         } | undefined>;
@@ -385,7 +391,7 @@ export declare class ENS {
         pageSize?: number | undefined;
         orderDirection?: "asc" | "desc" | undefined;
         orderBy?: "labelName" | "createdAt" | undefined;
-        lastSubnames: any[];
+        lastSubnames?: any[] | undefined;
         isLargeQuery?: boolean | undefined;
     }) => Promise<{
         subnames: {

package/dist/cjs/index.js

@@ -234,14 +234,15 @@ class ENS {
     transferName = this.generateWriteFunction('transferName', ['contracts']);
     wrapName = this.generateWriteFunction('wrapName', [
         'contracts',
+        'getExpiry',
     ]);
     unwrapName = this.generateWriteFunction('unwrapName', ['contracts']);
     burnFuses = this.generateWriteFunction('burnFuses', [
         'contracts',
     ]);
-    createSubname = this.generateWriteFunction('createSubname', ['contracts']);
+    createSubname = this.generateWriteFunction('createSubname', ['contracts', 'getExpiry']);
     deleteSubname = this.generateWriteFunction('deleteSubname', ['transferSubname']);
-    transferSubname = this.generateWriteFunction('transferSubname', ['contracts']);
+    transferSubname = this.generateWriteFunction('transferSubname', ['contracts', 'getExpiry']);
     getDNSOwner = this.generateFunction('getDNSOwner', []);
 }
 exports.ENS = ENS;

package/dist/cjs/utils/wrapperExpiry.d.ts

@@ -0,0 +1,5 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+export declare type Expiry = string | number | Date | BigNumber;
+export declare const MAX_EXPIRY: BigNumber;
+export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry | undefined) => Promise<BigNumber>;

package/dist/cjs/utils/wrapperExpiry.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeExpiry = exports.MAX_EXPIRY = void 0;
+const ethers_1 = require("ethers");
+exports.MAX_EXPIRY = ethers_1.BigNumber.from(2).pow(64).sub(1);
+const makeExpiry = async ({ getExpiry }, name, expiry) => {
+    if (expiry) {
+        if (expiry instanceof Date) {
+            return ethers_1.BigNumber.from(expiry.getTime() / 1000);
+        }
+        else if (expiry instanceof ethers_1.BigNumber) {
+            return expiry;
+        }
+        else {
+            return ethers_1.BigNumber.from(expiry);
+        }
+    }
+    else {
+        if (name.endsWith('.eth')) {
+            const expResponse = await getExpiry(name);
+            if (!expResponse?.expiry)
+                throw new Error("Couldn't get expiry for name, please provide one.");
+            return ethers_1.BigNumber.from(expResponse.expiry.getTime() / 1000);
+        }
+        else {
+            return exports.MAX_EXPIRY;
+        }
+    }
+};
+exports.makeExpiry = makeExpiry;

package/dist/esm/contracts/baseRegistrar.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").BaseRegistrarImplementation;
 export default _default;

package/dist/esm/contracts/index.d.ts

@@ -7,10 +7,10 @@ export default class ContractManager {
     private generateContractGetter;
     getPublicResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").PublicResolver>;
     getUniversalResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").UniversalResolver>;
-    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/ENSRegistry").ENSRegistry>;
+    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ENSRegistry>;
     getReverseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ReverseRegistrar>;
     getNameWrapper: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").NameWrapper>;
-    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation>;
+    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").BaseRegistrarImplementation>;
     getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
-    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/Multicall").Multicall>;
+    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").Multicall>;
 }

package/dist/esm/contracts/multicall.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/Multicall").Multicall;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").Multicall;
 export default _default;

package/dist/esm/contracts/registry.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/ENSRegistry").ENSRegistry;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ENSRegistry;
 export default _default;

package/dist/esm/functions/burnFuses.js

@@ -4,5 +4,5 @@ export default async function ({ contracts, signer }, name, { fusesToBurn, }) {
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     const hash = namehash(name);
     const encodedFuses = generateFuseInput(fusesToBurn);
-    return nameWrapper.populateTransaction.burnFuses(hash, encodedFuses);
+    return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
 }

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

@@ -1,6 +1,7 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
+import { Expiry } from '../utils/wrapperExpiry';
 declare type BaseArgs = {
     owner: string;
     resolverAddress?: string;
@@ -9,7 +10,8 @@ declare type BaseArgs = {
 declare type NameWrapperArgs = {
     contract: 'nameWrapper';
     fuses?: FuseOptions;
+    expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
 export {};

package/dist/esm/functions/createSubname.js

@@ -1,7 +1,8 @@
 import { ethers } from 'ethers';
 import generateFuseInput from '../utils/generateFuseInput';
 import { namehash } from '../utils/normalise';
-export default async function ({ contracts, signer }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
+import { makeExpiry } from '../utils/wrapperExpiry';
+export default async function ({ contracts, signer, getExpiry, }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
     const labels = name.split('.');
     if (labels.length === 1) {
         throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');
@@ -22,10 +23,11 @@ export default async function ({ contracts, signer }, name, { owner, resolverAdd
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            const expiry = await makeExpiry({ getExpiry }, name, 'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined);
             const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
                 ? generateFuseInput(wrapperArgs.fuses)
                 : '0';
-            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
+            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses, expiry);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

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

@@ -1,4 +1,4 @@
 import { ENSArgs } from '..';
-export default function ({ transferSubname }: ENSArgs<'transferSubname'>, name: string, { contract, }: {
+export default function ({ transferSubname, signer }: ENSArgs<'transferSubname' | 'signer'>, name: string, { contract, }: {
     contract: 'registry' | 'nameWrapper';
 }): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/deleteSubname.js

@@ -1,6 +1,7 @@
-export default async function ({ transferSubname }, name, { contract, }) {
+export default async function ({ transferSubname, signer }, name, { contract, }) {
     return transferSubname.populateTransaction(name, {
         contract,
-        address: '0x0000000000000000000000000000000000000000',
+        owner: '0x0000000000000000000000000000000000000000',
+        signer,
     });
 }

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

@@ -1,10 +1,17 @@
 import { ENSArgs } from '..';
+declare type ContractOption = 'registrar' | 'nameWrapper';
+declare type Args = {
+    contract?: ContractOption;
+};
 declare const _default: {
-    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string) => Promise<{
+    raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: Args) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
+    decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: Args) => Promise<{
+        expiry: Date;
+        gracePeriod: null;
+    } | {
         expiry: Date | null;
         gracePeriod: number;
     } | undefined>;

package/dist/esm/functions/getExpiry.js

@@ -1,10 +1,10 @@
 import { solidityKeccak256 } from 'ethers/lib/utils';
-const raw = async ({ contracts, multicallWrapper }, name) => {
-    const baseRegistrar = await contracts?.getBaseRegistrar();
-    const labels = name.split('.');
+import { namehash } from '../utils/normalise';
+const getRegistrarExpiry = async ({ contracts, multicallWrapper }, labels) => {
     if (labels.length > 2 || labels[1] !== 'eth') {
-        throw new Error('Only .eth names have expiry dates');
+        throw new Error('Only .eth names have expiry dates on the registrar');
     }
+    const baseRegistrar = await contracts?.getBaseRegistrar();
     const expiryCall = baseRegistrar.interface.encodeFunctionData('nameExpires', [
         solidityKeccak256(['string'], [labels[0]]),
     ]);
@@ -20,9 +20,32 @@ const raw = async ({ contracts, multicallWrapper }, name) => {
         },
     ]);
 };
-const decode = async ({ contracts, multicallWrapper }, data) => {
-    if (data === null)
-        return;
+const getWrapperExpiry = async ({ contracts }, labels) => {
+    const nameWrapper = await contracts?.getNameWrapper();
+    const expiryCall = nameWrapper.interface.encodeFunctionData('getData', [
+        namehash(labels.join('.')),
+    ]);
+    return {
+        to: nameWrapper.address,
+        data: expiryCall,
+    };
+};
+const getContractToUse = (contract, labels) => {
+    if (contract)
+        return contract;
+    if (labels.length === 2 && labels[1] === 'eth') {
+        return 'registrar';
+    }
+    return 'nameWrapper';
+};
+const raw = async (ensArgs, name, { contract } = {}) => {
+    const labels = name.split('.');
+    const contractToUse = getContractToUse(contract, labels);
+    return contractToUse === 'nameWrapper'
+        ? getWrapperExpiry(ensArgs, labels)
+        : getRegistrarExpiry(ensArgs, labels);
+};
+const decodeRegistrarExpiry = async ({ contracts, multicallWrapper }, data) => {
     const result = await multicallWrapper.decode(data);
     const baseRegistrar = await contracts?.getBaseRegistrar();
     try {
@@ -37,6 +60,28 @@ const decode = async ({ contracts, multicallWrapper }, data) => {
         return;
     }
 };
+const decodeWrapperExpiry = async ({ contracts }, data) => {
+    const nameWrapper = await contracts?.getNameWrapper();
+    try {
+        const [_owner, _fuses, expiry] = nameWrapper.interface.decodeFunctionResult('getData', data);
+        return {
+            expiry: new Date(expiry * 1000),
+            gracePeriod: null,
+        };
+    }
+    catch {
+        return;
+    }
+};
+const decode = async (ensArgs, data, name, { contract } = {}) => {
+    if (data === null)
+        return;
+    const labels = name.split('.');
+    const contractToUse = getContractToUse(contract, labels);
+    return contractToUse === 'nameWrapper'
+        ? decodeWrapperExpiry(ensArgs, data)
+        : decodeRegistrarExpiry(ensArgs, data);
+};
 export default {
     raw,
     decode,

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

@@ -7,10 +7,9 @@ declare const _default: {
     }>;
     decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
         fuseObj: {
-            [k: string]: any;
+            [k: string]: boolean;
         };
-        vulnerability: any;
-        vulnerableNode: null;
+        expiryDate: Date;
         rawFuses: BigNumber;
     } | undefined>;
 };

package/dist/esm/functions/getFuses.js

@@ -1,4 +1,4 @@
-import { utils } from 'ethers';
+import { BigNumber } from 'ethers';
 import { testable as fuseEnums } from '../utils/fuses';
 import { namehash } from '../utils/normalise';
 const NameSafety = [
@@ -20,7 +20,8 @@ const raw = async ({ contracts }, name) => {
 const decode = async ({ contracts }, data, name) => {
     const nameWrapper = await contracts?.getNameWrapper();
     try {
-        const [fuses, vulnerability, vulnerableNode] = nameWrapper.interface.decodeFunctionResult('getFuses', data);
+        const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult('getFuses', data);
+        const fuses = BigNumber.from(_fuses);
         const fuseObj = Object.fromEntries(Object.keys(fuseEnums).map((fuseEnum) => [
             fuseEnum
                 .toLowerCase()
@@ -33,20 +34,10 @@ const decode = async ({ contracts }, data, name) => {
         else {
             fuseObj.canDoEverything = false;
         }
-        let returnVulnerableNode = null;
-        if (utils.hexStripZeros(vulnerableNode) !== '0x') {
-            name.split('.').forEach((label, index, arr) => {
-                const node = arr.slice(index).join('.');
-                const nodehash = namehash(node);
-                if (nodehash === vulnerableNode) {
-                    returnVulnerableNode = node;
-                }
-            });
-        }
+        const expiryDate = new Date(expiry * 1000);
         return {
             fuseObj,
-            vulnerability: NameSafety[vulnerability] || vulnerability,
-            vulnerableNode: returnVulnerableNode,
+            expiryDate,
             rawFuses: fuses,
         };
     }

package/dist/esm/functions/getSpecificRecord.js

@@ -13,8 +13,15 @@ export const _getContentHash = {
         };
     },
     decode: async ({ contracts }, data) => {
+        let response;
         const publicResolver = await contracts?.getPublicResolver();
-        const [response] = publicResolver.interface.decodeFunctionResult('contenthash', data);
+        try {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('contenthash', data);
+        }
+        catch {
+            return;
+        }
         if (!response) {
             return;
         }

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

@@ -16,7 +16,7 @@ declare type Params = {
     pageSize?: number;
     orderDirection?: 'asc' | 'desc';
     orderBy?: 'createdAt' | 'labelName';
-    lastSubnames: Array<any>;
+    lastSubnames?: Array<any>;
     isLargeQuery?: boolean;
 };
 declare const getSubnames: (injected: ENSArgs<'gqlInstance'>, functionArgs: Params) => Promise<{

package/dist/esm/functions/getSubnames.js

@@ -1,7 +1,7 @@
 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 largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames = [], }) => {
     const client = gqlInstance.client;
     let finalQuery = gqlInstance.gql `
     query getSubnames(

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

@@ -1,6 +1,15 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, address, }: {
+import { Expiry } from '../utils/wrapperExpiry';
+declare type BaseArgs = {
+    owner: string;
+    resolverAddress?: string;
     contract: 'registry' | 'nameWrapper';
-    address: string;
-}): Promise<ethers.PopulatedTransaction>;
+};
+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/esm/functions/transferSubname.js

@@ -1,6 +1,7 @@
 import { ethers } from 'ethers';
 import { namehash } from '../utils/normalise';
-export default async function ({ contracts, signer }, name, { contract, address, }) {
+import { makeExpiry } from '../utils/wrapperExpiry';
+export default async function ({ contracts, signer, getExpiry, }, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
     const labels = name.split('.');
     const label = labels.shift();
     const labelhash = ethers.utils.solidityKeccak256(['string'], [label]);
@@ -8,11 +9,12 @@ export default async function ({ contracts, signer }, name, { contract, address,
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.populateTransaction.setSubnodeOwner(parentNodehash, labelhash, address);
+            return registry.populateTransaction.setSubnodeOwner(parentNodehash, labelhash, owner);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            return nameWrapper.populateTransaction.setSubnodeOwner(parentNodehash, label, address, '0');
+            const expiry = await 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/esm/functions/wrapName.d.ts

@@ -1,8 +1,10 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import type { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, signer, populate }: ENSArgs<'contracts' | 'signer' | 'populate'>, name: string, { wrappedOwner, fuseOptions, resolverAddress, }: {
+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/esm/functions/wrapName.js

@@ -1,54 +1,60 @@
 import { ethers } from 'ethers';
 import generateFuseInput from '../utils/generateFuseInput';
 import { hexEncodeName } from '../utils/hexEncodedName';
-async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address) {
+import { makeExpiry } from '../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.utils.solidityKeccak256(['string'], [labels[0]]);
-    const data = ethers.utils.defaultAbiCoder.encode(['string', 'address', 'uint32', 'uint64', 'address'], [labels[0], wrappedOwner, '0x0', decodedFuses, resolverAddress]);
+    const data = 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, signer) {
+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.populateTransaction.wrap(hexEncodeName(name), wrappedOwner, decodedFuses, resolverAddress);
+    return nameWrapper.populateTransaction.wrap(hexEncodeName(name), wrappedOwner, resolverAddress);
 }
-export default async function ({ contracts, signer, populate }, name, { wrappedOwner, fuseOptions, resolverAddress, }) {
+export default async function ({ contracts, signer, getExpiry, }, name, { wrappedOwner, fuseOptions, expiry, resolverAddress, }) {
     const address = await signer.getAddress();
     let decodedFuses;
-    switch (typeof fuseOptions) {
-        case 'object': {
-            decodedFuses = generateFuseInput(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 = generateFuseInput(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 makeExpiry({ getExpiry }, name, expiry);
+        return wrapETH({ contracts }, labels, wrappedOwner, expiryToUse, decodedFuses, resolverAddress, signer, address);
     }
     else {
-        return wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address, signer);
+        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);
     }
 }