@ensdomains/ensjs 3.0.0-alpha.9 → 3.0.0-beta.10

package/src/public.ts

@@ -0,0 +1,100 @@
+export {
+  default as _getAbi,
+  type InternalGetAbiParameters,
+  type InternalGetAbiReturnType,
+} from './functions/public/_getAbi.js'
+export {
+  default as _getAddr,
+  type InternalGetAddrParameters,
+  type InternalGetAddrReturnType,
+} from './functions/public/_getAddr.js'
+export {
+  default as _getContentHash,
+  type InternalGetContentHashParameters,
+  type InternalGetContentHashReturnType,
+} from './functions/public/_getContentHash.js'
+export {
+  default as _getText,
+  type InternalGetTextParameters,
+  type InternalGetTextReturnType,
+} from './functions/public/_getText.js'
+export {
+  default as batch,
+  type BatchParameters,
+  type BatchReturnType,
+} from './functions/public/batch.js'
+export {
+  default as getAbiRecord,
+  type GetAbiRecordParameters,
+  type GetAbiRecordReturnType,
+} from './functions/public/getAbiRecord.js'
+export {
+  default as getAddressRecord,
+  type GetAddressRecordParameters,
+  type GetAddressRecordReturnType,
+} from './functions/public/getAddressRecord.js'
+export {
+  default as getAvailable,
+  type GetAvailableParameters,
+  type GetAvailableReturnType,
+} from './functions/public/getAvailable.js'
+export {
+  default as getContentHashRecord,
+  type GetContentHashRecordParameters,
+  type GetContentHashRecordReturnType,
+} from './functions/public/getContentHashRecord.js'
+export {
+  default as getExpiry,
+  type GetExpiryParameters,
+  type GetExpiryReturnType,
+} from './functions/public/getExpiry.js'
+export {
+  default as getName,
+  type GetNameParameters,
+  type GetNameReturnType,
+} from './functions/public/getName.js'
+export {
+  default as getOwner,
+  type GetOwnerParameters,
+  type GetOwnerReturnType,
+} from './functions/public/getOwner.js'
+export {
+  default as getPrice,
+  type GetPriceParameters,
+  type GetPriceReturnType,
+} from './functions/public/getPrice.js'
+export {
+  default as getRecords,
+  type GetRecordsParameters,
+  type GetRecordsReturnType,
+} from './functions/public/getRecords.js'
+export {
+  default as getResolver,
+  type GetResolverParameters,
+  type GetResolverReturnType,
+} from './functions/public/getResolver.js'
+export {
+  default as getSupportedInterfaces,
+  type GetSupportedInterfacesParameters,
+  type GetSupportedInterfacesReturnType,
+} from './functions/public/getSupportedInterfaces.js'
+export {
+  default as getTextRecord,
+  type GetTextRecordParameters,
+  type GetTextRecordReturnType,
+} from './functions/public/getTextRecord.js'
+export {
+  default as getWrapperData,
+  type GetWrapperDataParameters,
+  type GetWrapperDataReturnType,
+} from './functions/public/getWrapperData.js'
+export {
+  default as multicallWrapper,
+  type MulticallWrapperParameters,
+  type MulticallWrapperReturnType,
+} from './functions/public/multicallWrapper.js'
+export {
+  default as universalWrapper,
+  type UniversalWrapperParameters,
+  type UniversalWrapperReturnType,
+} from './functions/public/universalWrapper.js'

package/src/subgraph.ts

