@ensdomains/ensjs 4.1.2 → 4.2.2

package/src/types.ts

@@ -28,11 +28,13 @@ export type SimpleTransactionRequest = {
   >
 }
 
+// biome-ignore lint/suspicious/noExplicitAny: generic default for passthrough data of various types
 export type TransactionRequestWithPassthrough<TPassthrough = any> =
   SimpleTransactionRequest & {
     passthrough?: TPassthrough
   }
 
+// biome-ignore lint/suspicious/noExplicitAny: args can be various types depending on the function being called
 export type GenericPassthrough = { args: any; address: Address }
 
 export type Extended = { [K in keyof Client]?: undefined } & {

package/src/utils/checkSafeUniversalResolverData.ts

@@ -11,6 +11,7 @@ import { getRevertErrorData } from './getRevertErrorData.js'
 type CheckSafeUniversalResolverDataParameters = Prettify<
   {
     strict: boolean | undefined
+    // biome-ignore lint/suspicious/noExplicitAny: contract function args can be various types depending on the ABI function
     args: any[] | (() => any[])
   } & Omit<Parameters<typeof getContractError>[1], 'args'>
 >

package/src/utils/consts.ts

@@ -1,4 +1,6 @@
 export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'
+export const EMPTY_BYTES32 =
+  '0x0000000000000000000000000000000000000000000000000000000000000000'
 export const MAX_INT_64 = BigInt('18446744073709551615')
 export const MAX_DATE_INT = 8640000000000000
 export const MINIMUM_DOT_ETH_CHARS = 3

package/src/utils/encoders/encodeAbi.ts

@@ -24,6 +24,7 @@ export type EncodeAbiParameters<TEncodeAs extends AbiEncodeAs = AbiEncodeAs> =
       }
     : {
         encodeAs: TEncodeAs
+        // biome-ignore lint/suspicious/noExplicitAny: ABI data structure can have various key-value types depending on the schema
         data: Record<any, any> | null
       }
 

package/src/utils/generateFunction.ts

@@ -4,10 +4,13 @@ import type { ClientWithEns } from '../contracts/consts.js'
 import type { TransactionRequestWithPassthrough } from '../types.js'
 
 export type EncoderFunction = (
+  // biome-ignore lint/suspicious/noExplicitAny: generic encoder function accepts various argument types
   ...args: any[]
 ) => TransactionRequestWithPassthrough
+// biome-ignore lint/suspicious/noExplicitAny: generic decoder function accepts various argument types and returns various types
 export type DecoderFunction = (...args: any[]) => Promise<any>
 
+// biome-ignore lint/suspicious/noExplicitAny: conditional type matches first argument of any type for extraction
 type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R
   ? (...args: P) => R
   : never
@@ -27,7 +30,9 @@ export type BatchFunctionResult<
   args: Parameters<OmitFirstArg<TEncoderFn>>
 } & CoderObject<TEncoderFn, TDecoderFn>
 
+// biome-ignore lint/complexity/noBannedTypes: Function constraint required for generic type matching any function signature
 export type ExtractResult<TFunction extends Function> = TFunction extends (
+  // biome-ignore lint/suspicious/noExplicitAny: conditional type matches promise-returning function with any arguments for result extraction
   ...args: any[]
 ) => Promise<infer U>
   ? U
