@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.2

package/src/functions/getSpecificRecord.ts

@@ -0,0 +1,365 @@
+import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { decodeContenthash } from '../utils/contentHash'
+import { namehash } from '../utils/normalise'
+
+export const _getContentHash = {
+  raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+    const publicResolver = await contracts?.getPublicResolver()!
+    return {
+      to: '0x0000000000000000000000000000000000000000',
+      data: publicResolver.interface.encodeFunctionData('contenthash', [
+        namehash(name),
+      ]),
+    }
+  },
+  decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+    const publicResolver = await contracts?.getPublicResolver()!
+    const [response] = publicResolver.interface.decodeFunctionResult(
+      'contenthash',
+      data,
+    )
+    if (!response) {
+      return
+    }
+
+    const decodedContent = decodeContenthash(response)
+
+    if (
+      !decodedContent ||
+      (ethers.utils.isBytesLike(decodedContent.decoded) &&
+        ethers.utils.hexStripZeros(decodedContent.decoded) === '0x') ||
+      Object.keys(decodedContent).length === 0
+    ) {
+      return
+    }
+
+    return decodedContent
+  },
+}
+
+export const getContentHash = {
+  raw: async (
+    { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
+    name: string,
+  ) => {
+    const prData = await _getContentHash.raw({ contracts }, name)
+    return await universalWrapper.raw(name, prData.data)
+  },
+  decode: async (
+    { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
+    data: string,
+  ) => {
+    const urData = await universalWrapper.decode(data)
+    if (!urData) return
+    return await _getContentHash.decode({ contracts }, urData.data)
+  },
+}
+
+export const _getText = {
+  raw: async (
+    { contracts }: ENSArgs<'contracts'>,
+    name: string,
+    key: string,
+  ) => {
+    const publicResolver = await contracts?.getPublicResolver()!
+    return {
+      to: '0x0000000000000000000000000000000000000000',
+      data: publicResolver.interface.encodeFunctionData('text', [
+        namehash(name),
+        key,
+      ]),
+    }
+  },
+  decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+    const publicResolver = await contracts?.getPublicResolver()!
+    const [response] = publicResolver.interface.decodeFunctionResult(
+      'text',
+      data,
+    )
+    if (!response) {
+      return
+    }
+    return response
+  },
+}
+
+export const getText = {
+  raw: async (
+    { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
+    name: string,
+    key: string,
+  ) => {
+    const prData = await _getText.raw({ contracts }, name, key)
+    return await universalWrapper.raw(name, prData.data)
+  },
+  decode: async (
+    { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
+    data: string,
+  ) => {
+    const urData = await universalWrapper.decode(data)
+    if (!urData) return
+    return await _getText.decode({ contracts }, urData.data)
+  },
+}
+
+export const _getAddr = {
+  raw: async (
+    { contracts }: ENSArgs<'contracts'>,
+    name: string,
+    coinType?: string | number,
+    bypassFormat?: boolean,
+  ) => {
+    if (!coinType) {
+      coinType = 60
+    }
+
+    const publicResolver = await contracts?.getPublicResolver()!
+
+    if (coinType === 60 || coinType === '60') {
+      return {
+        to: '0x0000000000000000000000000000000000000000',
+        data: publicResolver.interface.encodeFunctionData('addr(bytes32)', [
+          namehash(name),
+        ]),
+      }
+    }
+
+    if (bypassFormat) {
+      return {
+        to: '0x0000000000000000000000000000000000000000',
+        data: publicResolver.interface.encodeFunctionData(
+          'addr(bytes32,uint256)',
+          [namehash(name), coinType],
+        ),
+      }
+    }
+    const formatter =
+      typeof coinType === 'string' && isNaN(parseInt(coinType))
+        ? formatsByName[coinType]
+        : formatsByCoinType[
+            typeof coinType === 'number' ? coinType : parseInt(coinType)
+          ]
+
+    if (!formatter) {
+      throw new Error(`No formatter found for coin: ${coinType}`)
+    }
+
+    return {
+      to: '0x0000000000000000000000000000000000000000',
+      data: publicResolver.interface.encodeFunctionData(
+        'addr(bytes32,uint256)',
+        [namehash(name), formatter.coinType],
+      ),
+    }
+  },
+  decode: async (
+    { contracts }: ENSArgs<'contracts'>,
+    data: string,
+    _name: string,
+    coinType?: string | number,
+  ) => {
+    let returnCoinType = true
+    if (!coinType) {
+      coinType = 60
+      returnCoinType = false
+    }
+
+    const publicResolver = await contracts?.getPublicResolver()!
+    const formatter =
+      typeof coinType === 'string' && isNaN(parseInt(coinType))
+        ? formatsByName[coinType]
+        : formatsByCoinType[
+            typeof coinType === 'number' ? coinType : parseInt(coinType)
+          ]
+
+    let response: string
+
+    if (coinType === 60 || coinType === '60') {
+      ;[response] = publicResolver.interface.decodeFunctionResult(
+        'addr(bytes32)',
+        data,
+      )
+    } else {
+      ;[response] = publicResolver.interface.decodeFunctionResult(
+        'addr(bytes32,uint256)',
+        data,
+      )
+    }
+
+    if (!response) return
+
+    if (ethers.utils.hexStripZeros(response) === '0x') {
+      return
+    }
+
+    const decodedAddr = formatter.encoder(Buffer.from(response.slice(2), 'hex'))
+
+    if (!decodedAddr) {
+      return
+    }
+
+    if (!returnCoinType) {
+      return decodedAddr
+    }
+
+    return { coin: formatter.name, addr: decodedAddr }
+  },
+}
+
+export const getAddr = {
+  raw: async (
+    { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
+    name: string,
+    coinType?: string | number,
+  ) => {
+    const prData = await _getAddr.raw({ contracts }, name, coinType)
+    return await universalWrapper.raw(name, prData.data)
+  },
+  decode: async (
+    { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
+    data: string,
+    _name: string,
+    coinType?: string | number,
+  ) => {
+    const urData = await universalWrapper.decode(data)
+    if (!urData) return
+    return await _getAddr.decode({ contracts }, urData.data, _name, coinType)
+  },
+}
+
+// export async function getAddr(
+//   { contracts }: ENSArgs<'contracts'>,
+//   name: string,
+//   coinType?: string | number,
+// ) {
+//   if (!coinType) {
+//     coinType = 60
+//   }
+
+//   const universalResolver = await contracts?.getUniversalResolver()
+//   const publicResolver = await contracts?.getPublicResolver()
+//   const formatter =
+//     typeof coinType === 'string'
+//       ? formatsByName[coinType]
+//       : formatsByCoinType[coinType]
+
+//   if (!formatter) {
+//     throw new Error(`Coin type ${coinType} is not supported`)
+//   }
+
+//   const data = publicResolver?.interface.encodeFunctionData(
+//     'addr(bytes32,uint256)',
+//     [ethers.utils.namehash(name), formatter.coinType],
+//   )
+//   const result = await universalResolver?.resolve(hexEncodeName(name), data)
+
+//   const [encodedAddr] = ethers.utils.defaultAbiCoder.decode(
+//     ['bytes'],
+//     result['0'],
+//   )
+
+//   if (ethers.utils.hexStripZeros(encodedAddr) === '0x') {
+//     return
+//   }
+
+//   const decodedAddr = formatter.encoder(
+//     Buffer.from(encodedAddr.slice(2), 'hex'),
+//   )
+
+//   if (!decodedAddr) {
+//     return
+//   }
+
+//   return decodedAddr
+// }
+
+// export const getContentHash = {
+//   raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const prData = publicResolver.interface.encodeFunctionData(
+//       'contenthash(bytes32)',
+//       [ethers.utils.namehash(name)],
+//     )
+//     const urData = universalResolver.interface.encodeFunctionData(
+//       'resolve(bytes,bytes)',
+//       [hexEncodeName(name), prData],
+//     )
+
+//     return {
+//       to: universalResolver.address,
+//       data: urData,
+//     }
+//   },
+//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const response = universalResolver.interface.decodeFunctionResult(
+//       'resolve(bytes,bytes)',
+//       data,
+//     )
+
+//     if (!response || !response[1]) {
+//       return
+//     }
+
+//     const [encodedContentHash] = publicResolver.interface.decodeFunctionResult(
+//       'contenthash(bytes32)',
+//       response[0],
+//     )
+
+//     if (ethers.utils.hexStripZeros(encodedContentHash) === '0x') {
+//       return
+//     }
+
+//     return decodeContenthash(encodedContentHash)
+//   },
+// }
+
+// const getText = {
+//   raw: async (
+//     { contracts }: ENSArgs<'contracts'>,
+//     name: string,
+//     key: string,
+//   ) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const data = publicResolver.interface.encodeFunctionData(
+//       'text(bytes32,string)',
+//       [ethers.utils.namehash(name), key],
+//     )
+
+//     return {
+//       to: universalResolver.address,
+//       data: universalResolver.interface.encodeFunctionData(
+//         'resolve(bytes,bytes)',
+//         [hexEncodeName(name), data],
+//       ),
+//     }
+//   },
+//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const response = universalResolver.interface.decodeFunctionResult(
+//       'resolve(bytes,bytes)',
+//       data,
+//     )
+
+//     if (!response || !response[1]) {
+//       return
+//     }
+
+//     const [decodedText] = publicResolver.interface.decodeFunctionResult(
+//       'text(bytes32,string)',
+//       response[0],
+//     )
+
+//     if (decodedText === '') {
+//       return
+//     }
+
+//     return decodedText
+//   },
+// }

package/src/functions/getSubnames.ts

@@ -0,0 +1,190 @@
+import { ENSArgs } from '..'
+import { truncateFormat } from '../utils/format'
+import { decryptName } from '../utils/labels'
+import { namehash } from '../utils/normalise'
+
+type Subname = {
+  id: string
+  labelName: string | null
+  truncatedName?: string
+  labelhash: string
+  isMigrated: boolean
+  name: string
+  owner: {
+    id: string
+  }
+}
+
+type Params = {
+  name: string
+  page?: number
+  pageSize?: number
+  orderDirection?: 'asc' | 'desc'
+  orderBy?: 'createdAt' | 'labelName'
+  lastSubnames: Array<any>
+  isLargeQuery?: boolean
+}
+
+const largeQuery = async (
+  { gqlInstance }: ENSArgs<'gqlInstance'>,
+  { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }: Params,
+) => {
+  const client = gqlInstance.client
+
+  let finalQuery = gqlInstance.gql`
+    query getSubnames(
+      $id: ID! 
+      $first: Int
+      $lastCreatedAt: BigInt
+      $orderBy: Domain_orderBy 
+      $orderDirection: OrderDirection
+    ) {
+      domain(
+        id: $id
+      ) {
+        subdomainCount
+        subdomains(
+          first: $first
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+          where: { createdAt_lt: $lastCreatedAt }
+        ) {
+          id
+          labelName
+          labelhash
+          isMigrated
+          name
+          subdomainCount
+          createdAt
+          owner {
+            id
+          }
+        }
+      }
+    }
+  `
+  let queryVars = {
+    id: namehash(name),
+    first: pageSize,
+    lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
+    orderBy,
+    orderDirection,
+  }
+  const { domain } = await client.request(finalQuery, queryVars)
+  const subdomains = domain.subdomains.map((subname: any) => {
+    const decrypted = decryptName(subname.name)
+    return {
+      ...subname,
+      name: decrypted,
+      truncatedName: truncateFormat(decrypted),
+    }
+  })
+
+  return {
+    subnames: subdomains,
+    subnameCount: domain.subdomainCount,
+  }
+}
+
+const smallQuery = async (
+  { gqlInstance }: ENSArgs<'gqlInstance'>,
+  { name, page, pageSize = 10, orderDirection, orderBy }: Params,
+) => {
+  const client = gqlInstance.client
+  const subdomainsGql = `
+  id
+  labelName
+  labelhash
+  isMigrated
+  name
+  subdomainCount
+  createdAt
+  owner {
+    id
+  }
+`
+  let queryVars = {}
+  let finalQuery = ''
+  if (typeof page !== 'number') {
+    finalQuery = gqlInstance.gql`
+    query getSubnames(
+      $id: ID! 
+      $orderBy: Domain_orderBy 
+      $orderDirection: OrderDirection
+    ) {
+      domain(
+        id: $id
+      ) {
+        subdomains(
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+        ) {
+          ${subdomainsGql}
+        }
+      }
+    }
+  `
+    queryVars = {
+      id: namehash(name),
+      orderBy,
+      orderDirection,
+    }
+  } else {
+    finalQuery = gqlInstance.gql`
+    query getSubnames(
+      $id: ID! 
+      $first: Int
+      $skip: Int
+      $orderBy: Domain_orderBy 
+      $orderDirection: OrderDirection
+    ) {
+      domain(
+        id: $id
+      ) {
+        subdomainCount
+        subdomains(
+          first: $first
+          skip: $skip
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+        ) {
+          ${subdomainsGql}
+        }
+      }
+    }
+  `
+    queryVars = {
+      id: namehash(name),
+      first: pageSize,
+      skip: (page || 0) * pageSize,
+      orderBy,
+      orderDirection,
+    }
+  }
+  const { domain } = await client.request(finalQuery, queryVars)
+  const subdomains = domain.subdomains.map((subname: any) => {
+    const decrypted = decryptName(subname.name)
+    return {
+      ...subname,
+      name: decrypted,
+      truncatedName: truncateFormat(decrypted),
+    }
+  })
+
+  return {
+    subnames: subdomains,
+    subnameCount: domain.subdomainCount,
+  }
+}
+
+const getSubnames = (
+  injected: ENSArgs<'gqlInstance'>,
+  functionArgs: Params,
+): Promise<{ subnames: Subname[]; subnameCount: number }> => {
+  if (functionArgs.isLargeQuery) {
+    return largeQuery(injected, functionArgs)
+  }
+  return smallQuery(injected, functionArgs)
+}
+
+export default getSubnames

package/src/functions/initialGetters.ts

@@ -0,0 +1,11 @@
+export { default as batch } from './batch'
+export * from './batchWrappers'
+export { default as getExpiry } from './getExpiry'
+export { default as getName } from './getName'
+export { default as getNames } from './getNames'
+export { default as getOwner } from './getOwner'
+export { default as getPrice } from './getPrice'
+export { default as getProfile } from './getProfile'
+export { default as getRecords } from './getRecords'
+export * from './getSpecificRecord'
+export { default as getSubnames } from './getSubnames'

package/src/functions/setName.ts

@@ -0,0 +1,34 @@
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  name: string,
+  address?: string,
+  resolver?: string,
+  options?: { addressOrIndex?: string | number },
+) {
+  const signerAddress = await provider
+    ?.getSigner(options?.addressOrIndex)
+    .getAddress()
+
+  if (!signerAddress) {
+    throw new Error('No signer found')
+  }
+
+  const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(
+    provider?.getSigner()!,
+  )
+
+  if (address) {
+    const publicResolver = await contracts?.getPublicResolver()
+
+    return reverseRegistrar?.setNameForAddr(
+      address,
+      signerAddress,
+      resolver || publicResolver!.address,
+      name,
+    )
+  }
+
+  return reverseRegistrar?.setName(name)
+}

package/src/functions/setRecords.ts

@@ -0,0 +1,38 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import { generateRecordCallArray, RecordOptions } from '../utils/recordHelpers'
+
+export default async function (
+  {
+    contracts,
+    provider,
+    getResolver,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver'>,
+  name: string,
+  records: RecordOptions,
+) {
+  if (!name.includes('.')) {
+    throw new Error('Input is not an ENS name')
+  }
+
+  const resolverAddress = await getResolver(name)
+
+  if (!resolverAddress) {
+    throw new Error('No resolver found for input address')
+  }
+
+  const address = await provider?.getSigner().getAddress()
+
+  if (!address) {
+    throw new Error('No signer found')
+  }
+
+  const resolver = (
+    await contracts?.getPublicResolver(provider, resolverAddress)
+  )?.connect(provider?.getSigner()!)
+  const hash = namehash(name)
+
+  const calls: string[] = generateRecordCallArray(hash, records, resolver!)
+
+  return resolver?.multicall(calls)
+}

package/src/functions/setResolver.ts

@@ -0,0 +1,40 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  name: string,
+  contract: 'registry' | 'nameWrapper',
+  resolver?: string,
+  options?: { addressOrIndex?: string | number },
+) {
+  const address = await provider
+    ?.getSigner(options?.addressOrIndex)
+    .getAddress()
+
+  if (!address) {
+    throw new Error('No signer found')
+  }
+
+  if (!resolver) {
+    resolver = (await contracts?.getPublicResolver()!).address
+  }
+
+  switch (contract) {
+    case 'registry': {
+      const registry = (await contracts?.getRegistry())!.connect(
+        provider?.getSigner(options?.addressOrIndex)!,
+      )
+      return registry.setResolver(namehash(name), resolver)
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts?.getNameWrapper())!.connect(
+        provider?.getSigner(options?.addressOrIndex)!,
+      )
+      return nameWrapper.setResolver(namehash(name), resolver)
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
+}