@ensdomains/ensjs 3.0.0-alpha.15 → 3.0.0-alpha.18

package/src/utils/recordHelpers.ts

@@ -20,7 +20,7 @@ export const generateSetAddr = (
   resolver: PublicResolver,
 ) => {
   let coinTypeInstance
-  if (!isNaN(parseInt(coinType))) {
+  if (!Number.isNaN(parseInt(coinType))) {
     coinTypeInstance = formatsByCoinType[parseInt(coinType)]
   } else {
     coinTypeInstance = formatsByName[coinType.toUpperCase()]
@@ -58,19 +58,17 @@ export function generateSingleRecordCall<T extends RecordTypes>(
         _contentHash,
       ])
     }
-  } else {
-    return (_r: RecordInput<T>) => {
-      const record = _r as RecordItem
-      if (type === 'text') {
-        return resolver.interface.encodeFunctionData('setText', [
-          namehash,
-          record.key,
-          record.value,
-        ])
-      } else {
-        return generateSetAddr(namehash, record.key, record.value, resolver)
-      }
+  }
+  return (_r: RecordInput<T>) => {
+    const record = _r as RecordItem
+    if (type === 'text') {
+      return resolver.interface.encodeFunctionData('setText', [
+        namehash,
+        record.key,
+        record.value,
+      ])
     }
+    return generateSetAddr(namehash, record.key, record.value, resolver)
   }
 }
 
@@ -87,7 +85,7 @@ export const generateRecordCallArray = (
       resolver,
       'contentHash',
     )(records.contentHash)
-    data && calls.push(data)
+    if (data) calls.push(data)
   }
 
   if (records.texts && records.texts.length > 0) {

package/src/utils/registerHelpers.ts

@@ -52,7 +52,7 @@ export type CommitmentTuple = [
 
 export const randomSecret = () => {
   const bytes = Buffer.allocUnsafe(32)
-  return '0x' + crypto.getRandomValues(bytes).toString('hex')
+  return `0x${crypto.getRandomValues(bytes).toString('hex')}`
 }
 
 export const makeCommitmentData = ({
@@ -101,30 +101,13 @@ export const makeRegistrationData = (
   params: RegistrationParams,
 ): RegistrationTuple => {
   const commitmentData = makeCommitmentData(params)
-  commitmentData[0] = params.name.split('.')[0]
+  const label = params.name.split('.')[0]
+  commitmentData[0] = label
   const secret = commitmentData.splice(5, 1)[0]
   commitmentData.splice(3, 0, secret)
   return commitmentData as unknown as RegistrationTuple
 }
 
-export const makeCommitment = ({
-  secret = randomSecret(),
-  ...inputParams
-}: CommitmentParams) => {
-  const generatedParams = makeCommitmentData({
-    ...inputParams,
-    secret,
-  })
-
-  const commitment = _makeCommitment(generatedParams)
-
-  return {
-    secret,
-    commitment,
-    wrapperExpiry: generatedParams[8],
-  }
-}
-
 export const _makeCommitment = (params: CommitmentTuple) => {
   return utils.keccak256(
     utils.defaultAbiCoder.encode(
@@ -143,3 +126,21 @@ export const _makeCommitment = (params: CommitmentTuple) => {
     ),
   )
 }
+
+export const makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}: CommitmentParams) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret,
+  })
+
+  const commitment = _makeCommitment(generatedParams)
+
+  return {
+    secret,
+    commitment,
+    wrapperExpiry: generatedParams[8],
+  }
+}

package/src/utils/validation.ts

@@ -4,14 +4,13 @@ import { normalise } from './normalise'
 
 export const validateName = (name: string) => {
   const nameArray = name.split('.')
-  const hasEmptyLabels = nameArray.some((label) => label.length == 0)
+  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 isEncodedLabelhash(label) ? label : normalise(label)
     }
+    return isEncodedLabelhash(label) ? label : normalise(label)
   })
   const normalizedName = normalizedArray.join('.')
   saveName(normalizedName)
