@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.1

package/dist/cjs/GqlManager.d.ts

@@ -0,0 +1,6 @@
+export default class GqlManager {
+    gql: any;
+    client?: any | null;
+    setUrl: (url: string | null) => Promise<void>;
+    request: (...arg: any[]) => any;
+}

package/dist/cjs/GqlManager.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class GqlManager {
+    gql = () => null;
+    client = null;
+    setUrl = async (url) => {
+        if (url) {
+            const imported = await Promise.resolve().then(() => __importStar(require('graphql-request')));
+            this.client = new imported.GraphQLClient(url);
+            this.gql = imported.gql;
+        }
+        else {
+            this.client = null;
+            this.gql = () => null;
+        }
+    };
+    request = (...arg) => this.client ? this.client.request(...arg) : null;
+}
+exports.default = GqlManager;

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

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

package/dist/cjs/contracts/baseRegistrar.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseRegistrarImplementation__factory_1 = require("../generated/factories/BaseRegistrarImplementation__factory");
+exports.default = (provider, address) => BaseRegistrarImplementation__factory_1.BaseRegistrarImplementation__factory.connect(address, provider);

package/dist/cjs/contracts/doNotCallOnChainUniversalResolverProxy.d.ts

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

package/dist/cjs/contracts/doNotCallOnChainUniversalResolverProxy.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DoNotCallOnChainUniversalResolverProxy__factory_1 = require("../generated/factories/DoNotCallOnChainUniversalResolverProxy__factory");
+exports.default = (provider, address) => DoNotCallOnChainUniversalResolverProxy__factory_1.DoNotCallOnChainUniversalResolverProxy__factory.connect(address, provider);

package/dist/cjs/contracts/ethRegistrarController.d.ts

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

package/dist/cjs/contracts/ethRegistrarController.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ETHRegistrarController__factory_1 = require("../generated/factories/ETHRegistrarController__factory");
+exports.default = (provider, address) => ETHRegistrarController__factory_1.ETHRegistrarController__factory.connect(address, provider);

package/dist/cjs/contracts/getContractAddress.d.ts

@@ -0,0 +1,3 @@
+import { ContractName, SupportedNetworkId } from './types';
+export declare type ContractAddressFetch = (contractName: ContractName) => string;
+export declare const getContractAddress: (networkId: SupportedNetworkId) => ContractAddressFetch;

package/dist/cjs/contracts/getContractAddress.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContractAddress = void 0;
+const addresses = {
+    BaseRegistrarImplementation: {
+        '1': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
+        '3': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
+        '4': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
+        '5': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
+    },
+    ETHRegistrarController: {
+        '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+        '3': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+        '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+        '5': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+    },
+    Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
+    NameWrapper: '0x0000000000000000000000000000000000000000',
+    PublicResolver: {
+        '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
+    },
+    ENSRegistryWithFallback: {
+        '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
+        '3': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
+        '4': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
+        '5': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
+    },
+    ReverseRegistrar: {
+        '1': '0x084b1c3C81545d370f3634392De611CaaBFf8148',
+    },
+    UniversalResolver: {
+        '1': '0x580AF46E06DaaD47eb5940526FD64d95b815Cb70',
+        '4': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
+    },
+};
+const getContractAddress = (networkId) => ((contractName) => {
+    try {
+        return typeof addresses[contractName] === 'string'
+            ? addresses[contractName]
+            : addresses[contractName][networkId];
+    }
+    catch {
+        throw new Error(`No address for contract ${contractName} on network ${networkId}`);
+    }
+});
+exports.getContractAddress = getContractAddress;

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

@@ -0,0 +1,16 @@
+import { ethers } from 'ethers';
+import { ContractAddressFetch } from './getContractAddress';
+export default class ContractManager {
+    private provider;
+    private fetchAddress;
+    constructor(provider: ethers.providers.Provider, fetchAddress: ContractAddressFetch);
+    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>;
+    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>;
+    getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
+    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/Multicall").Multicall>;
+}

