@ensdomains/ensjs 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/utils/validation.ts

@@ -1,73 +1,79 @@
-import { isAddress } from 'ethers/lib/utils'
-import { isEncodedLabelhash, saveName } from './labels'
-import { normalise } from './normalise'
+import {
+  NameWithEmptyLabelsError,
+  RootNameIncludesOtherLabelsError,
+} from '../errors/utils.js'
+import { MINIMUM_DOT_ETH_CHARS } from './consts.js'
+import { checkLabel, isEncodedLabelhash, saveName } from './labels.js'
+import { normalise, split, type Label } from './normalise.js'
 
 export const validateName = (name: string) => {
   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) => {
+  const normalisedArray = nameArray.map((label) => {
+    if (label.length === 0) throw new NameWithEmptyLabelsError({ name })
     if (label === '[root]') {
+      if (name !== label) throw new RootNameIncludesOtherLabelsError({ name })
       return label
-    } else {
-      return isEncodedLabelhash(label) ? label : normalise(label)
     }
+    return isEncodedLabelhash(label)
+      ? checkLabel(label) || label
+      : normalise(label)
   })
-  const normalizedName = normalizedArray.join('.')
-  saveName(normalizedName)
-  return normalizedName
+  const normalisedName = normalisedArray.join('.')
+  saveName(normalisedName)
+  return normalisedName
 }
 
-export const validateTLD = (name: string) => {
-  const labels = name.split('.')
-  return validateName(labels[labels.length - 1])
+export type ParsedInputResult = {
+  type: 'name' | 'label'
+  normalised: string | undefined
+  isValid: boolean
+  isShort: boolean
+  is2LD: boolean
+  isETH: boolean
+  labelDataArray: Label[]
 }
 
-type InputType = {
-  type: 'name' | 'label' | 'address' | 'unknown'
-  info?: 'short' | 'supported' | 'unsupported'
-}
-
-export const parseInputType = (input: string): InputType => {
-  const validTLD = validateTLD(input)
-  let regex = /[^.]+$/
+export const parseInput = (input: string): ParsedInputResult => {
+  let nameReference = input
+  let isValid = false
 
   try {
-    validateName(input)
-  } catch (e) {
-    return {
-      type: 'unknown',
-    }
-  }
+    nameReference = validateName(input)
+    isValid = true
+  } catch {}
 
-  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',
-      }
-    }
+  const normalisedName = isValid ? nameReference : undefined
 
-    return {
-      type: 'name',
-      info: 'unsupported',
-    }
-  } else if (isAddress(input)) {
-    return {
-      type: 'address',
-    }
-  } else {
+  const labels = nameReference.split('.')
+  const tld = labels[labels.length - 1]
+  const isETH = tld === 'eth'
+  const labelDataArray = split(nameReference)
+  const isShort =
+    (labelDataArray[0].output?.length || 0) < MINIMUM_DOT_ETH_CHARS
+
+  if (labels.length === 1) {
     return {
       type: 'label',
+      normalised: normalisedName,
+      isShort,
+      isValid,
+      is2LD: false,
+      isETH,
+      labelDataArray,
     }
   }
+
+  const is2LD = labels.length === 2
+  return {
+    type: 'name',
+    normalised: normalisedName,
+    isShort: isETH && is2LD ? isShort : false,
+    isValid,
+    is2LD,
+    isETH,
+    labelDataArray,
+  }
 }
+
+export const checkIsDotEth = (labels: string[]) =>
+  labels.length === 2 && labels[1] === 'eth'

package/src/utils/wrapper.ts

@@ -0,0 +1,20 @@
+import { stringToBytes } from 'viem'
+import { WrappedLabelTooLargeError } from '../errors/utils.js'
+import type { AnyDate } from '../types.js'
+
+export const MAX_EXPIRY = 2n ** 64n - 1n
+
+export const expiryToBigInt = (expiry?: AnyDate, defaultValue = 0n): bigint => {
+  if (!expiry) return defaultValue
+  if (typeof expiry === 'bigint') return expiry
+  if (typeof expiry === 'string' || typeof expiry === 'number')
+    return BigInt(expiry)
+  if (expiry instanceof Date) return BigInt(Math.floor(expiry.getTime() / 1000))
+  throw new TypeError('Expiry must be a bigint, string, number or Date')
+}
+
+export const wrappedLabelLengthCheck = (label: string) => {
+  const bytes = stringToBytes(label)
+  if (bytes.byteLength > 255)
+    throw new WrappedLabelTooLargeError({ label, byteLength: bytes.byteLength })
+}

