@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.3

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

@@ -0,0 +1,2 @@
+export declare const normalise: (name: string) => any;
+export declare const namehash: (inputName: string) => string;

package/dist/cjs/utils/normalise.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.namehash = exports.normalise = void 0;
+const utils_1 = require("ethers/lib/utils");
+const uts46bundle_js_1 = __importDefault(require("idna-uts46-hx/uts46bundle.js"));
+const zeros = new Uint8Array(32);
+zeros.fill(0);
+const normalise = (name) => name ? uts46bundle_js_1.default.toUnicode(name, { useStd3ASCII: true }) : name;
+exports.normalise = normalise;
+const namehash = (inputName) => {
+    let result = zeros;
+    const name = (0, exports.normalise)(inputName);
+    if (name) {
+        const labels = name.split('.');
+        for (var i = labels.length - 1; i >= 0; i--) {
+            const labelSha = (0, utils_1.keccak256)((0, utils_1.toUtf8Bytes)(labels[i]));
+            result = (0, utils_1.keccak256)((0, utils_1.concat)([result, labelSha]));
+        }
+    }
+    else {
+        result = (0, utils_1.hexlify)(zeros);
+    }
+    return result;
+};
+exports.namehash = namehash;

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

@@ -0,0 +1,13 @@
+import type { PublicResolver } from '../generated';
+declare type RecordItem = {
+    key: string;
+    value: string;
+};
+export declare type RecordOptions = {
+    contentHash?: string;
+    texts?: RecordItem[];
+    coinTypes?: RecordItem[];
+};
+export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
+export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
+export {};

package/dist/cjs/utils/recordHelpers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRecordCallArray = exports.generateSetAddr = void 0;
+const address_encoder_1 = require("@ensdomains/address-encoder");
+const contentHash_1 = require("./contentHash");
+const generateSetAddr = (namehash, coinType, address, resolver) => {
+    let coinTypeInstance;
+    if (!isNaN(parseInt(coinType))) {
+        coinTypeInstance = address_encoder_1.formatsByCoinType[parseInt(coinType)];
+    }
+    else {
+        coinTypeInstance = address_encoder_1.formatsByName[coinType.toUpperCase()];
+    }
+    const inputCoinType = coinTypeInstance.coinType;
+    const encodedAddress = coinTypeInstance.decoder(address);
+    return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
+};
+exports.generateSetAddr = generateSetAddr;
+const generateRecordCallArray = (namehash, records, resolver) => {
+    const calls = [];
+    if (records.contentHash) {
+        const contentHash = records.contentHash === '' ? '' : (0, contentHash_1.encodeContenthash)(records.contentHash);
+        const data = resolver?.interface.encodeFunctionData('setContenthash', [namehash, contentHash]);
+        data && calls.push(data);
+    }
+    if (records.texts && records.texts.length > 0) {
+        records.texts.forEach(({ key, value }) => {
+            const data = resolver?.interface.encodeFunctionData('setText', [
+                namehash,
+                key,
+                value,
+            ]);
+            data && calls.push(data);
+        });
+    }
+    if (records.coinTypes && records.coinTypes.length > 0) {
+        records.coinTypes.forEach(({ key, value }) => {
+            const data = (0, exports.generateSetAddr)(namehash, key, value, resolver);
+            data && calls.push(data);
+        });
+    }
+    return calls;
+};
+exports.generateRecordCallArray = generateRecordCallArray;

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

@@ -0,0 +1,26 @@
+import type { FuseOptions } from '../@types/FuseOptions';
+import type { PublicResolver } from '../generated';
+import { RecordOptions } from './recordHelpers';
+export declare const randomSecret: () => string;
+export declare const makeCommitment: ({ name, owner, duration, resolver, records, reverseRecord, fuses, }: {
+    name: string;
+    owner: string;
+    duration: number;
+    resolver: PublicResolver;
+    records?: RecordOptions | undefined;
+    reverseRecord?: boolean | undefined;
+    fuses?: FuseOptions | undefined;
+}) => {
+    secret: string;
+    commitment: string;
+};
+export declare const _makeCommitment: ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }: {
+    labelhash: string;
+    owner: string;
+    duration: number;
+    secret: string;
+    resolver: string;
+    data: string[];
+    reverseRecord: boolean;
+    fuses: string;
+}) => string;