package/dist/cjs/contracts/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const baseRegistrar_1 = __importDefault(require("./baseRegistrar"));
+const ethRegistrarController_1 = __importDefault(require("./ethRegistrarController"));
+const multicall_1 = __importDefault(require("./multicall"));
+const nameWrapper_1 = __importDefault(require("./nameWrapper"));
+const publicResolver_1 = __importDefault(require("./publicResolver"));
+const registry_1 = __importDefault(require("./registry"));
+const reverseRegistrar_1 = __importDefault(require("./reverseRegistrar"));
+const universalResolver_1 = __importDefault(require("./universalResolver"));
+class ContractManager {
+    provider;
+    fetchAddress;
+    constructor(provider, fetchAddress) {
+        this.provider = provider;
+        this.fetchAddress = fetchAddress;
+    }
+    generateContractGetter = (name, func) => {
+        return async (passedProvider, address) => {
+            const inputAddress = address || this.fetchAddress(name);
+            const provider = passedProvider || this.provider;
+            return func(provider, inputAddress);
+        };
+    };
+    getPublicResolver = this.generateContractGetter('PublicResolver', publicResolver_1.default);
+    getUniversalResolver = this.generateContractGetter('UniversalResolver', universalResolver_1.default);
+    getRegistry = this.generateContractGetter('ENSRegistryWithFallback', registry_1.default);
+    getReverseRegistrar = this.generateContractGetter('ReverseRegistrar', reverseRegistrar_1.default);
+    getNameWrapper = this.generateContractGetter('NameWrapper', nameWrapper_1.default);
+    getBaseRegistrar = this.generateContractGetter('BaseRegistrarImplementation', baseRegistrar_1.default);
+    getEthRegistrarController = this.generateContractGetter('ETHRegistrarController', ethRegistrarController_1.default);
+    getMulticall = this.generateContractGetter('Multicall', multicall_1.default);
+}
+exports.default = ContractManager;

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

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

package/dist/cjs/contracts/multicall.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Multicall__factory_1 = require("../generated/factories/Multicall__factory");
+const ABI = [
+    'function aggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes[] returnData)',
+    'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
+    'function aggregate3Value(tuple(address target, bool allowFailure, uint256 value, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
+    'function blockAndAggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
+    'function getBasefee() view returns (uint256 basefee)',
+    'function getBlockHash(uint256 blockNumber) view returns (bytes32 blockHash)',
+    'function getBlockNumber() view returns (uint256 blockNumber)',
+    'function getChainId() view returns (uint256 chainid)',
+    'function getCurrentBlockCoinbase() view returns (address coinbase)',
+    'function getCurrentBlockDifficulty() view returns (uint256 difficulty)',
+    'function getCurrentBlockGasLimit() view returns (uint256 gaslimit)',
+    'function getCurrentBlockTimestamp() view returns (uint256 timestamp)',
+    'function getEthBalance(address addr) view returns (uint256 balance)',
+    'function getLastBlockHash() view returns (bytes32 blockHash)',
+    'function tryAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
+    'function tryBlockAndAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
+];
+exports.default = (provider, address) => Multicall__factory_1.Multicall__factory.connect(address, provider);

package/dist/cjs/contracts/nameWrapper.d.ts

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

package/dist/cjs/contracts/nameWrapper.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const NameWrapper__factory_1 = require("../generated/factories/NameWrapper__factory");
+exports.default = (provider, address) => NameWrapper__factory_1.NameWrapper__factory.connect(address, provider);

package/dist/cjs/contracts/publicResolver.d.ts

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

package/dist/cjs/contracts/publicResolver.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PublicResolver__factory_1 = require("../generated/factories/PublicResolver__factory");
+exports.default = (provider, address) => PublicResolver__factory_1.PublicResolver__factory.connect(address, provider);

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

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

package/dist/cjs/contracts/registry.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ENSRegistry__factory_1 = require("../generated/factories/ENSRegistry__factory");
+exports.default = (provider, address) => ENSRegistry__factory_1.ENSRegistry__factory.connect(address, provider);

package/dist/cjs/contracts/reverseRegistrar.d.ts

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

package/dist/cjs/contracts/reverseRegistrar.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ReverseRegistrar__factory_1 = require("../generated/factories/ReverseRegistrar__factory");
+exports.default = (provider, address) => ReverseRegistrar__factory_1.ReverseRegistrar__factory.connect(address, provider);

package/dist/cjs/contracts/types.d.ts

@@ -0,0 +1,2 @@
+export declare type SupportedNetworkId = '1' | '3' | '4' | '5' | '1337';
+export declare type ContractName = 'BaseRegistrarImplementation' | 'ETHRegistrarController' | 'Multicall' | 'NameWrapper' | 'PublicResolver' | 'ENSRegistryWithFallback' | 'ReverseRegistrar' | 'UniversalResolver';

