@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.61

package/src/utils/recordHelpers.ts

@@ -1,4 +1,7 @@
 import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
+import { isBytesLike } from '@ethersproject/bytes'
+import { toUtf8Bytes } from '@ethersproject/strings'
+import type { BigNumberish } from 'ethers'
 import type { PublicResolver } from '../generated'
 import { encodeContenthash } from './contentHash'
 
@@ -7,10 +10,19 @@ type RecordItem = {
   value: string
 }
 
+type ABIEncodeAs = 'json' | 'zlib' | 'cbor' | 'uri'
+
+type ABIItem = {
+  contentType?: BigNumberish
+  data: object | string
+}
+
 export type RecordOptions = {
+  clearRecords?: boolean
   contentHash?: string
   texts?: RecordItem[]
   coinTypes?: RecordItem[]
+  abi?: ABIItem
 }
 
 export const generateSetAddr = (
@@ -20,19 +32,117 @@ export const generateSetAddr = (
   resolver: PublicResolver,
 ) => {
   let coinTypeInstance
-  if (!isNaN(parseInt(coinType))) {
+  if (!Number.isNaN(parseInt(coinType))) {
     coinTypeInstance = formatsByCoinType[parseInt(coinType)]
   } else {
     coinTypeInstance = formatsByName[coinType.toUpperCase()]
   }
   const inputCoinType = coinTypeInstance.coinType
-  const encodedAddress = coinTypeInstance.decoder(address)
+  let encodedAddress = address !== '' ? coinTypeInstance.decoder(address) : '0x'
+  if (inputCoinType === 60 && encodedAddress === '0x')
+    encodedAddress = coinTypeInstance.decoder(
+      '0x0000000000000000000000000000000000000000',
+    )
+
   return resolver?.interface.encodeFunctionData(
     'setAddr(bytes32,uint256,bytes)',
     [namehash, inputCoinType, encodedAddress],
   )
 }
 
+export const generateABIInput = async (
+  encodeAs: ABIEncodeAs,
+  data: object | string,
+) => {
+  let contentType: number
+  let encodedData: string | Buffer | Uint8Array
+  switch (encodeAs) {
+    case 'json':
+      contentType = 1
+      encodedData = JSON.stringify(data)
+      break
+    case 'zlib': {
+      contentType = 2
+      const { deflate } = await import('pako/dist/pako_deflate.min.js')
+      encodedData = deflate(JSON.stringify(data))
+      break
+    }
+    case 'cbor': {
+      contentType = 4
+      const { encode } = await import('cbor')
+      encodedData = encode(data)
+      break
+    }
+    default: {
+      contentType = 8
+      encodedData = data as string
+      break
+    }
+  }
+  return { contentType, data: encodedData }
+}
+
+export type RecordTypes = 'contentHash' | 'text' | 'addr' | 'abi'
+
+export type RecordInput<T extends RecordTypes> = T extends 'contentHash'
+  ? string
+  : T extends 'abi'
+  ? ABIItem
+  : RecordItem
+
+export function generateSingleRecordCall<T extends RecordTypes>(
+  namehash: string,
+  resolver: PublicResolver,
+  type: T,
+): (record: RecordInput<T>) => string {
+  if (type === 'contentHash') {
+    return (_r: RecordInput<T>) => {
+      const record = _r as string
+      let _contentHash = ''
+      if (record !== _contentHash) {
+        const encoded = encodeContenthash(record)
+        if (encoded.error) throw new Error(encoded.error)
+        _contentHash = encoded.encoded as string
+      } else {
+        _contentHash = '0x'
+      }
+      return resolver.interface.encodeFunctionData('setContenthash', [
+        namehash,
+        _contentHash,
+      ])
+    }
+  }
+  if (type === 'abi') {
+    return (_r: RecordInput<T>) => {
+      const record = _r as ABIItem
+      const { contentType = 1, data } = record
+      let encodedData = data as string | Uint8Array | Buffer
+      if (!isBytesLike(encodedData)) {
+        if (typeof encodedData === 'object') {
+          encodedData = JSON.stringify(encodedData)
+        }
+        encodedData = toUtf8Bytes(encodedData)
+      }
+      return resolver.interface.encodeFunctionData('setABI', [
+        namehash,
+        contentType,
+        encodedData,
+      ])
+    }
+  }
+  return (_r: RecordInput<T>) => {
+    const record = _r as RecordItem
+    if (type === 'text') {
+      return resolver.interface.encodeFunctionData('setText', [
+        namehash,
+        record.key,
+        record.value,
+      ])
+    }
+    return generateSetAddr(namehash, record.key, record.value, resolver)
+  }
+}
+
 export const generateRecordCallArray = (
   namehash: string,
   records: RecordOptions,
@@ -40,32 +150,40 @@ export const generateRecordCallArray = (
 ) => {
   const calls: string[] = []
 
-  if (records.contentHash) {
-    const contentHash =
-      records.contentHash === '' ? '' : encodeContenthash(records.contentHash)
-    const data = (resolver?.interface.encodeFunctionData as any)(
-      'setContenthash',
-      [namehash, contentHash],
+  if (records.clearRecords) {
+    calls.push(
+      resolver.interface.encodeFunctionData('clearRecords', [namehash]),
     )
-    data && calls.push(data)
+  }
+
+  if (typeof records.contentHash === 'string') {
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      'contentHash',
+    )(records.contentHash)
+    if (data) calls.push(data)
+  }
+
+  if (records.abi) {
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      'abi',
+    )(records.abi)
+    if (data) calls.push(data)
   }
 
   if (records.texts && records.texts.length > 0) {
-    records.texts.forEach(({ key, value }: RecordItem) => {
-      const data = resolver?.interface.encodeFunctionData('setText', [
-        namehash,
-        key,
-        value,
-      ])
-      data && calls.push(data)
-    })
+    records.texts
+      .map(generateSingleRecordCall(namehash, resolver, 'text'))
+      .forEach((call) => calls.push(call))
   }
 
   if (records.coinTypes && records.coinTypes.length > 0) {
-    records.coinTypes.forEach(({ key, value }: RecordItem) => {
-      const data = generateSetAddr(namehash, key, value, resolver!)
-      data && calls.push(data)
-    })
+    records.coinTypes
+      .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+      .forEach((call) => calls.push(call))
   }
 
   return calls

package/src/utils/registerHelpers.ts

@@ -1,17 +1,50 @@
-import { utils } from 'ethers'
-import type { FuseOptions } from '../@types/FuseOptions'
+import { defaultAbiCoder } from '@ethersproject/abi'
+import { keccak256 } from '@ethersproject/keccak256'
 import type { PublicResolver } from '../generated'
-import generateFuseInput from './generateFuseInput'
+import { CombinedFuseInput, encodeFuses, hasFuses } from './fuses'
 import { labelhash } from './labels'
 import { namehash } from './normalise'
 import { generateRecordCallArray, RecordOptions } from './recordHelpers'
 
+export type BaseRegistrationParams = {
+  owner: string
+  duration: number
+  secret: string
+  resolverAddress?: string
+  records?: RecordOptions
+  reverseRecord?: boolean
+  fuses?: CombinedFuseInput['child']
+}
+
+export type RegistrationParams = Omit<
+  BaseRegistrationParams,
+  'resolverAddress'
+> & {
+  name: string
+  resolver: PublicResolver
+}
+
+export type CommitmentParams = Omit<RegistrationParams, 'secret'> & {
+  secret?: string
+}
+
+export type RegistrationTuple = [
+  name: string,
+  owner: string,
+  duration: number,
+  secret: string,
+  resolver: string,
+  data: string[],
+  reverseRecord: boolean,
+  ownerControlledFuses: number,
+]
+
 export const randomSecret = () => {
   const bytes = Buffer.allocUnsafe(32)
-  return '0x' + crypto.getRandomValues(bytes).toString('hex')
+  return `0x${crypto.getRandomValues(bytes).toString('hex')}`
 }
 
-export const makeCommitment = ({
+export const makeCommitmentData = ({
   name,
   owner,
   duration,
@@ -19,69 +52,78 @@ export const makeCommitment = ({
   records,
   reverseRecord,
   fuses,
-}: {
-  name: string
-  owner: string
-  duration: number
-  resolver: PublicResolver
-  records?: RecordOptions
-  reverseRecord?: boolean
-  fuses?: FuseOptions
-}) => {
-  const label = labelhash(name.split('.')[0])
+  secret,
+}: CommitmentParams & {
+  secret: string
+}): RegistrationTuple => {
+  const labelHash = labelhash(name.split('.')[0])
   const hash = namehash(name)
   const resolverAddress = resolver.address
+  const fuseData = hasFuses(fuses) ? encodeFuses(fuses!, 'child') : 0
+
+  if (reverseRecord) {
+    if (!records) {
+      records = { coinTypes: [{ key: 'ETH', value: owner }] }
+    } else if (!records.coinTypes?.find((c) => c.key === 'ETH')) {
+      if (!records.coinTypes) records.coinTypes = []
+      records.coinTypes.push({ key: 'ETH', value: owner })
+    }
+  }
+
   const data = records ? generateRecordCallArray(hash, records, resolver) : []
-  const secret = randomSecret()
-  const fuseData = fuses ? generateFuseInput(fuses) : '0'
 
-  const commitment = _makeCommitment({
-    labelhash: label,
+  return [
+    labelHash,
     owner,
     duration,
     secret,
-    resolver: resolverAddress,
+    resolverAddress,
     data,
-    reverseRecord: !!reverseRecord,
-    fuses: fuseData,
+    !!reverseRecord,
+    fuseData,
+  ]
+}
+
+export const makeRegistrationData = (
+  params: RegistrationParams,
+): RegistrationTuple => {
+  const commitmentData = makeCommitmentData(params)
+  const label = params.name.split('.')[0]
+  commitmentData[0] = label
+  return commitmentData
+}
+
+export const _makeCommitment = (params: RegistrationTuple) => {
+  return keccak256(
+    defaultAbiCoder.encode(
+      [
+        'bytes32',
+        'address',
+        'uint256',
+        'bytes32',
+        'address',
+        'bytes[]',
+        'bool',
+        'uint16',
+      ],
+      params,
+    ),
+  )
+}
+
+export const makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}: CommitmentParams) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret,
   })
 
+  const commitment = _makeCommitment(generatedParams)
+
   return {
     secret,
     commitment,
   }
 }
-
-export const _makeCommitment = ({
-  labelhash,
-  owner,
-  duration,
-  secret,
-  resolver,
-  data,
-  reverseRecord,
-  fuses,
-}: {
-  labelhash: string
-  owner: string
-  duration: number
-  secret: string
-  resolver: string
-  data: string[]
-  reverseRecord: boolean
-  fuses: string
-}) => {
-  return utils.solidityKeccak256(
-    [
-      'bytes32',
-      'address',
-      'uint256',
-      'bytes32',
-      'address',
-      'bytes[]',
-      'bool',
-      'uint96',
-    ],
-    [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses],
-  )
-}

package/src/utils/registry.ts

@@ -0,0 +1,14 @@
+import { ENSArgs } from '../index'
+import { namehash } from './normalise'
+
+export const makeResolver = async (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  resolver?: string,
+) => {
+  if (resolver) return resolver
+  const registry = await contracts!.getRegistry()
+  const node = namehash(name)
+  const _resolver = await registry.resolver(node)
+  return _resolver
+}

package/src/utils/singleCall.ts

@@ -1,16 +1,21 @@
-import { ethers } from 'ethers'
+import type { Provider } from '@ethersproject/providers'
 
 export default async (
-  provider: ethers.providers.Provider,
+  provider: Provider,
   ensData: any,
   func: {
-    raw: (...args: any[]) => Promise<{ to: string; data: string }>
+    raw: (
+      ...args: any[]
+    ) => Promise<{ to: string; data: string; passthrough?: any }>
     decode: (...args: any[]) => Promise<any>
   },
   ...data: any[]
-) =>
-  func
-    .raw(ensData, ...data)
-    .then((rawData) => provider.call(rawData))
+) => {
+  const { passthrough, ...rawData } = await func.raw(ensData, ...data)
+  const result = await provider
+    .call({ ...rawData, ccipReadEnabled: true })
     .catch(() => null)
-    .then((ret) => func.decode(ensData, ret, ...data))
+  if (!result) return
+  if (passthrough) return func.decode(ensData, result, passthrough, ...data)
+  return func.decode(ensData, result, ...data)
+}