@ensdomains/ensjs 3.0.0-beta.1 → 3.0.0-beta.10

package/src/utils/generateRecordCallArray.ts

@@ -1,6 +1,6 @@
-import { encodeFunctionData, type Hex } from 'viem'
-import { publicResolverClearRecordsSnippet } from '../contracts/publicResolver.js'
+import { type Hex } from 'viem'
 import type { Prettify } from '../types.js'
+import { encodeClearRecords } from './encoders/encodeClearRecords.js'
 import {
   encodeSetAbi,
   type EncodeSetAbiParameters,
@@ -39,13 +39,7 @@ export const generateRecordCallArray = ({
   const calls: Hex[] = []
 
   if (clearRecords) {
-    calls.push(
-      encodeFunctionData({
-        abi: publicResolverClearRecordsSnippet,
-        functionName: 'clearRecords',
-        args: [namehash],
-      }),
-    )
+    calls.push(encodeClearRecords(namehash))
   }
 
   if (typeof contentHash === 'string') {

package/src/utils/index.ts

@@ -1,9 +1,12 @@
 export {
+  contentTypeToEncodeAs,
   encodeAbi,
+  encodeAsToContentType,
   type EncodeAbiParameters,
   type EncodeAbiReturnType,
   type EncodedAbi,
 } from './encoders/encodeAbi.js'
+export { encodeClearRecords } from './encoders/encodeClearRecords.js'
 export {
   encodeSetAbi,
   type EncodeSetAbiParameters,
@@ -32,17 +35,46 @@ export {
   MAX_INT_64,
   MINIMUM_DOT_ETH_CHARS,
 } from './consts.js'
+export {
+  ChildFuseKeys,
+  ChildFuseReference,
+  ChildFuses,
+  FullParentFuseKeys,
+  FullParentFuseReference,
+  FullParentFuses,
+  FuseRanges,
+  ParentFuseKeys,
+  ParentFuseReference,
+  ParentFuses,
+  UnnamedChildFuseKeys,
+  UnnamedChildFuses,
+  UnnamedParentFuseKeys,
+  UnnamedParentFuses,
+  UserSettableFuseKeys,
+  UserSettableFuses,
+  checkPccBurned,
+  decodeFuses,
+  encodeFuses,
+  type ChildFuseReferenceType,
+  type DecodedFuses,
+  type EncodeChildFusesInputObject,
+  type EncodeFusesInputObject,
+  type EncodeParentFusesInputObject,
+  type FullParentFuseReferenceType,
+  type ParentFuseReferenceType,
+} from './fuses.js'
 
 export {
-  decodeContenthash,
-  encodeContenthash,
+  decodeContentHash,
+  encodeContentHash,
+  getDisplayCodec,
+  getInternalCodec,
   getProtocolType,
-  isValidContenthash,
-  validateContent,
+  isValidContentHash,
   type DecodedContentHash,
   type ProtocolType,
 } from './contentHash.js'
-export { bracketFormat, formatHashed, truncateFormat } from './format.js'
+export { truncateFormat } from './format.js'
 export {
   generateRecordCallArray,
   type RecordOptions,

package/src/utils/normaliseCoinId.ts

@@ -0,0 +1,36 @@
+import {
+  getCoderByCoinName,
+  getCoderByCoinType,
+  type Coin,
+} from '@ensdomains/address-encoder'
+import { CoinFormatterNotFoundError } from '../errors/public.js'
+
+export const normaliseCoinId = (coinId: string | number) => {
+  const isString = typeof coinId === 'string'
+
+  if (isString && Number.isNaN(parseInt(coinId))) {
+    return {
+      type: 'name',
+      value: coinId.toLowerCase().replace(/legacy$/, 'Legacy'),
+    } as const
+  }
+  return {
+    type: 'id',
+    value: isString ? parseInt(coinId as string) : (coinId as number),
+  } as const
+}
+
+export const getCoderFromCoin = (coinId: string | number): Coin => {
+  const normalisedCoin = normaliseCoinId(coinId)
+  let coder: Coin
+  try {
+    coder =
+      normalisedCoin.type === 'id'
+        ? getCoderByCoinType(normalisedCoin.value)
+        : getCoderByCoinName(normalisedCoin.value)
+  } catch {
+    throw new CoinFormatterNotFoundError({ coinType: coinId })
+  }
+
+  return coder
+}

package/src/utils/registerHelpers.ts

@@ -10,7 +10,7 @@ import {
 } from 'viem'
 import { CampaignReferenceTooLargeError } from '../errors/utils.js'
 import { EMPTY_ADDRESS } from './consts.js'
-import { encodeFuses, hasFuses, type CombinedFuseInput } from './fuses.js'
+import { encodeFuses, type EncodeChildFusesInputObject } from './fuses.js'
 import {
   generateRecordCallArray,
   type RecordOptions,
@@ -33,7 +33,7 @@ export type RegistrationParameters = {
   /** Sets primary name upon registration */
   reverseRecord?: boolean
   /** Fuses to set upon registration */
-  fuses?: CombinedFuseInput['child']
+  fuses?: EncodeChildFusesInputObject
 }
 
 export type CommitmentTuple = [
@@ -95,7 +95,9 @@ export const makeCommitmentTuple = ({
 }: RegistrationParameters): CommitmentTuple => {
   const labelHash = labelhash(name.split('.')[0])
   const hash = namehash(name)
-  const fuseData = hasFuses(fuses) ? encodeFuses(fuses!, 'child') : 0
+  const fuseData = fuses
+    ? encodeFuses({ restriction: 'child', input: fuses })
+    : 0
 
   if (
     reverseRecord &&

package/src/wallet.ts

@@ -1,85 +1,126 @@
+export {
+  default as clearRecords,
+  type ClearRecordsDataParameters,
+  type ClearRecordsDataReturnType,
+  type ClearRecordsParameters,
+  type ClearRecordsReturnType,
+} from './functions/wallet/clearRecords.js'
 export {
   default as commitName,
+  type CommitNameDataParameters,
+  type CommitNameDataReturnType,
   type CommitNameParameters,
   type CommitNameReturnType,
 } from './functions/wallet/commitName.js'
 export {
   default as createSubname,
+  type CreateSubnameDataParameters,
+  type CreateSubnameDataReturnType,
   type CreateSubnameParameters,
   type CreateSubnameReturnType,
 } from './functions/wallet/createSubname.js'
 export {
   default as deleteSubname,
+  type DeleteSubnameDataParameters,
+  type DeleteSubnameDataReturnType,
   type DeleteSubnameParameters,
   type DeleteSubnameReturnType,
 } from './functions/wallet/deleteSubname.js'
 export {
   default as registerName,
+  type RegisterNameDataParameters,
+  type RegisterNameDataReturnType,
   type RegisterNameParameters,
   type RegisterNameReturnType,
 } from './functions/wallet/registerName.js'
 export {
   default as renewNames,
+  type RenewNamesDataParameters,
+  type RenewNamesDataReturnType,
   type RenewNamesParameters,
   type RenewNamesReturnType,
 } from './functions/wallet/renewNames.js'
 export {
   default as setAbiRecord,
+  type SetAbiRecordDataParameters,
+  type SetAbiRecordDataReturnType,
   type SetAbiRecordParameters,
   type SetAbiRecordReturnType,
 } from './functions/wallet/setAbiRecord.js'
 export {
   default as setAddressRecord,
+  type SetAddressRecordDataParameters,
+  type SetAddressRecordDataReturnType,
   type SetAddressRecordParameters,
   type SetAddressRecordReturnType,
 } from './functions/wallet/setAddressRecord.js'
 export {
   default as setChildFuses,
+  type SetChildFusesDataParameters,
+  type SetChildFusesDataReturnType,
   type SetChildFusesParameters,
   type SetChildFusesReturnType,
 } from './functions/wallet/setChildFuses.js'
 export {
   default as setContentHashRecord,
+  type SetContentHashRecordDataParameters,
+  type SetContentHashRecordDataReturnType,
   type SetContentHashRecordParameters,
   type SetContentHashRecordReturnType,
 } from './functions/wallet/setContentHashRecord.js'
 export {
   default as setFuses,
+  type SetFusesDataParameters,
+  type SetFusesDataReturnType,
   type SetFusesParameters,
   type SetFusesReturnType,
 } from './functions/wallet/setFuses.js'
 export {
   default as setPrimaryName,
+  type SetPrimaryNameDataParameters,
+  type SetPrimaryNameDataReturnType,
   type SetPrimaryNameParameters,
   type SetPrimaryNameReturnType,
 } from './functions/wallet/setPrimaryName.js'
 export {
   default as setRecords,
+  type SetRecordsDataParameters,
+  type SetRecordsDataReturnType,
   type SetRecordsParameters,
   type SetRecordsReturnType,
 } from './functions/wallet/setRecords.js'
 export {
   default as setResolver,
+  type SetResolverDataParameters,
+  type SetResolverDataReturnType,
   type SetResolverParameters,
   type SetResolverReturnType,
 } from './functions/wallet/setResolver.js'
 export {
   default as setTextRecord,
+  type SetTextRecordDataParameters,
+  type SetTextRecordDataReturnType,
   type SetTextRecordParameters,
   type SetTextRecordReturnType,
 } from './functions/wallet/setTextRecord.js'
 export {
   default as transferName,
+  type TransferNameDataParameters,
+  type TransferNameDataReturnType,
   type TransferNameParameters,
   type TransferNameReturnType,
 } from './functions/wallet/transferName.js'
 export {
   default as unwrapName,
+  type UnwrapNameDataParameters,
+  type UnwrapNameDataReturnType,
   type UnwrapNameParameters,
   type UnwrapNameReturnType,
 } from './functions/wallet/unwrapName.js'
 export {
   default as wrapName,
+  type WrapNameDataParameters,
+  type WrapNameDataReturnType,
   type WrapNameParameters,
   type WrapNameReturnType,
 } from './functions/wallet/wrapName.js'

package/dist/types/functions/dns/prepareDnsImport.d.ts

@@ -1,39 +0,0 @@
-import type { ClientWithEns } from '../../contracts/consts.js';
-import type { Endpoint } from './types.js';
-export type PrepareDnsImportParameters = {
-    /** Name to prepare for DNS import */
-    name: string;
-    /** An RFC-1035 compatible DNS endpoint to use (default: `https://cloudflare-dns.com/dns-query`) */
-    endpoint?: Endpoint;
-};
-export type RrSetWithSig = {
-    rrset: Uint8Array;
-    sig: Uint8Array;
-};
-export type PrepareDnsImportReturnType = {
-    rrsets: RrSetWithSig[];
-    proof: Uint8Array;
-};
-/**
- * Creates prepared data for `importDnsName()`
- * @param client - {@link ClientWithEns}
- * @param parameters - {@link PrepareDnsImportParameters}
- * @returns Prepared data object
- *
- * @example
- * import { createPublicClient, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addContracts, prepareDnsImport } from '@ensdomains/ensjs'
- *
- * const mainnetWithEns = addContracts([mainnet])
- * const client = createPublicClient({
- *   chain: mainnetWithEns,
- *   transport: http(),
- * })
- * const preparedData = await prepareDnsImport(client, {
- *   name: 'example.eth',
- * })
- */
-declare const prepareDnsImport: (client: ClientWithEns, { name, endpoint, }: PrepareDnsImportParameters) => Promise<PrepareDnsImportReturnType>;
-export default prepareDnsImport;
-//# sourceMappingURL=prepareDnsImport.d.ts.map

package/src/@types/@ensdomains/content-hash.d.ts

@@ -1 +0,0 @@
-declare module '@ensdomains/content-hash'

package/src/functions/dns/getDnsOwner.test.ts

@@ -1,195 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import type { RequestListener } from 'http'
-import { getVersion } from '../../errors/error-utils.js'
-import { createHttpServer } from '../../tests/createHttpServer.js'
-import getDnsOwner from './getDnsOwner.js'
-
-const handler: jest.MockedFunction<RequestListener> = jest.fn()
-let closeServer: () => Promise<unknown>
-let serverUrl: `http://${string}` = 'http://'
-
-beforeAll(async () => {
-  const { close, url } = await createHttpServer(handler)
-  closeServer = close
-  serverUrl = url
-})
-
-afterAll(async () => {
-  await closeServer()
-})
-
-beforeEach(() => {
-  handler.mockReset()
-})
-
-it('returns valid address from valid domain and record', async () => {
-  let name
-  let type
-  handler.mockImplementation((req, res) => {
-    const url = new URL(req.url!, `http://${req.headers.host!}`)
-    name = url.searchParams.get('name')
-    type = url.searchParams.get('type')
-
-    res.writeHead(200, { 'Content-Type': 'application/dns-json' })
-    res.end(
-      JSON.stringify({
-        Status: 0,
-        AD: true,
-        Answer: [
-          {
-            name: '_ens.example.com',
-            type: 16,
-            TTL: 0,
-            data: '"a=0x8e8Db5CcEF88cca9d624701Db544989C996E3216"',
-          },
-        ],
-      }),
-    )
-    res.destroy()
-  })
-
-  const result = await getDnsOwner({ name: 'example.com', endpoint: serverUrl })
-  expect(handler).toHaveBeenCalled()
-  expect(name).toBe('_ens.example.com.')
-  expect(type).toBe('TXT')
-  expect(result).toEqual('0x8e8Db5CcEF88cca9d624701Db544989C996E3216')
-})
-
-it('throws error if .eth', async () => {
-  await expect(getDnsOwner({ name: 'example.eth' })).rejects
-    .toThrowErrorMatchingInlineSnapshot(`
-    "Unsupported name type: eth-2ld
-
-    - Supported name types: other-2ld
-
-    Version: ${getVersion()}"
-  `)
-})
-it('throws error if >2ld', async () => {
-  await expect(getDnsOwner({ name: 'subdomain.example.com' })).rejects
-    .toThrowErrorMatchingInlineSnapshot(`
-    "Unsupported name type: other-subname
-
-    - Supported name types: other-2ld
-
-    Version: ${getVersion()}"
-  `)
-})
-it('returns error if DnsResponseStatus is not NOERROR', async () => {
-  handler.mockImplementation((_req, res) => {
-    res.writeHead(200, { 'Content-Type': 'application/dns-json' })
-    res.end(
-      JSON.stringify({
-        Status: 3, // NXDOMAIN
-        AD: true,
-      }),
-    )
-    res.destroy()
-  })
-
-  await expect(getDnsOwner({ name: 'example.com', endpoint: serverUrl }))
-    .rejects.toThrowErrorMatchingInlineSnapshot(`
-    "DNS query failed with status: NXDOMAIN
-
-    Version: ${getVersion()}"
-  `)
-})
-it('returns error if AD is false', async () => {
-  handler.mockImplementation((_req, res) => {
-    res.writeHead(200, { 'Content-Type': 'application/dns-json' })
-    res.end(
-      JSON.stringify({
-        Status: 0,
-        AD: false,
-      }),
-    )
-    res.destroy()
-  })
-
-  await expect(getDnsOwner({ name: 'example.com', endpoint: serverUrl }))
-    .rejects.toThrowErrorMatchingInlineSnapshot(`
-    "DNSSEC verification failed
-
-    Version: ${getVersion()}"
-  `)
-})
-it('returns error if no TXT record', async () => {
-  handler.mockImplementation((_req, res) => {
-    res.writeHead(200, { 'Content-Type': 'application/dns-json' })
-    res.end(
-      JSON.stringify({
-        Status: 0,
-        AD: true,
-        Answer: [],
-      }),
-    )
-    res.destroy()
-  })
-
-  await expect(getDnsOwner({ name: 'example.com', endpoint: serverUrl }))
-    .rejects.toThrowErrorMatchingInlineSnapshot(`
-    "No TXT record found
-
-    Version: ${getVersion()}"
-  `)
-})
-it('returns error if TXT record is not formatted correctly', async () => {
-  handler.mockImplementation((_req, res) => {
-    res.writeHead(200, { 'Content-Type': 'application/dns-json' })
-    res.end(
-      JSON.stringify({
-        Status: 0,
-        AD: true,
-        Answer: [
-          {
-            name: '_ens.example.com',
-            type: 16,
-            TTL: 0,
-            data: '"0x8e8Db5CcEF88cca9d624701Db544989C996E3216"',
-          },
-        ],
-      }),
-    )
-    res.destroy()
-  })
-
-  await expect(getDnsOwner({ name: 'example.com', endpoint: serverUrl }))
-    .rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Invalid TXT record: 0x8e8Db5CcEF88cca9d624701Db544989C996E3216
-
-    Version: ${getVersion()}"
-  `)
-})
-it('returns error if address is not checksummed', async () => {
-  handler.mockImplementation((_req, res) => {
-    res.writeHead(200, { 'Content-Type': 'application/dns-json' })
-    res.end(
-      JSON.stringify({
-        Status: 0,
-        AD: true,
-        Answer: [
-          {
-            name: '_ens.example.com',
-            type: 16,
-            TTL: 0,
-            data: '"a=0x8e8db5CcEF88cca9d624701Db544989C996E3216"',
-          },
-        ],
-      }),
-    )
-    res.destroy()
-  })
-
-  await expect(getDnsOwner({ name: 'example.com', endpoint: serverUrl }))
-    .rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Invalid address checksum: 0x8e8db5CcEF88cca9d624701Db544989C996E3216
-
-    Version: ${getVersion()}"
-  `)
-})
-it('real test', async () => {
-  const result = await getDnsOwner({
-    name: 'taytems.xyz',
-  })
-  expect(result).toEqual('0x8e8Db5CcEF88cca9d624701Db544989C996E3216')
-})

package/src/functions/dns/importDnsName.test.ts

@@ -1,117 +0,0 @@
-import { parseEther, type Address, type Hex } from 'viem'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { getVersion } from '../../errors/error-utils.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import getOwner from '../public/getOwner.js'
-import getResolver from '../public/getResolver.js'
-import importDnsName from './importDnsName.js'
-import prepareDnsImport from './prepareDnsImport.js'
-
-const name = 'taytems.xyz'
-const address = '0x8e8Db5CcEF88cca9d624701Db544989C996E3216'
-
-let snapshot: Hex
-let accounts: Address[]
-
-beforeAll(async () => {
-  accounts = await walletClient.getAddresses()
-})
-
-beforeEach(async () => {
-  snapshot = await testClient.snapshot()
-})
-
-afterEach(async () => {
-  await testClient.revert({ id: snapshot })
-})
-
-it('should import a DNS name with no address', async () => {
-  const tx = await importDnsName(walletClient, {
-    name,
-    preparedData: await prepareDnsImport(publicClient, { name }),
-    account: accounts[0],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner(publicClient, { name })
-  expect(owner!.owner).toBe(address)
-})
-it('should import a DNS name with an address, using default resolver', async () => {
-  await testClient.impersonateAccount({ address })
-  await testClient.setBalance({
-    address,
-    value: parseEther('1'),
-  })
-
-  const tx = await importDnsName(walletClient, {
-    name,
-    address,
-    preparedData: await prepareDnsImport(publicClient, { name }),
-    account: address,
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner(publicClient, { name })
-  expect(owner!.owner).toBe(address)
-  const resolver = await getResolver(publicClient, { name })
-  expect(resolver).toBe(
-    getChainContractAddress({
-      client: publicClient,
-      contract: 'ensPublicResolver',
-    }),
-  )
-})
-it('should import a DNS name with an address, using a custom resolver', async () => {
-  await testClient.impersonateAccount({ address })
-  await testClient.setBalance({
-    address,
-    value: parseEther('1'),
-  })
-
-  const legacyResolverAddress = JSON.parse(
-    process.env.DEPLOYMENT_ADDRESSES!,
-  ).LegacyPublicResolver
-
-  const tx = await importDnsName(walletClient, {
-    name,
-    address,
-    preparedData: await prepareDnsImport(publicClient, { name }),
-    account: address,
-    resolverAddress: legacyResolverAddress,
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner(publicClient, { name })
-  expect(owner!.owner).toBe(address)
-  const resolver = await getResolver(publicClient, { name })
-  expect(resolver).toBe(legacyResolverAddress)
-})
-it('should throw error if resolver is specified when claiming without an address', async () => {
-  await expect(
-    importDnsName(walletClient, {
-      name,
-      resolverAddress: address,
-      preparedData: await prepareDnsImport(publicClient, { name }),
-      account: accounts[0],
-    } as any),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Additional parameter specified: resolverAddress
-
-    - Allowed parameters: name, preparedData
-
-    Details: resolverAddress cannot be specified when claiming without an address
-
-    Version: ${getVersion()}"
-  `)
-})