package/dist/cjs/contracts/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/contracts/universalResolver.d.ts

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

package/dist/cjs/contracts/universalResolver.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const UniversalResolver__factory_1 = require("../generated/factories/UniversalResolver__factory");
+exports.default = (provider, address) => UniversalResolver__factory_1.UniversalResolver__factory.connect(address, provider);

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

@@ -0,0 +1,9 @@
+import { BatchFunctionResult, ENSArgs, RawFunction } from '..';
+declare const _default: {
+    raw: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, ...items: BatchFunctionResult<RawFunction>[]) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
+};
+export default _default;

package/dist/cjs/functions/batch.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const raw = async ({ multicallWrapper }, ...items) => {
+    const rawDataArr = await Promise.all(items.map(({ args, raw }, i) => {
+        if (!raw) {
+            throw new Error(`Function ${i} is not batchable`);
+        }
+        return raw(...args);
+    }));
+    return multicallWrapper.raw(rawDataArr);
+};
+const decode = async ({ multicallWrapper }, data, ...items) => {
+    const response = await multicallWrapper.decode(data);
+    if (!response)
+        return;
+    return Promise.all(response.map((ret, i) => items[i].decode(ret.returnData, ...items[i].args)));
+};
+exports.default = {
+    raw,
+    decode,
+};

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

@@ -0,0 +1,29 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+export declare const universalWrapper: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, data: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<{
+        data: any;
+        resolver: any;
+    } | undefined>;
+};
+export declare const resolverMulticallWrapper: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, data: {
+        to: string;
+        data: string;
+    }[]) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<ethers.utils.Result | undefined>;
+};
+export declare const multicallWrapper: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
+};

package/dist/cjs/functions/batchWrappers.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multicallWrapper = exports.resolverMulticallWrapper = exports.universalWrapper = void 0;
+const hexEncodedName_1 = require("../utils/hexEncodedName");
+exports.universalWrapper = {
+    raw: async ({ contracts }, name, data) => {
+        const universalResolver = await contracts?.getUniversalResolver();
+        return {
+            to: universalResolver.address,
+            data: universalResolver.interface.encodeFunctionData('resolve', [
+                (0, hexEncodedName_1.hexEncodeName)(name),
+                data,
+            ]),
+        };
+    },
+    decode: async ({ contracts }, data) => {
+        const universalResolver = await contracts?.getUniversalResolver();
+        const response = universalResolver.interface.decodeFunctionResult('resolve', data);
+        if (!response || !response[0]) {
+            return;
+        }
+        return { data: response[0], resolver: response[1] };
+    },
+};
+exports.resolverMulticallWrapper = {
+    raw: async ({ contracts }, data) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        const formattedDataArr = data.map((item) => item.data);
+        return {
+            to: publicResolver.address,
+            data: publicResolver.interface.encodeFunctionData('multicall', [
+                formattedDataArr,
+            ]),
+        };
+    },
+    decode: async ({ contracts }, data) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        const response = publicResolver.interface.decodeFunctionResult('multicall', data);
+        if (!response) {
+            return;
+        }
+        return response;
+    },
+};
+exports.multicallWrapper = {
+    raw: async function ({ contracts }, transactions, requireSuccess = false) {
+        const multicall = await contracts?.getMulticall();
+        return {
+            to: multicall.address,
+            data: multicall.interface.encodeFunctionData('tryAggregate', [
+                requireSuccess,
+                transactions.map((tx) => ({
+                    target: tx.to,
+                    callData: tx.data,
+                })),
+            ]),
+        };
+    },
+    decode: async function ({ contracts }, data) {
+        if (!data)
+            return;
+        const multicall = await contracts?.getMulticall();
+        try {
+            const [result] = multicall.interface.decodeFunctionResult('tryAggregate', data);
+            return result;
+        }
+        catch {
+            return;
+        }
+    },
+};

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

@@ -0,0 +1,4 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+import { FuseOptions } from '../@types/FuseOptions';
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, fusesToBurn: FuseOptions): Promise<ethers.ContractTransaction>;

package/dist/cjs/functions/burnFuses.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
+async function default_1({ contracts, provider }, name, fusesToBurn) {
+    const signer = provider?.getSigner();
+    if (!signer) {
+        throw new Error('No signer found');
+    }
+    const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+    const namehash = ethers_1.ethers.utils.namehash(name);
+    const encodedFuses = (0, generateFuseInput_1.default)(fusesToBurn);
+    return nameWrapper.burnFuses(namehash, encodedFuses);
+}
+exports.default = default_1;

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