@@ -36,6 +41,7 @@ export type ExtractResult<TFunction extends Function> = TFunction extends (
 export interface GeneratedFunction<
   TEncoderFn extends EncoderFunction,
   TDecoderFn extends DecoderFunction,
+  // biome-ignore lint/complexity/noBannedTypes: Function type required for extending base function interface with additional properties
 > extends Function,
     CoderObject<TEncoderFn, TDecoderFn> {
   (

package/src/utils/index.ts

@@ -43,6 +43,7 @@ export {
 
 export {
   EMPTY_ADDRESS,
+  EMPTY_BYTES32,
   GRACE_PERIOD_SECONDS,
   MAX_DATE_INT,
   MAX_INT_64,
@@ -104,21 +105,6 @@ export {
   saveLabel,
   saveName,
 } from './labels.js'
-export {
-  makeLegacyCommitment,
-  makeLegacyCommitmentFromTuple,
-  makeLegacyCommitmentTuple,
-  makeLegacyCommitmentWithConfigTuple,
-  makeLegacyRegistrationTuple,
-  makeLegacyRegistrationWithConfigTuple,
-  isLegacyRegistrationWithConfigParameters,
-  type LegacyCommitmentTuple,
-  type LegacyCommitmentWithConfigTuple,
-  type LegacyRegistrationParameters,
-  type LegacyRegistrationWithConfigParameters,
-  type LegacyRegistrationTuple,
-  type LegacyRegistrationWithConfigTuple,
-} from './legacyRegisterHelpers.js'
 export { makeSafeSecondsDate } from './makeSafeSecondsDate.js'
 export {
   beautify,
@@ -143,13 +129,12 @@ export {
 } from './normalise.js'
 export {
   makeCommitment,
-  makeCommitmentFromTuple,
-  makeCommitmentTuple,
-  makeRegistrationTuple,
+  makeCommitmentFromCallData,
+  makeRegistrationCallData,
   randomSecret,
-  type CommitmentTuple,
+  type RegistrationCallData,
+  type ReverseRecordParameter,
   type RegistrationParameters,
-  type RegistrationTuple,
 } from './registerHelpers.js'
 export {
   checkIsDotEth,

package/src/utils/labels.ts

@@ -49,6 +49,7 @@ function getLabels() {
     : {}
 }
 
+// biome-ignore lint/suspicious/noExplicitAny: label data stored in localStorage can be various types
 function _saveLabel(hash: string, label: any) {
   if (!hasLocalStorage) return hash
   const labels = getLabels()
@@ -89,8 +90,11 @@ export function checkIsDecrypted(string: string | string[]) {
 }
 
 export function decryptName(name: string) {
-  return name
-    .split('.')
-    .map((label: any) => checkLabel(label))
-    .join('.')
+  return (
+    name
+      .split('.')
+      // biome-ignore lint/suspicious/noExplicitAny: label is a string from split but type inference needs explicit annotation
+      .map((label: any) => checkLabel(label))
+      .join('.')
+  )
 }

package/src/utils/registerHelpers.ts

@@ -3,8 +3,8 @@ import {
   type Hex,
   encodeAbiParameters,
   keccak256,
-  labelhash,
   pad,
+  parseAbiParameters,
   toBytes,
   toHex,
 } from 'viem'
@@ -13,13 +13,18 @@ import {
   ResolverAddressRequiredError,
 } from '../errors/utils.js'
 import { EMPTY_ADDRESS } from './consts.js'
-import { type EncodeChildFusesInputObject, encodeFuses } from './fuses.js'
 import {
   type RecordOptions,
   generateRecordCallArray,
 } from './generateRecordCallArray.js'
 import { namehash } from './normalise.js'
 
+export enum ReverseRecordParameter {
+  None = 0,
+  Ethereum = 1,
+  Default = 2,
+}
+
 export type RegistrationParameters = {
   /** Name to register */
   name: string
@@ -34,32 +39,21 @@ export type RegistrationParameters = {
   /** Records to set upon registration */
   records?: RecordOptions
   /** Sets primary name upon registration */
-  reverseRecord?: boolean
-  /** Fuses to set upon registration */
-  fuses?: EncodeChildFusesInputObject
+  reverseRecord?: ReverseRecordParameter
+  /** Referrer for registration */
+  referrer?: Hex
 }
 
-export type CommitmentTuple = [
-  labelHash: Hex,
-  owner: Address,
-  duration: bigint,
-  secret: Hex,
-  resolver: Address,
-  data: Hex[],
-  reverseRecord: boolean,
-  ownerControlledFuses: number,
-]
-
-export type RegistrationTuple = [
-  label: string,
-  owner: Address,
-  duration: bigint,
-  secret: Hex,
-  resolver: Address,
-  data: Hex[],
-  reverseRecord: boolean,
-  ownerControlledFuses: number,
-]
+export type RegistrationCallData = {
+  label: string
+  owner: Address
+  duration: bigint
+  secret: Hex
+  resolver: Address
+  data: Hex[]
+  reverseRecord: ReverseRecordParameter
+  referrer: Hex
+}
 
 const cryptoRef =
   (typeof crypto !== 'undefined' && crypto) ||
@@ -93,21 +87,18 @@ export const randomSecret = ({
   return toHex(bytes)
 }
 
-export const makeCommitmentTuple = ({
+export const makeRegistrationCallData = ({
   name,
   owner,
   duration,
   resolverAddress = EMPTY_ADDRESS,
-  records: { coins = [], ...records } = { texts: [], coins: [] },
+  records: { coins = [], ...records } = { coins: [], texts: [] },
   reverseRecord,
-  fuses,
   secret,
-}: RegistrationParameters): CommitmentTuple => {
-  const labelHash = labelhash(name.split('.')[0])
+  referrer = '0x0000000000000000000000000000000000000000000000000000000000000000',
+}: RegistrationParameters): RegistrationCallData => {
+  const label = name.split('.')[0]
   const hash = namehash(name)
-  const fuseData = fuses
-    ? encodeFuses({ restriction: 'child', input: fuses })
-    : 0
 
   if (
     reverseRecord &&
@@ -135,48 +126,33 @@ export const makeCommitmentTuple = ({
         resolverAddress,
         records,
         reverseRecord,
-        fuses,
       },
     })
 
-  return [
-    labelHash,
+  return {
+    label,
     owner,
-    BigInt(duration),
+    duration: BigInt(duration),
     secret,
-    resolverAddress,
+    resolver: resolverAddress,
     data,
-    !!reverseRecord,
-    fuseData,
-  ]
-}
-
-export const makeRegistrationTuple = (
-  params: RegistrationParameters,
-): RegistrationTuple => {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const [_labelhash, ...commitmentData] = makeCommitmentTuple(params)
-  const label = params.name.split('.')[0]
-  return [label, ...commitmentData]
+    reverseRecord: reverseRecord ?? 0,
+    referrer: referrer,
+  }
 }
 
-export const makeCommitmentFromTuple = (params: CommitmentTuple): Hex => {
+export const makeCommitmentFromCallData = (
+  callData: RegistrationCallData,
+): Hex => {
   return keccak256(
     encodeAbiParameters(
-      [
-        { name: 'name', type: 'bytes32' },
-        { name: 'owner', type: 'address' },
-        { name: 'duration', type: 'uint256' },
-        { name: 'secret', type: 'bytes32' },
-        { name: 'resolver', type: 'address' },
-        { name: 'data', type: 'bytes[]' },
-        { name: 'reverseRecord', type: 'bool' },
-        { name: 'ownerControlledFuses', type: 'uint16' },
-      ],
-      params,
+      parseAbiParameters(
+        '(string label,address owner,uint256 duration,bytes32 secret,address resolver,bytes[] data,uint8 reverseRecord,bytes32 referrer)',
+      ),
+      [callData],
     ),
   )
 }
 
 export const makeCommitment = (params: RegistrationParameters): Hex =>
-  makeCommitmentFromTuple(makeCommitmentTuple(params))
+  makeCommitmentFromCallData(makeRegistrationCallData(params))

package/src/wallet.ts

@@ -26,20 +26,6 @@ export {
   type DeleteSubnameParameters,
   type DeleteSubnameReturnType,
 } from './functions/wallet/deleteSubname.js'
-export {
-  default as legacyCommitName,
-  type LegacyCommitNameDataParameters,
-  type LegacyCommitNameDataReturnType,
-  type LegacyCommitNameParameters,
-  type LegacyCommitNameReturnType,
-} from './functions/wallet/legacyCommitName.js'
-export {
-  default as legacyRegisterName,
-  type LegacyRegisterNameDataParameters,
-  type LegacyRegisterNameDataReturnType,
-  type LegacyRegisterNameParameters,
-  type LegacyRegisterNameReturnType,
-} from './functions/wallet/legacyRegisterName.js'
 export {
   default as registerName,
   type RegisterNameDataParameters,

package/dist/functions/wallet/legacyCommitName.d.ts

@@ -1,40 +0,0 @@
-import { type Account, type Hash, type Transport } from 'viem';
-import type { ChainWithEns, ClientWithAccount } from '../../contracts/consts.js';
-import type { Prettify, SimpleTransactionRequest, WriteTransactionParameters } from '../../types.js';
-import { type LegacyRegistrationParameters } from '../../utils/legacyRegisterHelpers.js';
-export type LegacyCommitNameDataParameters = LegacyRegistrationParameters;
-export type LegacyCommitNameDataReturnType = SimpleTransactionRequest;
-export type LegacyCommitNameParameters<TChain extends ChainWithEns, TAccount extends Account | undefined, TChainOverride extends ChainWithEns | undefined> = Prettify<LegacyCommitNameDataParameters & WriteTransactionParameters<TChain, TAccount, TChainOverride>>;
-export type LegacyCommitNameReturnType = Hash;
-export declare const makeFunctionData: <TChain extends ChainWithEns, TAccount extends Account | undefined>(wallet: ClientWithAccount<Transport, TChain, TAccount>, args: LegacyCommitNameDataParameters) => LegacyCommitNameDataReturnType;
-/**
- * Commits a name to be registered
- * @param wallet - {@link ClientWithAccount}
- * @param parameters - {@link LegacyCommitNameParameters}
- * @returns Transaction hash. {@link LegacyCommitNameReturnType}
- *
- * @example
- * import { createWalletClient, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { commitName } from '@ensdomains/ensjs/wallet'
- * import { randomSecret } from '@ensdomains/ensjs/utils'
- *
- * const wallet = createWalletClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: custom(window.ethereum),
- * })
- * const secret = randomSecret()
- * const hash = await commitName(wallet, {
- *   name: 'example.eth',
- *   owner: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
- *   duration: 31536000, // 1 year
- *   secret,
- * })
- * // 0x...
- */
-declare function legacyCommitName<TChain extends ChainWithEns, TAccount extends Account | undefined, TChainOverride extends ChainWithEns | undefined = ChainWithEns>(wallet: ClientWithAccount<Transport, TChain, TAccount>, { name, owner, duration, secret, resolverAddress, address, ...txArgs }: LegacyCommitNameParameters<TChain, TAccount, TChainOverride>): Promise<LegacyCommitNameReturnType>;
-declare namespace legacyCommitName {
-    var makeFunctionData: <TChain extends ChainWithEns, TAccount extends Account | undefined>(wallet: ClientWithAccount<Transport, TChain, TAccount>, args: LegacyCommitNameDataParameters) => LegacyCommitNameDataReturnType;
-}
-export default legacyCommitName;

package/dist/functions/wallet/legacyCommitName.js

@@ -1,72 +0,0 @@
-import { encodeFunctionData, } from 'viem';
-import { sendTransaction } from 'viem/actions';
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js';
-import { legacyEthRegistrarControllerCommitSnippet } from '../../contracts/legacyEthRegistrarController.js';
-import { UnsupportedNameTypeError } from '../../errors/general.js';
-import { EMPTY_ADDRESS } from '../../utils/consts.js';
-import { getNameType } from '../../utils/getNameType.js';
-import { makeLegacyCommitment, } from '../../utils/legacyRegisterHelpers.js';
-export const makeFunctionData = (wallet, args) => {
-    const nameType = getNameType(args.name);
-    if (nameType !== 'eth-2ld')
-        throw new UnsupportedNameTypeError({
-            nameType,
-            supportedNameTypes: ['eth-2ld'],
-            details: 'Only 2ld-eth name registration is supported',
-        });
-    return {
-        to: getChainContractAddress({
-            client: wallet,
-            contract: 'legacyEthRegistrarController',
-        }),
-        data: encodeFunctionData({
-            abi: legacyEthRegistrarControllerCommitSnippet,
-            functionName: 'commit',
-            args: [makeLegacyCommitment(args)],
-        }),
-    };
-};
-/**
- * Commits a name to be registered
- * @param wallet - {@link ClientWithAccount}
- * @param parameters - {@link LegacyCommitNameParameters}
- * @returns Transaction hash. {@link LegacyCommitNameReturnType}
- *
- * @example
- * import { createWalletClient, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { commitName } from '@ensdomains/ensjs/wallet'
- * import { randomSecret } from '@ensdomains/ensjs/utils'
- *
- * const wallet = createWalletClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: custom(window.ethereum),
- * })
- * const secret = randomSecret()
- * const hash = await commitName(wallet, {
- *   name: 'example.eth',
- *   owner: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
- *   duration: 31536000, // 1 year
- *   secret,
- * })
- * // 0x...
- */
-async function legacyCommitName(wallet, { name, owner, duration, secret, resolverAddress = EMPTY_ADDRESS, address = EMPTY_ADDRESS, ...txArgs }) {
-    const data = makeFunctionData(wallet, {
-        name,
-        owner,
-        duration,
-        secret,
-        resolverAddress,
-        address,
-    });
-    const writeArgs = {
-        ...data,
-        ...txArgs,
-    };
-    return sendTransaction(wallet, writeArgs);
-}
-legacyCommitName.makeFunctionData = makeFunctionData;
-export default legacyCommitName;
-//# sourceMappingURL=legacyCommitName.js.map

package/dist/functions/wallet/legacyCommitName.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacyCommitName.js","sourceRoot":"","sources":["../../../src/functions/wallet/legacyCommitName.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,kBAAkB,GACnB,MAAM,MAAM,CAAA;AACb,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAE9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAA;AACpF,OAAO,EAAE,yCAAyC,EAAE,MAAM,iDAAiD,CAAA;AAC3G,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AAMlE,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAEL,oBAAoB,GACrB,MAAM,sCAAsC,CAAA;AAiB7C,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAI9B,MAAsD,EACtD,IAAoC,EACJ,EAAE;IAClC,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACvC,IAAI,QAAQ,KAAK,SAAS;QACxB,MAAM,IAAI,wBAAwB,CAAC;YACjC,QAAQ;YACR,kBAAkB,EAAE,CAAC,SAAS,CAAC;YAC/B,OAAO,EAAE,6CAA6C;SACvD,CAAC,CAAA;IAEJ,OAAO;QACL,EAAE,EAAE,uBAAuB,CAAC;YAC1B,MAAM,EAAE,MAAM;YACd,QAAQ,EAAE,8BAA8B;SACzC,CAAC;QACF,IAAI,EAAE,kBAAkB,CAAC;YACvB,GAAG,EAAE,yCAAyC;YAC9C,YAAY,EAAE,QAAQ;YACtB,IAAI,EAAE,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;SACnC,CAAC;KACH,CAAA;AACH,CAAC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,KAAK,UAAU,gBAAgB,CAK7B,MAAsD,EACtD,EACE,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,MAAM,EACN,eAAe,GAAG,aAAa,EAC/B,OAAO,GAAG,aAAa,EACvB,GAAG,MAAM,EACoD;IAE/D,MAAM,IAAI,GAAG,gBAAgB,CAAC,MAAM,EAAE;QACpC,IAAI;QACJ,KAAK;QACL,QAAQ;QACR,MAAM;QACN,eAAe;QACf,OAAO;KACR,CAAC,CAAA;IACF,MAAM,SAAS,GAAG;QAChB,GAAG,IAAI;QACP,GAAG,MAAM;KACqD,CAAA;IAChE,OAAO,eAAe,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAC3C,CAAC;AAED,gBAAgB,CAAC,gBAAgB,GAAG,gBAAgB,CAAA;AAEpD,eAAe,gBAAgB,CAAA"}

package/dist/functions/wallet/legacyRegisterName.d.ts

@@ -1,59 +0,0 @@
-import { type Account, type Hash, type Transport } from 'viem';
-import type { ChainWithEns, ClientWithAccount } from '../../contracts/consts.js';
-import type { Prettify, SimpleTransactionRequest, WriteTransactionParameters } from '../../types.js';
-import { type LegacyRegistrationParameters } from '../../utils/legacyRegisterHelpers.js';
-export type LegacyRegisterNameDataParameters = LegacyRegistrationParameters & {
-    /** Value of registration */
-    value: bigint;
-};
-export type LegacyRegisterNameDataReturnType = SimpleTransactionRequest & {
-    value: bigint;
-};
-export type LegacyRegisterNameParameters<TChain extends ChainWithEns, TAccount extends Account | undefined, TChainOverride extends ChainWithEns | undefined> = Prettify<LegacyRegisterNameDataParameters & WriteTransactionParameters<TChain, TAccount, TChainOverride>>;
-export type LegacyRegisterNameReturnType = Hash;
-export declare const makeFunctionData: <TChain extends ChainWithEns, TAccount extends Account | undefined>(wallet: ClientWithAccount<Transport, TChain, TAccount>, { value, ...args }: LegacyRegisterNameDataParameters) => LegacyRegisterNameDataReturnType;
-/**
- * Registers a name on ENS
- * @param wallet - {@link ClientWithAccount}
- * @param parameters - {@link RegisterNameParameters}
- * @returns Transaction hash. {@link LegacyRegisterNameReturnType}
- *
- * @example
- * import { createPublicClient, createWalletClient, http, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { getPrice } from '@ensdomains/ensjs/public'
- * import { randomSecret } from '@ensdomains/ensjs/utils'
- * import { commitName, registerName } from '@ensdomains/ensjs/wallet'
- *
- * const mainnetWithEns = addEnsContracts(mainnet)
- * const client = createPublicClient({
- *   chain: mainnetWithEns,
- *   transport: http(),
- * })
- * const wallet = createWalletClient({
- *   chain: mainnetWithEns,
- *   transport: custom(window.ethereum),
- * })
- * const secret = randomSecret()
- * const params = {
- *   name: 'example.eth',
- *   owner: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
- *   duration: 31536000, // 1 year
- *   secret,
- * }
- *
- * const commitmentHash = await commitName(wallet, params)
- * await client.waitForTransactionReceipt({ hash: commitmentHash }) // wait for commitment to finalise
- * await new Promise((resolve) => setTimeout(resolve, 60 * 1_000)) // wait for commitment to be valid
- *
- * const { base, premium } = await getPrice(client, { nameOrNames: params.name, duration: params.duration })
- * const value = (base + premium) * 110n / 100n // add 10% to the price for buffer
- * const hash = await registerName(wallet, { ...params, value })
- * // 0x...
- */
-declare function legacyRegisterName<TChain extends ChainWithEns, TAccount extends Account | undefined, TChainOverride extends ChainWithEns | undefined = ChainWithEns>(wallet: ClientWithAccount<Transport, TChain, TAccount>, { name, owner, duration, secret, resolverAddress, address, value, ...txArgs }: LegacyRegisterNameParameters<TChain, TAccount, TChainOverride>): Promise<LegacyRegisterNameReturnType>;
-declare namespace legacyRegisterName {
-    var makeFunctionData: <TChain extends ChainWithEns, TAccount extends Account | undefined>(wallet: ClientWithAccount<Transport, TChain, TAccount>, { value, ...args }: LegacyRegisterNameDataParameters) => LegacyRegisterNameDataReturnType;
-}
-export default legacyRegisterName;

package/dist/functions/wallet/legacyRegisterName.js

@@ -1,93 +0,0 @@
-import { encodeFunctionData, } from 'viem';
-import { sendTransaction } from 'viem/actions';
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js';
-import { legacyEthRegistrarControllerRegisterSnippet, legacyEthRegistrarControllerRegisterWithConfigSnippet, } from '../../contracts/legacyEthRegistrarController.js';
-import { UnsupportedNameTypeError } from '../../errors/general.js';
-import { getNameType } from '../../utils/getNameType.js';
-import { isLegacyRegistrationWithConfigParameters, makeLegacyRegistrationTuple, makeLegacyRegistrationWithConfigTuple, } from '../../utils/legacyRegisterHelpers.js';
-export const makeFunctionData = (wallet, { value, ...args }) => {
-    const nameType = getNameType(args.name);
-    if (nameType !== 'eth-2ld')
-        throw new UnsupportedNameTypeError({
-            nameType,
-            supportedNameTypes: ['eth-2ld'],
-            details: 'Only 2ld-eth name registration is supported',
-        });
-    return {
-        to: getChainContractAddress({
-            client: wallet,
-            contract: 'legacyEthRegistrarController',
-        }),
-        data: isLegacyRegistrationWithConfigParameters(args)
-            ? encodeFunctionData({
-                abi: legacyEthRegistrarControllerRegisterWithConfigSnippet,
-                functionName: 'registerWithConfig',
-                args: makeLegacyRegistrationWithConfigTuple(args),
-            })
-            : encodeFunctionData({
-                abi: legacyEthRegistrarControllerRegisterSnippet,
-                functionName: 'register',
-                args: makeLegacyRegistrationTuple(args),
-            }),
-        value,
-    };
-};
-/**
- * Registers a name on ENS
- * @param wallet - {@link ClientWithAccount}
- * @param parameters - {@link RegisterNameParameters}
- * @returns Transaction hash. {@link LegacyRegisterNameReturnType}
- *
- * @example
- * import { createPublicClient, createWalletClient, http, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { getPrice } from '@ensdomains/ensjs/public'
- * import { randomSecret } from '@ensdomains/ensjs/utils'
- * import { commitName, registerName } from '@ensdomains/ensjs/wallet'
- *
- * const mainnetWithEns = addEnsContracts(mainnet)
- * const client = createPublicClient({
- *   chain: mainnetWithEns,
- *   transport: http(),
- * })
- * const wallet = createWalletClient({
- *   chain: mainnetWithEns,
- *   transport: custom(window.ethereum),
- * })
- * const secret = randomSecret()
- * const params = {
- *   name: 'example.eth',
- *   owner: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
- *   duration: 31536000, // 1 year
- *   secret,
- * }
- *
- * const commitmentHash = await commitName(wallet, params)
- * await client.waitForTransactionReceipt({ hash: commitmentHash }) // wait for commitment to finalise
- * await new Promise((resolve) => setTimeout(resolve, 60 * 1_000)) // wait for commitment to be valid
- *
- * const { base, premium } = await getPrice(client, { nameOrNames: params.name, duration: params.duration })
- * const value = (base + premium) * 110n / 100n // add 10% to the price for buffer
- * const hash = await registerName(wallet, { ...params, value })
- * // 0x...
- */
-async function legacyRegisterName(wallet, { name, owner, duration, secret, resolverAddress, address, value, ...txArgs }) {
-    const data = makeFunctionData(wallet, {
-        name,
-        owner,
-        duration,
-        secret,
-        resolverAddress,
-        address,
-        value,
-    });
-    const writeArgs = {
-        ...data,
-        ...txArgs,
-    };
-    return sendTransaction(wallet, writeArgs);
-}
-legacyRegisterName.makeFunctionData = makeFunctionData;
-export default legacyRegisterName;
-//# sourceMappingURL=legacyRegisterName.js.map

package/dist/functions/wallet/legacyRegisterName.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacyRegisterName.js","sourceRoot":"","sources":["../../../src/functions/wallet/legacyRegisterName.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,kBAAkB,GACnB,MAAM,MAAM,CAAA;AACb,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAE9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAA;AACpF,OAAO,EACL,2CAA2C,EAC3C,qDAAqD,GACtD,MAAM,iDAAiD,CAAA;AACxD,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AAMlE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAEL,wCAAwC,EACxC,2BAA2B,EAC3B,qCAAqC,GACtC,MAAM,sCAAsC,CAAA;AAsB7C,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAI9B,MAAsD,EACtD,EAAE,KAAK,EAAE,GAAG,IAAI,EAAoC,EAClB,EAAE;IACpC,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACvC,IAAI,QAAQ,KAAK,SAAS;QACxB,MAAM,IAAI,wBAAwB,CAAC;YACjC,QAAQ;YACR,kBAAkB,EAAE,CAAC,SAAS,CAAC;YAC/B,OAAO,EAAE,6CAA6C;SACvD,CAAC,CAAA;IAEJ,OAAO;QACL,EAAE,EAAE,uBAAuB,CAAC;YAC1B,MAAM,EAAE,MAAM;YACd,QAAQ,EAAE,8BAA8B;SACzC,CAAC;QACF,IAAI,EAAE,wCAAwC,CAAC,IAAI,CAAC;YAClD,CAAC,CAAC,kBAAkB,CAAC;gBACjB,GAAG,EAAE,qDAAqD;gBAC1D,YAAY,EAAE,oBAAoB;gBAClC,IAAI,EAAE,qCAAqC,CAAC,IAAI,CAAC;aAClD,CAAC;YACJ,CAAC,CAAC,kBAAkB,CAAC;gBACjB,GAAG,EAAE,2CAA2C;gBAChD,YAAY,EAAE,UAAU;gBACxB,IAAI,EAAE,2BAA2B,CAAC,IAAI,CAAC;aACxC,CAAC;QACN,KAAK;KACN,CAAA;AACH,CAAC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,KAAK,UAAU,kBAAkB,CAK/B,MAAsD,EACtD,EACE,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,MAAM,EACN,eAAe,EACf,OAAO,EACP,KAAK,EACL,GAAG,MAAM,EACsD;IAEjE,MAAM,IAAI,GAAG,gBAAgB,CAAC,MAAM,EAAE;QACpC,IAAI;QACJ,KAAK;QACL,QAAQ;QACR,MAAM;QACN,eAAe;QACf,OAAO;QACP,KAAK;KACN,CAAC,CAAA;IACF,MAAM,SAAS,GAAG;QAChB,GAAG,IAAI;QACP,GAAG,MAAM;KACqD,CAAA;IAChE,OAAO,eAAe,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAC3C,CAAC;AAED,kBAAkB,CAAC,gBAAgB,GAAG,gBAAgB,CAAA;AAEtD,eAAe,kBAAkB,CAAA"}

package/dist/utils/legacyRegisterHelpers.d.ts

@@ -1,48 +0,0 @@
-import { type Address, type Hex } from 'viem';
-export type LegacyRegistrationParameters = {
-    /** Name to register */
-    name: string;
-    /** Address to set owner to */
-    owner: Address;
-    /** Duration of registration */
-    duration: number;
-    /** Random 32 bytes to use for registration */
-    secret: Hex;
-    /** Custom resolver address, defaults to empty address */
-    resolverAddress?: Address;
-    /** Address to set upon registration, defaults to empty address */
-    address?: Address;
-};
-export type LegacyRegistrationWithConfigParameters = LegacyRegistrationParameters & {
-    resolverAddress: Address;
-    address?: Address;
-};
-export declare const isLegacyRegistrationWithConfigParameters: (params: LegacyRegistrationParameters) => params is LegacyRegistrationWithConfigParameters;
-export type LegacyCommitmentTuple = [label: string, owner: Address, secret: Hex];
-export type LegacyCommitmentWithConfigTuple = [
-    label: string,
-    owner: Address,
-    resolverAddress: Address,
-    address: Address,
-    secret: Hex
-];
-export type LegacyRegistrationTuple = [
-    label: string,
-    owner: Address,
-    duration: bigint,
-    secret: Hex
-];
-export type LegacyRegistrationWithConfigTuple = [
-    label: string,
-    owner: Address,
-    duration: bigint,
-    secret: Hex,
-    resolverAddress: Address,
-    address: Address
-];
-export declare const makeLegacyCommitmentTuple: (params: LegacyRegistrationParameters) => LegacyCommitmentTuple;
-export declare const makeLegacyCommitmentWithConfigTuple: (params: LegacyRegistrationWithConfigParameters) => LegacyCommitmentWithConfigTuple;
-export declare const makeLegacyRegistrationTuple: ({ name, owner, secret, duration, }: LegacyRegistrationParameters) => LegacyRegistrationTuple;
-export declare const makeLegacyRegistrationWithConfigTuple: ({ name, owner, secret, duration, resolverAddress, address, }: LegacyRegistrationWithConfigParameters) => LegacyRegistrationWithConfigTuple;
-export declare const makeLegacyCommitmentFromTuple: ([label, ...others]: LegacyCommitmentTuple | LegacyCommitmentWithConfigTuple) => Hex;
-export declare const makeLegacyCommitment: (params: LegacyRegistrationParameters | LegacyRegistrationWithConfigParameters) => Hex;