@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

package/dist/cjs/GqlManager.d.ts

@@ -0,0 +1,9 @@
+export declare const enter: (node: any) => any;
+export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
+export declare const responseMiddleware: (traverse: any) => (response: any) => any;
+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,102 @@
+"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 });
+exports.responseMiddleware = exports.requestMiddleware = exports.enter = void 0;
+// @ts-nocheck
+const normalise_1 = require("./utils/normalise");
+const generateSelection = (selection) => ({
+    kind: 'Field',
+    name: {
+        kind: 'Name',
+        value: selection,
+    },
+    arguments: [],
+    directives: [],
+    alias: undefined,
+    selectionSet: undefined,
+});
+const enter = (node) => {
+    if (node.kind === 'SelectionSet') {
+        const id = node.selections.find((x) => x.name && x.name.value === 'id');
+        const name = node.selections.find((x) => x.name && x.name.value === 'name');
+        if (!id && name) {
+            node.selections = [...node.selections, generateSelection('id')];
+            return node;
+        }
+    }
+};
+exports.enter = enter;
+const requestMiddleware = (visit, parse) => (request) => {
+    const requestBody = JSON.parse(request.body);
+    const rawQuery = requestBody.query;
+    const parsedQuery = parse(rawQuery);
+    const updatedQuery = visit(parsedQuery, { enter: exports.enter });
+    const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body };
+    return {
+        ...request,
+        body: JSON.stringify(updatedBody),
+    };
+};
+exports.requestMiddleware = requestMiddleware;
+const responseMiddleware = (traverse) => (response) => {
+    traverse(response).forEach(function (responseItem) {
+        if (responseItem instanceof Object && responseItem.name) {
+            //Name already in hashed form
+            if (responseItem.name && responseItem.name.includes('[')) {
+                return;
+            }
+            const hashedName = (0, normalise_1.namehash)(responseItem.name);
+            if (responseItem.id !== hashedName) {
+                this.update({ ...responseItem, name: hashedName, invalidName: true });
+            }
+        }
+    });
+    return response;
+};
+exports.responseMiddleware = responseMiddleware;
+class GqlManager {
+    gql = () => null;
+    client = null;
+    setUrl = async (url) => {
+        if (url) {
+            const [imported, traverse, { visit, parse }] = await Promise.all([
+                Promise.resolve().then(() => __importStar(require('graphql-request'))),
+                Promise.resolve().then(() => __importStar(require('traverse'))),
+                Promise.resolve().then(() => __importStar(require('graphql/language'))),
+            ]);
+            this.client = new imported.GraphQLClient(url, {
+                requestMiddleware: (0, exports.requestMiddleware)(visit, parse),
+                responseMiddleware: (0, exports.responseMiddleware)(traverse.default),
+            });
+            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;
+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/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>;
+    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>;
+    getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
+    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").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;
+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;
+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,5 @@
+import { ENSArgs } from '..';
+import { FuseOptions } from '../@types/FuseOptions';
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { fusesToBurn, }: {
+    fusesToBurn: FuseOptions;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/burnFuses.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
+const normalise_1 = require("../utils/normalise");
+async function default_1({ contracts, signer }, name, { fusesToBurn, }) {
+    const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+    const hash = (0, normalise_1.namehash)(name);
+    const encodedFuses = (0, generateFuseInput_1.default)(fusesToBurn);
+    return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
+}
+exports.default = default_1;

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

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

package/dist/cjs/functions/createSubname.js

@@ -0,0 +1,42 @@
+"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"));
+const normalise_1 = require("../utils/normalise");
+const wrapperExpiry_1 = require("../utils/wrapperExpiry");
+async function default_1({ 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');
+    }
+    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 = (0, normalise_1.namehash)(labels.join('.'));
+    switch (contract) {
+        case 'registry': {
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.populateTransaction.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            const expiry = await (0, wrapperExpiry_1.makeExpiry)({ getExpiry }, name, 'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined);
+            const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
+                ? (0, generateFuseInput_1.default)(wrapperArgs.fuses)
+                : '0';
+            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses, expiry);
+        }
+        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 ({ transferSubname, signer }: ENSArgs<'transferSubname' | 'signer'>, name: string, { contract, }: {
+    contract: 'registry' | 'nameWrapper';
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/deleteSubname.js

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

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

@@ -0,0 +1,7 @@
+import * as packet from 'dns-packet';
+export declare function encodeURLParams(p: {
+    [key: string]: string;
+}): string;
+export declare const getDNS: (q: packet.Packet) => Promise<packet.Packet>;
+export declare const dnsQuery: (qtype: string, qname: string) => Promise<packet.Packet>;
+export default function (_: any, dnsName: string): Promise<any>;