package/dist/cjs/utils/registerHelpers.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._makeCommitment = exports.makeCommitment = exports.randomSecret = void 0;
+const ethers_1 = require("ethers");
+const generateFuseInput_1 = __importDefault(require("./generateFuseInput"));
+const labels_1 = require("./labels");
+const normalise_1 = require("./normalise");
+const recordHelpers_1 = require("./recordHelpers");
+const randomSecret = () => {
+    const bytes = Buffer.allocUnsafe(32);
+    return '0x' + crypto.getRandomValues(bytes).toString('hex');
+};
+exports.randomSecret = randomSecret;
+const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
+    const label = (0, labels_1.labelhash)(name.split('.')[0]);
+    const hash = (0, normalise_1.namehash)(name);
+    const resolverAddress = resolver.address;
+    const data = records ? (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver) : [];
+    const secret = (0, exports.randomSecret)();
+    const fuseData = fuses ? (0, generateFuseInput_1.default)(fuses) : '0';
+    const commitment = (0, exports._makeCommitment)({
+        labelhash: label,
+        owner,
+        duration,
+        secret,
+        resolver: resolverAddress,
+        data,
+        reverseRecord: !!reverseRecord,
+        fuses: fuseData,
+    });
+    return {
+        secret,
+        commitment,
+    };
+};
+exports.makeCommitment = makeCommitment;
+const _makeCommitment = ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }) => {
+    return ethers_1.utils.solidityKeccak256([
+        'bytes32',
+        'address',
+        'uint256',
+        'bytes32',
+        'address',
+        'bytes[]',
+        'bool',
+        'uint96',
+    ], [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses]);
+};
+exports._makeCommitment = _makeCommitment;

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

@@ -0,0 +1,9 @@
+import { ethers } from 'ethers';
+declare const _default: (provider: ethers.providers.Provider, ensData: any, func: {
+    raw: (...args: any[]) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: (...args: any[]) => Promise<any>;
+}, ...data: any[]) => Promise<any>;
+export default _default;

package/dist/cjs/utils/singleCall.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = async (provider, ensData, func, ...data) => func
+    .raw(ensData, ...data)
+    .then((rawData) => provider.call(rawData))
+    .catch(() => null)
+    .then((ret) => func.decode(ensData, ret, ...data));

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

@@ -0,0 +1,8 @@
+export declare const validateName: (name: string) => string;
+export declare const validateTLD: (name: string) => string;
+declare type InputType = {
+    type: 'name' | 'label' | 'address' | 'unknown';
+    info?: 'short' | 'supported' | 'unsupported';
+};
+export declare const parseInputType: (input: string) => InputType;
+export {};

package/dist/cjs/utils/validation.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInputType = exports.validateTLD = exports.validateName = void 0;
+const utils_1 = require("ethers/lib/utils");
+const labels_1 = require("./labels");
+const normalise_1 = require("./normalise");
+const validateName = (name) => {
+    const nameArray = name.split('.');
+    const hasEmptyLabels = nameArray.some((label) => label.length == 0);
+    if (hasEmptyLabels)
+        throw new Error('Name cannot have empty labels');
+    const normalizedArray = nameArray.map((label) => {
+        if (label === '[root]') {
+            return label;
+        }
+        else {
+            return (0, labels_1.isEncodedLabelhash)(label) ? label : (0, normalise_1.normalise)(label);
+        }
+    });
+    const normalizedName = normalizedArray.join('.');
+    (0, labels_1.saveName)(normalizedName);
+    return normalizedName;
+};
+exports.validateName = validateName;
+const validateTLD = (name) => {
+    const labels = name.split('.');
+    return (0, exports.validateName)(labels[labels.length - 1]);
+};
+exports.validateTLD = validateTLD;
+const parseInputType = (input) => {
+    const validTLD = (0, exports.validateTLD)(input);
+    let regex = /[^.]+$/;
+    try {
+        (0, exports.validateName)(input);
+    }
+    catch (e) {
+        return {
+            type: 'unknown',
+        };
+    }
+    if (input.indexOf('.') !== -1) {
+        const termArray = input.split('.');
+        const tld = input.match(regex) ? input.match(regex)[0] : '';
+        if (validTLD) {
+            if (tld === 'eth' && [...termArray[termArray.length - 2]].length < 3) {
+                // code-point length
+                return {
+                    type: 'name',
+                    info: 'short',
+                };
+            }
+            return {
+                type: 'name',
+                info: 'supported',
+            };
+        }
+        return {
+            type: 'name',
+            info: 'unsupported',
+        };
+    }
+    else if ((0, utils_1.isAddress)(input)) {
+        return {
+            type: 'address',
+        };
+    }
+    else {
+        return {
+            type: 'label',
+        };
+    }
+};
+exports.parseInputType = parseInputType;

package/dist/esm/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/esm/GqlManager.js

@@ -0,0 +1,18 @@
+export default class GqlManager {
+    constructor() {
+        this.gql = () => null;
+        this.client = null;
+        this.setUrl = async (url) => {
+            if (url) {
+                const imported = await import('graphql-request');
+                this.client = new imported.GraphQLClient(url);
+                this.gql = imported.gql;
+            }
+            else {
+                this.client = null;
+                this.gql = () => null;
+            }
+        };
+        this.request = (...arg) => this.client ? this.client.request(...arg) : null;
+    }
+}

package/dist/esm/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/esm/contracts/baseRegistrar.js

@@ -0,0 +1,2 @@
+import { BaseRegistrarImplementation__factory } from '../generated/factories/BaseRegistrarImplementation__factory';
+export default (provider, address) => BaseRegistrarImplementation__factory.connect(address, provider);