@@ -0,0 +1,70 @@
+export { createSubgraphClient } from './functions/subgraph/client.js'
+export type {
+  AbiChanged,
+  AddrChanged,
+  AuthorisationChanged,
+  BaseDomainEvent,
+  BaseRegistrationEvent,
+  BaseResolverEvent,
+  ContenthashChanged,
+  DomainEvent,
+  DomainEventKey,
+  ExpiryExtended,
+  FusesSet,
+  InterfaceChanged,
+  MulticoinAddrChanged,
+  NameChanged,
+  NameRegistered,
+  NameRenewed,
+  NameTransferred,
+  NameUnwrapped,
+  NameWrapped,
+  NewOwner,
+  NewResolver,
+  NewTtl,
+  PubkeyChanged,
+  RegistrationEvent,
+  RegistrationEventKey,
+  ResolverEvent,
+  ResolverEventKey,
+  TextChanged,
+  Transfer,
+  VersionChanged,
+  WrappedTransfer,
+} from './functions/subgraph/events.js'
+export {
+  default as getDecodedName,
+  type GetDecodedNameParameters,
+  type GetDecodedNameReturnType,
+} from './functions/subgraph/getDecodedName.js'
+export {
+  default as getNameHistory,
+  type GetNameHistoryParameters,
+  type GetNameHistoryReturnType,
+} from './functions/subgraph/getNameHistory.js'
+export {
+  default as getNamesForAddress,
+  type GetNamesForAddressParameters,
+  type GetNamesForAddressReturnType,
+  type NameWithRelation,
+} from './functions/subgraph/getNamesForAddress.js'
+export {
+  default as getSubgraphRecords,
+  type GetSubgraphRecordsParameters,
+  type GetSubgraphRecordsReturnType,
+} from './functions/subgraph/getSubgraphRecords.js'
+export {
+  default as getSubgraphRegistrant,
+  type GetSubgraphRegistrantParameters,
+  type GetSubgraphRegistrantReturnType,
+} from './functions/subgraph/getSubgraphRegistrant.js'
+export {
+  default as getSubnames,
+  type GetSubnamesParameters,
+  type GetSubnamesReturnType,
+} from './functions/subgraph/getSubnames.js'
+export {
+  getChecksumAddressOrNull,
+  makeNameObject,
+  type Name,
+} from './functions/subgraph/utils.js'

package/src/types.ts

@@ -0,0 +1,120 @@
+import type {
+  Account,
+  Address,
+  Client,
+  SendTransactionParameters,
+  TransactionRequest,
+} from 'viem'
+import type { ChainWithEns } from './contracts/consts.js'
+
+export type Prettify<T> = {
+  [K in keyof T]: T[K]
+} & {}
+
+export type SimpleTransactionRequest = {
+  [P in keyof Pick<TransactionRequest, 'to' | 'data'>]-?: Exclude<
+    TransactionRequest[P],
+    null
+  >
+}
+
+export type TransactionRequestWithPassthrough = SimpleTransactionRequest & {
+  passthrough?: any
+}
+
+export type GenericPassthrough = { args: any; address: Address }
+
+export type Extended = { [K in keyof Client]?: undefined } & {
+  [key: string]: unknown
+}
+
+type AllowedWriteParameters =
+  | 'gas'
+  | 'gasPrice'
+  | 'maxFeePerGas'
+  | 'maxPriorityFeePerGas'
+  | 'nonce'
+  | 'account'
+
+export type WriteTransactionParameters<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
+> = Pick<
+  SendTransactionParameters<TChain, TAccount, TChainOverride>,
+  AllowedWriteParameters
+>
+
+export type DateWithValue<T> = {
+  date: Date
+  value: T
+}
+
+export type DecodedAbi = {
+  contentType: 1 | 2 | 4 | 8 | number
+  decoded: boolean
+  abi: string | object
+}
+
+export type DecodedAddr = {
+  id: number
+  name: string
+  value: string
+}
+
+export type DecodedText = {
+  key: string
+  value: string
+}
+
+export type AnyDate = string | number | bigint | Date
+
+export type RootName = ''
+export type TldName = `${string}`
+export type EthTldName = `eth`
+export type Eth2ldName = `${string}.eth`
+export type EthAnyName = EthTldName | Eth2ldName
+export type EthSubname = `${string}.${string}.eth`
+export type Other2ldName = `${string}.${string}`
+export type OtherSubname = `${string}.${string}.${string}`
+
+export type NameOption =
+  | TldName
+  | Eth2ldName
+  | EthSubname
+  | Other2ldName
+  | OtherSubname
+
+export type TldNameSpecifier = 'tld'
+export type Eth2ldNameSpecifier = 'eth-2ld'
+export type EthSubnameSpecifier = 'eth-subname'
+export type Other2ldNameSpecifier = 'other-2ld'
+export type OtherSubnameSpecifier = 'other-subname'
+export type RootNameSpecifier = 'root'
+export type EthTldNameSpecifier = 'eth-tld'
+
+export type NameType =
+  | TldNameSpecifier
+  | Eth2ldNameSpecifier
+  | EthSubnameSpecifier
+  | Other2ldNameSpecifier
+  | OtherSubnameSpecifier
+  | RootNameSpecifier
+  | EthTldNameSpecifier
+
+type GetEthNameType<TString extends EthAnyName> = TString extends EthTldName
+  ? EthTldNameSpecifier
+  : TString extends EthSubname
+  ? EthSubnameSpecifier
+  : Eth2ldNameSpecifier
+type GetOtherNameType<TString extends TldName> = TString extends OtherSubname
+  ? OtherSubnameSpecifier
+  : TString extends Other2ldName
+  ? Other2ldNameSpecifier
+  : TldNameSpecifier
+
+export type GetNameType<TString extends string> = TString extends RootName
+  ? RootNameSpecifier
+  : TString extends EthAnyName
+  ? GetEthNameType<TString>
+  : GetOtherNameType<TString>