@@ -0,0 +1,19 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+import { FuseOptions } from '../@types/FuseOptions';
+declare type BaseArgs = {
+    name: string;
+    owner: string;
+    resolverAddress?: string;
+    contract: 'registry' | 'nameWrapper';
+    options?: {
+        addressOrIndex?: string | number;
+    };
+};
+declare type NameWrapperArgs = {
+    contract: 'nameWrapper';
+    fuses?: FuseOptions;
+} & BaseArgs;
+declare type Args = BaseArgs | NameWrapperArgs;
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, { name, owner, resolverAddress, contract, options, ...wrapperArgs }: Args): Promise<ethers.ContractTransaction>;
+export {};

package/dist/cjs/functions/createSubname.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
+async function default_1({ contracts, provider }, { name, owner, resolverAddress, contract, options, ...wrapperArgs }) {
+    const signer = provider?.getSigner(options?.addressOrIndex);
+    if (!signer) {
+        throw new Error('No signer found');
+    }
+    const labels = name.split('.');
+    if (labels.length === 1) {
+        throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');
+    }
+    if ('fuses' in wrapperArgs && contract === 'registry') {
+        throw new Error('Fuses can only be set on a wrapped name');
+    }
+    if (!resolverAddress) {
+        resolverAddress = (await contracts?.getPublicResolver()).address;
+    }
+    const label = labels.shift();
+    const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [label]);
+    const parentNodehash = ethers_1.ethers.utils.namehash(labels.join('.'));
+    switch (contract) {
+        case 'registry': {
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
+                ? (0, generateFuseInput_1.default)(wrapperArgs.fuses)
+                : '0';
+            return nameWrapper.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
+        }
+        default: {
+            throw new Error(`Unknown contract: ${contract}`);
+        }
+    }
+}
+exports.default = default_1;

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

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

package/dist/cjs/functions/deleteSubname.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function default_1({ contracts, provider, transferSubname, }, name, contract, options) {
+    return transferSubname(name, contract, '0x0000000000000000000000000000000000000000', options);
+}
+exports.default = default_1;

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

@@ -0,0 +1,12 @@
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
+        expiry: Date | null;
+        gracePeriod: number;
+    } | undefined>;
+};
+export default _default;

package/dist/cjs/functions/getExpiry.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("ethers/lib/utils");
+const raw = async ({ contracts, multicallWrapper }, name) => {
+    const baseRegistrar = await contracts?.getBaseRegistrar();
+    const labels = name.split('.');
+    if (labels.length > 2 || labels[1] !== 'eth') {
+        throw new Error('Only .eth names have expiry dates');
+    }
+    const expiryCall = baseRegistrar.interface.encodeFunctionData('nameExpires', [
+        (0, utils_1.solidityKeccak256)(['string'], [labels[0]]),
+    ]);
+    const gracePeriodCall = baseRegistrar.interface.encodeFunctionData('GRACE_PERIOD');
+    return multicallWrapper.raw([
+        {
+            to: baseRegistrar.address,
+            data: expiryCall,
+        },
+        {
+            to: baseRegistrar.address,
+            data: gracePeriodCall,
+        },
+    ]);
+};
+const decode = async ({ contracts, multicallWrapper }, data) => {
+    if (data === null)
+        return;
+    const result = await multicallWrapper.decode(data);
+    const baseRegistrar = await contracts?.getBaseRegistrar();
+    try {
+        const [nameExpires] = baseRegistrar.interface.decodeFunctionResult('nameExpires', result[0].returnData);
+        const [gracePeriod] = baseRegistrar.interface.decodeFunctionResult('GRACE_PERIOD', result[1].returnData);
+        return {
+            expiry: nameExpires > 0 ? new Date(nameExpires * 1000) : null,
+            gracePeriod: gracePeriod.toNumber() * 1000,
+        };
+    }
+    catch {
+        return;
+    }
+};
+exports.default = {
+    raw,
+    decode,
+};

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

@@ -0,0 +1,17 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
+        fuseObj: {
+            [k: string]: any;
+        };
+        vulnerability: any;
+        vulnerableNode: null;
+        rawFuses: BigNumber;
+    } | undefined>;
+};
+export default _default;