package/dist/esm/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/esm/contracts/doNotCallOnChainUniversalResolverProxy.js

@@ -0,0 +1,2 @@
+import { DoNotCallOnChainUniversalResolverProxy__factory } from '../generated/factories/DoNotCallOnChainUniversalResolverProxy__factory';
+export default (provider, address) => DoNotCallOnChainUniversalResolverProxy__factory.connect(address, provider);

package/dist/esm/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/esm/contracts/ethRegistrarController.js

@@ -0,0 +1,2 @@
+import { ETHRegistrarController__factory } from '../generated/factories/ETHRegistrarController__factory';
+export default (provider, address) => ETHRegistrarController__factory.connect(address, provider);

package/dist/esm/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/esm/contracts/getContractAddress.js

@@ -0,0 +1,42 @@
+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',
+    },
+};
+export 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}`);
+    }
+});

package/dist/esm/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/esm/contracts/index.js

@@ -0,0 +1,29 @@
+import getBaseRegistrar from './baseRegistrar';
+import getEthRegistrarController from './ethRegistrarController';
+import getMulticall from './multicall';
+import getNameWrapper from './nameWrapper';
+import getPublicResolver from './publicResolver';
+import getRegistry from './registry';
+import getReverseRegistrar from './reverseRegistrar';
+import getUniversalResolver from './universalResolver';
+export default class ContractManager {
+    constructor(provider, fetchAddress) {
+        this.generateContractGetter = (name, func) => {
+            return async (passedProvider, address) => {
+                const inputAddress = address || this.fetchAddress(name);
+                const provider = passedProvider || this.provider;
+                return func(provider, inputAddress);
+            };
+        };
+        this.getPublicResolver = this.generateContractGetter('PublicResolver', getPublicResolver);
+        this.getUniversalResolver = this.generateContractGetter('UniversalResolver', getUniversalResolver);
+        this.getRegistry = this.generateContractGetter('ENSRegistryWithFallback', getRegistry);
+        this.getReverseRegistrar = this.generateContractGetter('ReverseRegistrar', getReverseRegistrar);
+        this.getNameWrapper = this.generateContractGetter('NameWrapper', getNameWrapper);
+        this.getBaseRegistrar = this.generateContractGetter('BaseRegistrarImplementation', getBaseRegistrar);
+        this.getEthRegistrarController = this.generateContractGetter('ETHRegistrarController', getEthRegistrarController);
+        this.getMulticall = this.generateContractGetter('Multicall', getMulticall);
+        this.provider = provider;
+        this.fetchAddress = fetchAddress;
+    }
+}

package/dist/esm/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/esm/contracts/multicall.js

@@ -0,0 +1,20 @@
+import { Multicall__factory } from '../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)',
+];
+export default (provider, address) => Multicall__factory.connect(address, provider);

package/dist/esm/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/esm/contracts/nameWrapper.js

@@ -0,0 +1,2 @@
+import { NameWrapper__factory } from '../generated/factories/NameWrapper__factory';
+export default (provider, address) => NameWrapper__factory.connect(address, provider);

package/dist/esm/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/esm/contracts/publicResolver.js

@@ -0,0 +1,2 @@
+import { PublicResolver__factory } from '../generated/factories/PublicResolver__factory';
+export default (provider, address) => PublicResolver__factory.connect(address, provider);

package/dist/esm/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/esm/contracts/registry.js

@@ -0,0 +1,2 @@
+import { ENSRegistry__factory } from '../generated/factories/ENSRegistry__factory';
+export default (provider, address) => ENSRegistry__factory.connect(address, provider);

package/dist/esm/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/esm/contracts/reverseRegistrar.js

@@ -0,0 +1,2 @@
+import { ReverseRegistrar__factory } from '../generated/factories/ReverseRegistrar__factory';
+export default (provider, address) => ReverseRegistrar__factory.connect(address, provider);

package/dist/esm/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/esm/contracts/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/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/esm/contracts/universalResolver.js

@@ -0,0 +1,2 @@
+import { UniversalResolver__factory } from '../generated/factories/UniversalResolver__factory';
+export default (provider, address) => UniversalResolver__factory.connect(address, provider);

package/dist/esm/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/esm/functions/batch.js

@@ -0,0 +1,19 @@
+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)));
+};
+export default {
+    raw,
+    decode,
+};

package/dist/esm/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/esm/functions/batchWrappers.js

@@ -0,0 +1,68 @@
+import { hexEncodeName } from '../utils/hexEncodedName';
+export const universalWrapper = {
+    raw: async ({ contracts }, name, data) => {
+        const universalResolver = await contracts?.getUniversalResolver();
+        return {
+            to: universalResolver.address,
+            data: universalResolver.interface.encodeFunctionData('resolve', [
+                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] };
+    },
+};
+export const 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;
+    },
+};
+export const 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/esm/functions/burnFuses.d.ts

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