@@ -30,7 +29,7 @@ type InputType = {
 
 export const parseInputType = (input: string): InputType => {
   const validTLD = validateTLD(input)
-  let regex = /[^.]+$/
+  const regex = /[^.]+$/
 
   try {
     validateName(input)
@@ -61,13 +60,13 @@ export const parseInputType = (input: string): InputType => {
       type: 'name',
       info: 'unsupported',
     }
-  } else if (isAddress(input)) {
+  }
+  if (isAddress(input)) {
     return {
       type: 'address',
     }
-  } else {
-    return {
-      type: 'label',
-    }
+  }
+  return {
+    type: 'label',
   }
 }

package/src/utils/wrapperExpiry.ts

@@ -13,19 +13,17 @@ export const makeExpiry = async (
   if (expiry) {
     if (expiry instanceof Date) {
       return BigNumber.from(expiry.getTime() / 1000)
-    } else if (expiry instanceof BigNumber) {
-      return expiry
-    } else {
-      return BigNumber.from(expiry)
     }
-  } else {
-    if (name.endsWith('.eth')) {
-      const expResponse = await getExpiry(name)
-      if (!expResponse?.expiry)
-        throw new Error("Couldn't get expiry for name, please provide one.")
-      return BigNumber.from(expResponse.expiry.getTime() / 1000)
-    } else {
-      return MAX_EXPIRY
+    if (expiry instanceof BigNumber) {
+      return expiry
     }
+    return BigNumber.from(expiry)
+  }
+  if (name.endsWith('.eth')) {
+    const expResponse = await getExpiry(name)
+    if (!expResponse?.expiry)
+      throw new Error("Couldn't get expiry for name, please provide one.")
+    return BigNumber.from(expResponse.expiry.getTime() / 1000)
   }
+  return MAX_EXPIRY
 }

package/src/utils/writeTx.ts

@@ -1,4 +1,4 @@
-import { JsonRpcSigner } from '@ethersproject/providers'
+import type { JsonRpcSigner } from '@ethersproject/providers'
 import type { PopulatedTransaction } from 'ethers'
 
 type CustomData = Record<string, any>

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

@@ -1,74 +0,0 @@
-// @ts-nocheck
-import { namehash } from './utils/normalise';
-const generateSelection = (selection) => ({
-    kind: 'Field',
-    name: {
-        kind: 'Name',
-        value: selection,
-    },
-    arguments: [],
-    directives: [],
-    alias: undefined,
-    selectionSet: undefined,
-});
-export 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;
-        }
-    }
-};
-export const requestMiddleware = (visit, parse) => (request) => {
-    const requestBody = JSON.parse(request.body);
-    const rawQuery = requestBody.query;
-    const parsedQuery = parse(rawQuery);
-    const updatedQuery = visit(parsedQuery, { enter });
-    const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body };
-    return {
-        ...request,
-        body: JSON.stringify(updatedBody),
-    };
-};
-export 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 = namehash(responseItem.name);
-            if (responseItem.id !== hashedName) {
-                this.update({ ...responseItem, name: hashedName, invalidName: true });
-            }
-        }
-    });
-    return response;
-};
-export default class GqlManager {
-    constructor() {
-        this.gql = () => null;
-        this.client = null;
-        this.setUrl = async (url) => {
-            if (url) {
-                const [imported, traverse, { visit, parse }] = await Promise.all([
-                    import('graphql-request'),
-                    import('traverse'),
-                    import('graphql/language'),
-                ]);
-                this.client = new imported.GraphQLClient(url, {
-                    requestMiddleware: requestMiddleware(visit, parse),
-                    responseMiddleware: responseMiddleware(traverse.default),
-                });
-                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.js

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

package/dist/esm/contracts/ethRegistrarController.js

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

package/dist/esm/contracts/getContractAddress.js

@@ -1,42 +0,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',
-    },
-};
-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.js

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

@@ -1,20 +0,0 @@
-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.js

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

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

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

package/dist/esm/contracts/registry.js

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

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

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

package/dist/esm/contracts/types.js

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

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

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

package/dist/esm/functions/batch.js

@@ -1,19 +0,0 @@
-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.js

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

@@ -1,32 +0,0 @@
-import { ENSArgs } from '..';
-import { fuseEnum, unnamedFuses } from '../utils/fuses';
-declare type FuseObj = typeof fuseEnum;
-declare type UnnamedFuseType = typeof unnamedFuses;
-declare type Fuse = keyof FuseObj;
-declare type UnnamedFuseValues = UnnamedFuseType[number];
-declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
-/**
- * This type creates a type error if there are any duplicate fuses.
- * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
- *
- * @template A The array to check for duplicates.
- * @template B The union of all checked existing types.
- */
-declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities ? A extends [infer Head, ...infer Tail] ? Head extends B ? [
-] : [
-    Head,
-    ...FusesWithoutDuplicates<Tail, Head | B>
-] : A : [
-];
-declare type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
-    namedFusesToBurn: FusesWithoutDuplicates<A>;
-};
-declare type FusePropsUnnamedArray = {
-    unnamedFusesToBurn: UnnamedFuseValues[];
-};
-declare type FusePropsNumber = {
-    fuseNumberToBurn: number;
-};
-declare type FuseProps<A extends FuseArrayPossibilities> = (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray) | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
-export default function <A extends FuseArrayPossibilities>({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps<A>): Promise<import("ethers").PopulatedTransaction>;
-export {};

package/dist/esm/functions/burnFuses.js

@@ -1,41 +0,0 @@
-import { fuseEnum, unnamedFuses } from '../utils/fuses';
-import { namehash } from '../utils/normalise';
-export default async function ({ contracts, signer }, name, props) {
-    const isNumber = 'fuseNumberToBurn' in props;
-    const hasNamedArray = 'namedFusesToBurn' in props;
-    const hasUnnamedArray = 'unnamedFusesToBurn' in props;
-    let encodedFuses = 0;
-    if (isNumber) {
-        if (props.fuseNumberToBurn > 2 ** 32 || props.fuseNumberToBurn < 1) {
-            throw new Error(`Fuse number must be limited to uint32, ${props.fuseNumberToBurn} was too ${props.fuseNumberToBurn < 1 ? 'low' : 'high'}.`);
-        }
-        else if (props.fuseNumberToBurn % 1 !== 0) {
-            throw new Error(`Fuse number must be an integer, ${props.fuseNumberToBurn} was not.`);
-        }
-        encodedFuses = props.fuseNumberToBurn;
-    }
-    else {
-        if (!hasNamedArray && !hasUnnamedArray) {
-            throw new Error('Please provide fuses to burn');
-        }
-        if (hasNamedArray) {
-            for (const fuse of props.namedFusesToBurn) {
-                if (!(fuse in fuseEnum)) {
-                    throw new Error(`${fuse} is not a valid named fuse.`);
-                }
-                encodedFuses |= fuseEnum[fuse];
-            }
-        }
-        if (hasUnnamedArray) {
-            for (const fuse of props.unnamedFusesToBurn) {
-                if (!unnamedFuses.includes(fuse)) {
-                    throw new Error(`${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`);
-                }
-                encodedFuses |= fuse;
-            }
-        }
-    }
-    const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-    const hash = namehash(name);
-    return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
-}

package/dist/esm/functions/commitName.js

@@ -1,21 +0,0 @@
-import { makeCommitment } from '../utils/registerHelpers';
-export default async function ({ contracts }, name, { resolverAddress, ...params }) {
-    const labels = name.split('.');
-    if (labels.length !== 2 || labels[1] !== 'eth')
-        throw new Error('Currently only .eth TLD registrations are supported');
-    const controller = await contracts.getEthRegistrarController();
-    const resolver = await contracts.getPublicResolver(undefined, resolverAddress);
-    const { secret, commitment, wrapperExpiry } = makeCommitment({
-        name,
-        resolver,
-        ...params,
-    });
-    return {
-        ...(await controller.populateTransaction.commit(commitment)),
-        customData: {
-            secret,
-            commitment,
-            wrapperExpiry,
-        },
-    };
-}

package/dist/esm/functions/createSubname.js

@@ -1,36 +0,0 @@
-import { ethers } from 'ethers';
-import generateFuseInput from '../utils/generateFuseInput';
-import { namehash } from '../utils/normalise';
-import { makeExpiry } from '../utils/wrapperExpiry';
-export default async function ({ contracts, signer, getExpiry, }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
-    const labels = name.split('.');
-    if (labels.length === 1) {
-        throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');
-    }
-    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.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = 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 makeExpiry({ getExpiry }, name, 'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined);
-            const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
-                ? generateFuseInput(wrapperArgs.fuses)
-                : '0';
-            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses, expiry);
-        }
-        default: {
-            throw new Error(`Unknown contract: ${contract}`);
-        }
-    }
-}

package/dist/esm/functions/deleteSubname.js

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