@ensdomains/ensjs 4.2.0 → 4.2.3

package/src/functions/public/getRecords.ts

@@ -94,9 +94,13 @@ export type GetRecordsReturnType<
   TContentHash extends boolean | undefined = true,
   TAbi extends boolean | undefined = true,
 > = Prettify<
+  // biome-ignore lint/complexity/noBannedTypes: empty object represents no data when feature is disabled
   (TContentHash extends true ? WithContentHashResult : {}) &
+    // biome-ignore lint/complexity/noBannedTypes: empty object represents no data when feature is disabled
     (TAbi extends true ? WithAbiResult : {}) &
+    // biome-ignore lint/complexity/noBannedTypes: empty object represents no data when feature is disabled
     (TTexts extends readonly string[] ? WithTextsResult : {}) &
+    // biome-ignore lint/complexity/noBannedTypes: empty object represents no data when feature is disabled
     (TCoins extends readonly (string | number)[] ? WithCoinsResult : {}) & {
       /** Resolver address used for fetch */
       resolverAddress: Address
@@ -129,6 +133,7 @@ type EncodeReturnType = Required<
   TransactionRequestWithPassthrough<{
     calls: (CallObj | null)[]
     address?: Address
+    // biome-ignore lint/suspicious/noExplicitAny: passthrough args can be various types depending on resolver method
     args?: any
   }>
 >
@@ -414,11 +419,11 @@ const decode = async <
       abi: multicallSnippet,
       data: result[0],
     }).map((r, i) => {
-      if (r === '0x') {
+      if (r === '0x' || (r.length - 2) % 64 !== 0) {
         calls[i] = null
         return null
       }
-      return (r.length - 2) % 64 === 0 ? r : null
+      return r
     })
   }
 
@@ -440,6 +445,7 @@ const decode = async <
 }
 
 type EncoderFunction = typeof encode
+// biome-ignore lint/suspicious/noExplicitAny: generic placeholder for batch function type inference
 type DecoderFunction = typeof decode<any>
 
 type BatchableFunctionObject = {

package/src/functions/subgraph/client.ts

@@ -55,6 +55,7 @@ export const requestMiddleware: RequestMiddleware = (request) => {
 }
 
 export const responseMiddleware: ResponseMiddleware = (response) => {
+  // biome-ignore lint/suspicious/noExplicitAny: recursively traverses unknown GraphQL response structure
   const traverse = (obj: Record<string, any>) => {
     if (obj && typeof obj === 'object') {
       for (const key in obj) {

package/src/functions/subgraph/getNamesForAddress.ts

@@ -182,6 +182,7 @@ const getNamesForAddress = async (
   const ownerWhereFilters: DomainFilter[] = Object.entries(filters).reduce(
     (prev, [key, value]) => {
       if (value) {
+        // biome-ignore lint/suspicious/noExplicitAny: runtime validation of filter key against supported filters
         if (!supportedOwnerFilters.includes(key as any))
           throw new InvalidFilterKeyError({
             filterKey: key,

package/src/functions/wallet/commitName.ts

@@ -106,7 +106,7 @@ async function commitName<
     resolverAddress,
     records,
     reverseRecord,
-    fuses,
+    referrer,
     ...txArgs
   }: CommitNameParameters<TChain, TAccount, TChainOverride>,
 ): Promise<CommitNameReturnType> {
@@ -118,7 +118,7 @@ async function commitName<
     resolverAddress,
     records,
     reverseRecord,
-    fuses,
+    referrer,
   })
   const writeArgs = {
     ...data,

package/src/functions/wallet/registerName.ts

@@ -18,9 +18,8 @@ import type {
 import { getNameType } from '../../utils/getNameType.js'
 import {
   type RegistrationParameters,
-  makeRegistrationTuple,
+  makeRegistrationCallData,
 } from '../../utils/registerHelpers.js'
-import { wrappedLabelLengthCheck } from '../../utils/wrapper.js'
 
 export type RegisterNameDataParameters = RegistrationParameters & {
   /** Value of registration */
@@ -57,9 +56,6 @@ export const makeFunctionData = <
       details: 'Only 2ld-eth name registration is supported',
     })
 
-  const labels = args.name.split('.')
-  wrappedLabelLengthCheck(labels[0])
-
   return {
     to: getChainContractAddress({
       client: wallet,
@@ -68,7 +64,7 @@ export const makeFunctionData = <
     data: encodeFunctionData({
       abi: ethRegistrarControllerRegisterSnippet,
       functionName: 'register',
-      args: makeRegistrationTuple(args),
+      args: [makeRegistrationCallData(args)],
     }),
     value,
   }
@@ -128,7 +124,7 @@ async function registerName<
     resolverAddress,
     records,
     reverseRecord,
-    fuses,
+    referrer,
     value,
     ...txArgs
   }: RegisterNameParameters<TChain, TAccount, TChainOverride>,
@@ -141,7 +137,7 @@ async function registerName<
     resolverAddress,
     records,
     reverseRecord,
-    fuses,
+    referrer,
     value,
   })
   const writeArgs = {

package/src/functions/wallet/renewNames.ts

@@ -1,6 +1,7 @@
 import {
   type Account,
   type Hash,
+  type Hex,
   type SendTransactionParameters,
   type Transport,
   encodeFunctionData,
@@ -16,6 +17,7 @@ import type {
   SimpleTransactionRequest,
   WriteTransactionParameters,
 } from '../../types.js'
+import { EMPTY_BYTES32 } from '../../utils/consts.js'
 import { getNameType } from '../../utils/getNameType.js'
 
 export type RenewNamesDataParameters = {
@@ -23,6 +25,8 @@ export type RenewNamesDataParameters = {
   nameOrNames: string | string[]
   /** Duration to renew name(s) for */
   duration: bigint | number
+  /** Referrer data */
+  referrer?: Hex
   /** Value of all renewals */
   value: bigint
 }
@@ -47,7 +51,12 @@ export const makeFunctionData = <
   TAccount extends Account | undefined,
 >(
   wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  { nameOrNames, duration, value }: RenewNamesDataParameters,
+  {
+    nameOrNames,
+    duration,
+    referrer = EMPTY_BYTES32,
+    value,
+  }: RenewNamesDataParameters,
 ): RenewNamesDataReturnType => {
   const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames]
   const labels = names.map((name) => {
@@ -71,7 +80,7 @@ export const makeFunctionData = <
       data: encodeFunctionData({
         abi: ethRegistrarControllerRenewSnippet,
         functionName: 'renew',
-        args: [labels[0], BigInt(duration)],
+        args: [labels[0], BigInt(duration), referrer],
       }),
       value,
     }
@@ -85,7 +94,7 @@ export const makeFunctionData = <
     data: encodeFunctionData({
       abi: bulkRenewalRenewAllSnippet,
       functionName: 'renewAll',
-      args: [labels, BigInt(duration)],
+      args: [labels, BigInt(duration), referrer],
     }),
     value,
   }

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"}