package/src/utils/consts.ts

@@ -0,0 +1,5 @@
+export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'
+export const MAX_INT_64 = BigInt('18446744073709551615')
+export const MAX_DATE_INT = 8640000000000000
+export const MINIMUM_DOT_ETH_CHARS = 3
+export const GRACE_PERIOD_SECONDS = 7776000 // 90 days

package/src/utils/contentHash.ts

@@ -1,151 +1,102 @@
-import contentHash from '@ensdomains/content-hash'
-import { utils } from 'ethers'
+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'
+  | 'ipns'
+  | 'bzz'
+  | 'onion'
+  | 'onion3'
+  | 'sia'
+  | 'ar'
+  | null
 
 export type DecodedContentHash = {
-  protocolType?: any
-  decoded?: any
-  error?: any
+  protocolType: ProtocolType
+  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):\/\/(.*)/) ||
+    text.match(/^(ipfs|sia|ipns|bzz|onion|onion3|arweave|ar):\/\/(.*)/) ||
     text.match(/\/(ipfs)\/(.*)/) ||
     text.match(/\/(ipns)\/(.*)/)
   )
 }
 
-export function decodeContenthash(encoded: any) {
-  let decoded, protocolType, error
-  if (!encoded || encoded === '0x') {
-    return {}
-  }
-  if (encoded.error) {
-    return { protocolType: null, decoded: encoded.error }
-  } else if (encoded === false) {
-    return { protocolType: null, decoded: 'invalid value' }
+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
   }
-  if (encoded) {
-    try {
-      decoded = contentHash.decode(encoded)
-      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 = 'arweave'
-      } else {
-        decoded = encoded
-      }
-    } catch (e: any) {
-      error = e.message
-    }
-  }
-  return { protocolType, decoded, error }
 }
 
