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

package/src/functions/wallet/setTextRecord.ts

@@ -60,7 +60,8 @@ export const makeFunctionData = <
  * @example
  * import { createWalletClient, custom } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, setTextRecord } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { setTextRecord } from '@ensdomains/ensjs/wallet'
  *
  * const wallet = createWalletClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/wallet/transferName.ts

@@ -60,7 +60,7 @@ type BaseRegistrarTransferNameDataParameters = {
   asParent?: never
 }
 
-type TransferNameDataParameters = BaseTransferNameDataParameters &
+export type TransferNameDataParameters = BaseTransferNameDataParameters &
   (
     | RegistryOrNameWrapperTransferNameDataParameters
     | BaseRegistrarTransferNameDataParameters
@@ -209,7 +209,8 @@ export const makeFunctionData = <
  * @example
  * import { createWalletClient, custom } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, transferName } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { transferName } from '@ensdomains/ensjs/wallet'
  *
  * const wallet = createWalletClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/wallet/unwrapName.ts

@@ -127,7 +127,8 @@ export const makeFunctionData = <
  * @example
  * import { createWalletClient, custom } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, unwrapName } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { unwrapName } from '@ensdomains/ensjs/wallet'
  *
  * const wallet = createWalletClient({
  *   chain: addEnsContracts(mainnet),

package/src/functions/wallet/wrapName.ts

@@ -22,7 +22,10 @@ import type {
   SimpleTransactionRequest,
   WriteTransactionParameters,
 } from '../../types.js'
-import { encodeFuses, type CombinedFuseInput } from '../../utils/fuses.js'
+import {
+  encodeFuses,
+  type EncodeChildFusesInputObject,
+} from '../../utils/fuses.js'
 import { packetToBytes } from '../../utils/hexEncodedName.js'
 import { checkIsDotEth } from '../../utils/validation.js'
 import { wrappedLabelLengthCheck } from '../../utils/wrapper.js'
@@ -37,7 +40,7 @@ export type WrapNameDataParameters<
   newOwnerAddress: Address
   /** Fuses to set on wrap (eth-2ld only) */
   fuses?: TNameOption extends Eth2ldNameSpecifier
-    ? CombinedFuseInput['child']
+    ? EncodeChildFusesInputObject
     : never
   /** The resolver address to set on wrap */
   resolverAddress?: Address
@@ -83,7 +86,9 @@ export const makeFunctionData = <
 
   if (isEth2ld) {
     wrappedLabelLengthCheck(labels[0])
-    const encodedFuses = fuses ? encodeFuses(fuses, 'child') : 0
+    const encodedFuses = fuses
+      ? encodeFuses({ restriction: 'child', input: fuses })
+      : 0
     const tokenId = BigInt(labelhash(labels[0]))
 
     const data = encodeAbiParameters(
@@ -136,7 +141,8 @@ export const makeFunctionData = <
  * @example
  * import { createWalletClient, custom } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { addEnsContracts, wrapName } from '@ensdomains/ensjs'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { wrapName } from '@ensdomains/ensjs/wallet'
  *
  * const wallet = createWalletClient({
  *   chain: addEnsContracts(mainnet),

package/src/index.ts

@@ -59,7 +59,6 @@ export {
   FusesInvalidFuseObjectError,
   FusesInvalidNamedFuseError,
   FusesInvalidUnnamedFuseError,
-  FusesNonIntegerError,
   FusesOutOfRangeError,
   FusesRestrictionNotAllowedError,
   FusesValueRequiredError,

package/src/subgraph.ts

@@ -63,3 +63,8 @@ export {
   type GetSubnamesParameters,
   type GetSubnamesReturnType,
 } from './functions/subgraph/getSubnames.js'
+export {
+  getChecksumAddressOrNull,
+  makeNameObject,
+  type Name,
+} from './functions/subgraph/utils.js'

package/src/types.ts

@@ -11,9 +11,12 @@ export type Prettify<T> = {
   [K in keyof T]: T[K]
 } & {}
 
-export type SimpleTransactionRequest = Prettify<
-  Required<Pick<TransactionRequest, 'to' | 'data'>>
->
+export type SimpleTransactionRequest = {
+  [P in keyof Pick<TransactionRequest, 'to' | 'data'>]-?: Exclude<
+    TransactionRequest[P],
+    null
+  >
+}
 
 export type TransactionRequestWithPassthrough = SimpleTransactionRequest & {
   passthrough?: any

package/src/utils/contentHash.ts

@@ -1,5 +1,11 @@
-import contentHash from '@ensdomains/content-hash'
+import {
+  decode,
+  encode,
+  getCodec,
+  type Codec as InternalCodec,
+} from '@ensdomains/content-hash'
 import { isHex, type Hex } from 'viem'
+import { InvalidContentHashError } from '../errors/utils.js'
 
 export type ProtocolType =
   | 'ipfs'
@@ -16,16 +22,6 @@ export type DecodedContentHash = {
   decoded: string
 }
 
-const supportedCodecs = [
-  'ipns-ns',
-  'ipfs-ns',
-  'swarm-ns',
-  'onion',
-  'onion3',
-  'skynet-ns',
-  'arweave-ns',
-]
-
 function matchProtocol(text: string) {
   return (
     text.match(/^(ipfs|sia|ipns|bzz|onion|onion3|arweave|ar):\/\/(.*)/) ||
@@ -34,117 +30,73 @@ function matchProtocol(text: string) {
   )
 }
 
-export function decodeContenthash(encoded: Hex): DecodedContentHash | null {
+export const getDisplayCodec = (encoded: string): ProtocolType => {
+  const codec = getCodec(encoded)
+  switch (codec) {
+    case 'ipfs':
+    case 'ipns':
+    case 'onion':
+    case 'onion3':
+      return codec
+    case 'swarm':
+      return 'bzz'
+    case 'skynet':
+      return 'sia'
+    case 'arweave':
+      return 'ar'
+    default:
+      return null
+  }
+}
+
+export const getInternalCodec = (
+  displayCodec: NonNullable<ProtocolType>,
+): InternalCodec => {
+  switch (displayCodec) {
+    case 'bzz':
+      return 'swarm'
+    case 'sia':
+      return 'skynet'
+    case 'ar':
+      return 'arweave'
+    default:
+      return displayCodec
+  }
+}
+
+export function decodeContentHash(encoded: Hex): DecodedContentHash | null {
   if (!encoded || encoded === '0x') {
     return null
   }
-  let decoded = contentHash.decode(encoded)
-  let protocolType: ProtocolType = null
-  const codec = contentHash.getCodec(encoded)
-  if (codec === 'ipfs-ns') {
-    protocolType = 'ipfs'
-  } else if (codec === 'ipns-ns') {
-    protocolType = 'ipns'
-  } else if (codec === 'swarm-ns') {
-    protocolType = 'bzz'
-  } else if (codec === 'onion') {
-    protocolType = 'onion'
-  } else if (codec === 'onion3') {
-    protocolType = 'onion3'
-  } else if (codec === 'skynet-ns') {
-    protocolType = 'sia'
-  } else if (codec === 'arweave-ns') {
-    protocolType = 'ar'
-  } else {
-    decoded = encoded
-  }
+  const decoded = decode(encoded)
+  const protocolType = getDisplayCodec(encoded)
   return { protocolType, decoded }
 }
 
-export function validateContent(encoded: any) {
-  return (
-    contentHash.isHashOfType(encoded, contentHash.Types.ipfs) ||
-    contentHash.isHashOfType(encoded, contentHash.Types.swarm)
-  )
+export function isValidContentHash(encoded: unknown) {
+  if (typeof encoded !== 'string') return false
+  const codec = getCodec(encoded)
+  return Boolean(codec && isHex(encoded))
 }
 
-export function isValidContenthash(encoded: any) {
-  try {
-    const codec = contentHash.getCodec(encoded)
-    return isHex(encoded) && supportedCodecs.includes(codec)
-  } catch (e) {
-    console.log(e)
-  }
-  return false
+export function getProtocolType(encoded: string) {
+  const matched = matchProtocol(encoded)
+  if (!matched) return null
+  const [, protocolType, decoded] = matched
+  return { protocolType: protocolType as NonNullable<ProtocolType>, decoded }
 }
 
-export function getProtocolType(encoded: any) {
-  let protocolType
-  let decoded
-  try {
-    const matched = matchProtocol(encoded)
-    if (matched) {
-      ;[, protocolType, decoded] = matched
-    }
-    return {
-      protocolType,
-      decoded,
-    }
-  } catch (e) {
-    console.log(e)
-  }
-  return
-}
+export function encodeContentHash(text: string): Hex {
+  const typeData = getProtocolType(text)
+  if (!typeData) throw new InvalidContentHashError()
 
-export function encodeContenthash(text: string) {
-  let content = text
-  let contentType
-  let encoded: string | boolean = false
-  let error
-  if (text) {
-    const matched = matchProtocol(text)
-    if (matched) {
-      ;[, contentType, content] = matched
-    }
-    try {
-      if (contentType === 'ipfs') {
-        if (content.length >= 4) {
-          encoded = `0x${contentHash.encode('ipfs-ns', content)}`
-        }
-      } else if (contentType === 'ipns') {
-        encoded = `0x${contentHash.encode('ipns-ns', content)}`
-      } else if (contentType === 'bzz') {
-        if (content.length >= 4) {
-          encoded = `0x${contentHash.fromSwarm(content)}`
-        }
-      } else if (contentType === 'onion') {
-        if (content.length === 16) {
-          encoded = `0x${contentHash.encode('onion', content)}`
-        }
-      } else if (contentType === 'onion3') {
-        if (content.length === 56) {
-          encoded = `0x${contentHash.encode('onion3', content)}`
-        }
-      } else if (contentType === 'sia') {
-        if (content.length === 46) {
-          encoded = `0x${contentHash.encode('skynet-ns', content)}`
-        }
-      } else if (contentType === 'arweave' || contentType === 'ar') {
-        if (content.length === 43) {
-          encoded = `0x${contentHash.encode('arweave-ns', content)}`
-        }
-      } else {
-        console.warn('Unsupported protocol or invalid value', {
-          contentType,
-          text,
-        })
-      }
-    } catch (err) {
-      const errorMessage = 'Error encoding content hash'
-      console.warn(errorMessage, { text, encoded })
-      error = errorMessage
-      // throw 'Error encoding content hash'
-    }
-  }
-  return { encoded, error }
+  const internalCodec = getInternalCodec(typeData.protocolType)
+
+  // manual exceptions for onion/onion3 which are just utf8 encoded
+  if (internalCodec === 'onion' && typeData.decoded.length !== 16)
+    throw new InvalidContentHashError()
+  if (internalCodec === 'onion3' && typeData.decoded.length !== 56)
+    throw new InvalidContentHashError()
+
+  return `0x${encode(internalCodec, typeData.decoded)}`
 }

package/src/utils/encoders/encodeAbi.ts

@@ -1,16 +1,18 @@
 import { bytesToHex, stringToHex, type Hex } from 'viem'
+import { UnknownContentTypeError } from '../../errors/utils.js'
 import type { Prettify } from '../../types.js'
 
 type AbiEncodeAs = 'json' | 'zlib' | 'cbor' | 'uri'
 
 type AbiContentType = 1 | 2 | 4 | 8
 
-type AbiEncodeMap = {
-  json: 1
-  zlib: 2
-  cbor: 4
-  uri: 8
-}
+const abiEncodeMap = {
+  json: 1,
+  zlib: 2,
+  cbor: 4,
+  uri: 8,
+} as const
+type AbiEncodeMap = typeof abiEncodeMap
 
 type GetAbiContentType<TEncodeAs extends AbiEncodeAs> = AbiEncodeMap[TEncodeAs]
 
@@ -33,6 +35,33 @@ export type EncodedAbi<TContentType extends AbiContentType = AbiContentType> = {
 export type EncodeAbiReturnType<TContentType extends AbiContentType> =
   EncodedAbi<TContentType>
 
+export const contentTypeToEncodeAs = (
+  contentType: AbiContentType,
+): AbiEncodeAs => {
+  switch (contentType) {
+    case 1:
+      return 'json'
+    case 2:
+      return 'zlib'
+    case 4:
+      return 'cbor'
+    case 8:
+      return 'uri'
+    default:
+      throw new UnknownContentTypeError({ contentType })
+  }
+}
+
+export const encodeAsToContentType = (
+  encodeAs: AbiEncodeAs,
+): AbiContentType => {
+  const contentType = abiEncodeMap[encodeAs]
+  if (contentType === undefined) {
+    throw new UnknownContentTypeError({ contentType: encodeAs })
+  }
+  return contentType
+}
+
 export const encodeAbi = async <
   TEncodeAs extends AbiEncodeAs,
   TContentType extends GetAbiContentType<TEncodeAs>,
@@ -57,8 +86,8 @@ export const encodeAbi = async <
     }
     case 'cbor': {
       contentType = 4
-      const { encode } = await import('cbor')
-      encodedData = bytesToHex(encode(data))
+      const { cborEncode } = await import('@ensdomains/address-encoder/utils')
+      encodedData = bytesToHex(new Uint8Array(cborEncode(data)))
       break
     }
     default: {

package/src/utils/encoders/encodeClearRecords.ts

@@ -0,0 +1,9 @@
+import { encodeFunctionData, type Hex } from 'viem'
+import { publicResolverClearRecordsSnippet } from '../../contracts/publicResolver.js'
+
+export const encodeClearRecords = (namehash: Hex) =>
+  encodeFunctionData({
+    abi: publicResolverClearRecordsSnippet,
+    functionName: 'clearRecords',
+    args: [namehash],
+  })

package/src/utils/encoders/encodeSetAddr.ts

@@ -1,6 +1,6 @@
-import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
 import { bytesToHex, encodeFunctionData, type Address, type Hex } from 'viem'
 import { publicResolverSetAddrSnippet } from '../../contracts/publicResolver.js'
+import { getCoderFromCoin } from '../normaliseCoinId.js'
 
 export type EncodeSetAddrParameters = {
   namehash: Hex
@@ -15,22 +15,11 @@ export const encodeSetAddr = ({
   coin,
   value,
 }: EncodeSetAddrParameters): EncodeSetAddrReturnType => {
-  let coinTypeInstance
-  if (typeof coin === 'number') {
-    coinTypeInstance = formatsByCoinType[coin]
-  } else if (!Number.isNaN(parseInt(coin))) {
-    coinTypeInstance = formatsByCoinType[parseInt(coin)]
-  } else {
-    coinTypeInstance = formatsByName[coin.toUpperCase()]
-  }
-  const inputCoinType = coinTypeInstance.coinType
-  let encodedAddress: Hex | Uint8Array = value
-    ? coinTypeInstance.decoder(value)
-    : '0x'
+  const coder = getCoderFromCoin(coin)
+  const inputCoinType = coder.coinType
+  let encodedAddress: Hex | Uint8Array = value ? coder.decode(value) : '0x'
   if (inputCoinType === 60 && encodedAddress === '0x')
-    encodedAddress = coinTypeInstance.decoder(
-      '0x0000000000000000000000000000000000000000',
-    )
+    encodedAddress = coder.decode('0x0000000000000000000000000000000000000000')
   if (typeof encodedAddress !== 'string') {
     encodedAddress = bytesToHex(encodedAddress)
   }

package/src/utils/encoders/encodeSetContentHash.ts

@@ -1,6 +1,6 @@
 import { encodeFunctionData, type Hex } from 'viem'
 import { publicResolverSetContenthashSnippet } from '../../contracts/publicResolver.js'
-import { encodeContenthash } from '../contentHash.js'
+import { encodeContentHash } from '../contentHash.js'
 
 export type EncodeSetContentHashParameters = {
   namehash: Hex
@@ -15,9 +15,7 @@ export const encodeSetContentHash = ({
 }: EncodeSetContentHashParameters): EncodeSetContentHashReturnType => {
   let encodedHash: Hex = '0x'
   if (contentHash) {
-    const encodedObject = encodeContenthash(contentHash)
-    if (encodedObject.error) throw new Error(encodedObject.error)
-    encodedHash = encodedObject.encoded as Hex
+    encodedHash = encodeContentHash(contentHash)
   }
   return encodeFunctionData({
     abi: publicResolverSetContenthashSnippet,

package/src/utils/format.ts

@@ -1,8 +1,2 @@
-export const formatHashed = (name: string): string =>
-  name.replace(/(\[)(.{64})(\])/g, '0x$2')
-
 export const truncateFormat = (name: string): string =>
   name.replace(/(\[.{3})(.{58})(.{3}\])/g, '$1...$3')
-
-export const bracketFormat = (name: string): string =>
-  name.replace(/(0x)(.{64})(?=\.)/g, '[$2]')