package/src/wallet.ts

@@ -0,0 +1,85 @@
+export {
+  default as commitName,
+  type CommitNameParameters,
+  type CommitNameReturnType,
+} from './functions/wallet/commitName.js'
+export {
+  default as createSubname,
+  type CreateSubnameParameters,
+  type CreateSubnameReturnType,
+} from './functions/wallet/createSubname.js'
+export {
+  default as deleteSubname,
+  type DeleteSubnameParameters,
+  type DeleteSubnameReturnType,
+} from './functions/wallet/deleteSubname.js'
+export {
+  default as registerName,
+  type RegisterNameParameters,
+  type RegisterNameReturnType,
+} from './functions/wallet/registerName.js'
+export {
+  default as renewNames,
+  type RenewNamesParameters,
+  type RenewNamesReturnType,
+} from './functions/wallet/renewNames.js'
+export {
+  default as setAbiRecord,
+  type SetAbiRecordParameters,
+  type SetAbiRecordReturnType,
+} from './functions/wallet/setAbiRecord.js'
+export {
+  default as setAddressRecord,
+  type SetAddressRecordParameters,
+  type SetAddressRecordReturnType,
+} from './functions/wallet/setAddressRecord.js'
+export {
+  default as setChildFuses,
+  type SetChildFusesParameters,
+  type SetChildFusesReturnType,
+} from './functions/wallet/setChildFuses.js'
+export {
+  default as setContentHashRecord,
+  type SetContentHashRecordParameters,
+  type SetContentHashRecordReturnType,
+} from './functions/wallet/setContentHashRecord.js'
+export {
+  default as setFuses,
+  type SetFusesParameters,
+  type SetFusesReturnType,
+} from './functions/wallet/setFuses.js'
+export {
+  default as setPrimaryName,
+  type SetPrimaryNameParameters,
+  type SetPrimaryNameReturnType,
+} from './functions/wallet/setPrimaryName.js'
+export {
+  default as setRecords,
+  type SetRecordsParameters,
+  type SetRecordsReturnType,
+} from './functions/wallet/setRecords.js'
+export {
+  default as setResolver,
+  type SetResolverParameters,
+  type SetResolverReturnType,
+} from './functions/wallet/setResolver.js'
+export {
+  default as setTextRecord,
+  type SetTextRecordParameters,
+  type SetTextRecordReturnType,
+} from './functions/wallet/setTextRecord.js'
+export {
+  default as transferName,
+  type TransferNameParameters,
+  type TransferNameReturnType,
+} from './functions/wallet/transferName.js'
+export {
+  default as unwrapName,
+  type UnwrapNameParameters,
+  type UnwrapNameReturnType,
+} from './functions/wallet/unwrapName.js'
+export {
+  default as wrapName,
+  type WrapNameParameters,
+  type WrapNameReturnType,
+} from './functions/wallet/wrapName.js'

package/subgraph/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "../dist/types/subgraph.d.ts",
+  "module": "../dist/esm/subgraph.js",
+  "main": "../dist/cjs/subgraph.js"
+}

package/utils/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "../dist/types/utils/index.d.ts",
+  "module": "../dist/esm/utils/index.js",
+  "main": "../dist/cjs/utils/index.js"
+}

package/wallet/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "../dist/types/wallet.d.ts",
+  "module": "../dist/esm/wallet.js",
+  "main": "../dist/cjs/wallet.js"
+}

package/dist/cjs/GqlManager.d.ts

@@ -1,9 +0,0 @@
-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

@@ -1,102 +0,0 @@
-"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

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

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

@@ -1,3 +0,0 @@
-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

@@ -1,4 +0,0 @@
-"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

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

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

@@ -1,3 +0,0 @@
-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

@@ -1,46 +0,0 @@
-"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

@@ -1,16 +0,0 @@
-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/multicall.d.ts

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

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

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

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

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

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

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

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

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

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

@@ -1,2 +0,0 @@
-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

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

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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,21 +0,0 @@
-"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

@@ -1,29 +0,0 @@
-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

@@ -1,71 +0,0 @@
-"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

@@ -1,5 +0,0 @@
-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>;