-export function validateContent(encoded: any) {
-  return (
-    contentHash.isHashOfType(encoded, contentHash.Types.ipfs) ||
-    contentHash.isHashOfType(encoded, contentHash.Types.swarm)
-  )
+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 isValidContenthash(encoded: any) {
-  try {
-    const codec = contentHash.getCodec(encoded)
-    return utils.isHexString(encoded) && supportedCodecs.includes(codec)
-  } catch (e) {
-    console.log(e)
+export function decodeContentHash(encoded: Hex): DecodedContentHash | null {
+  if (!encoded || encoded === '0x') {
+    return null
   }
+  const decoded = decode(encoded)
+  const protocolType = getDisplayCodec(encoded)
+  return { protocolType, decoded }
 }
 
-export function getProtocolType(encoded: any) {
-  let protocolType, decoded
-  try {
-    let matched = matchProtocol(encoded)
-    if (matched) {
-      protocolType = matched[1]
-      decoded = matched[2]
-    }
-    return {
-      protocolType,
-      decoded,
-    }
-  } catch (e) {
-    console.log(e)
-  }
+export function isValidContentHash(encoded: unknown) {
+  if (typeof encoded !== 'string') return false
+  const codec = getCodec(encoded)
+  return Boolean(codec && isHex(encoded))
 }
 
-export function encodeContenthash(text: string) {
-  let content = text
-  let contentType
-  let encoded: string | boolean = false
-  let error
-  if (!!text) {
-    let matched = matchProtocol(text)
-    if (matched) {
-      contentType = matched[1]
-      content = matched[2]
-    }
-    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') {
-        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 }
+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 encodeContentHash(text: string): Hex {
+  const typeData = getProtocolType(text)
+  if (!typeData) throw new InvalidContentHashError()
+
+  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

@@ -0,0 +1,100 @@
+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
+
+const abiEncodeMap = {
+  json: 1,
+  zlib: 2,
+  cbor: 4,
+  uri: 8,
+} as const
+type AbiEncodeMap = typeof abiEncodeMap
+
+type GetAbiContentType<TEncodeAs extends AbiEncodeAs> = AbiEncodeMap[TEncodeAs]
+
+export type EncodeAbiParameters<TEncodeAs extends AbiEncodeAs = AbiEncodeAs> =
+  TEncodeAs extends 'uri'
+    ? {
+        encodeAs: TEncodeAs
+        data: string
+      }
+    : {
+        encodeAs: TEncodeAs
+        data: Record<any, any>
+      }
+
+export type EncodedAbi<TContentType extends AbiContentType = AbiContentType> = {
+  contentType: TContentType
+  encodedData: Hex
+}
+
+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>,
+>({
+  encodeAs,
+  data,
+}: EncodeAbiParameters<TEncodeAs>): Promise<
+  Prettify<EncodeAbiReturnType<TContentType>>
+> => {
+  let contentType: AbiContentType
+  let encodedData: Hex
+  switch (encodeAs) {
+    case 'json':
+      contentType = 1
+      encodedData = stringToHex(JSON.stringify(data))
+      break
+    case 'zlib': {
+      contentType = 2
+      const { deflate } = await import('pako/dist/pako_deflate.min.js')
+      encodedData = bytesToHex(deflate(JSON.stringify(data)))
+      break
+    }
+    case 'cbor': {
+      contentType = 4
+      const { cborEncode } = await import('@ensdomains/address-encoder/utils')
+      encodedData = bytesToHex(new Uint8Array(cborEncode(data)))
+      break
+    }
+    default: {
+      contentType = 8
+      encodedData = stringToHex(data as string)
+      break
+    }
+  }
+  return { contentType: contentType as TContentType, encodedData }
+}

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/encodeSetAbi.ts

@@ -0,0 +1,21 @@
+import { encodeFunctionData, type Hex } from 'viem'
+import { publicResolverSetAbiSnippet } from '../../contracts/publicResolver.js'
+import type { EncodedAbi } from './encodeAbi.js'
+
+export type EncodeSetAbiParameters = {
+  namehash: Hex
+} & (EncodedAbi | { contentType: 0; encodedData: null })
+
+export type EncodeSetAbiReturnType = Hex
+
+export const encodeSetAbi = ({
+  namehash,
+  contentType,
+  encodedData,
+}: EncodeSetAbiParameters): EncodeSetAbiReturnType => {
+  return encodeFunctionData({
+    abi: publicResolverSetAbiSnippet,
+    functionName: 'setABI',
+    args: [namehash, BigInt(contentType), encodedData ?? '0x'],
+  })
+}

package/src/utils/encoders/encodeSetAddr.ts

@@ -0,0 +1,32 @@
+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
+  coin: string | number
+  value: Address | string | null
+}
+
+export type EncodeSetAddrReturnType = Hex
+
+export const encodeSetAddr = ({
+  namehash,
+  coin,
+  value,
+}: EncodeSetAddrParameters): EncodeSetAddrReturnType => {
+  const coder = getCoderFromCoin(coin)
+  const inputCoinType = coder.coinType
+  let encodedAddress: Hex | Uint8Array = value ? coder.decode(value) : '0x'
+  if (inputCoinType === 60 && encodedAddress === '0x')
+    encodedAddress = coder.decode('0x0000000000000000000000000000000000000000')
+  if (typeof encodedAddress !== 'string') {
+    encodedAddress = bytesToHex(encodedAddress)
+  }
+
+  return encodeFunctionData({
+    abi: publicResolverSetAddrSnippet,
+    functionName: 'setAddr',
+    args: [namehash, BigInt(inputCoinType), encodedAddress],
+  })
+}