@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.3

package/src/functions/getResolver.ts

@@ -0,0 +1,32 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { hexEncodeName } from '../utils/hexEncodedName'
+
+const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+  const universalResolver = await contracts?.getUniversalResolver()!
+  return {
+    to: universalResolver.address,
+    data: universalResolver.interface.encodeFunctionData('findResolver', [
+      hexEncodeName(name),
+    ]),
+  }
+}
+
+const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+  const universalResolver = await contracts?.getUniversalResolver()!
+  const response = universalResolver.interface.decodeFunctionResult(
+    'findResolver',
+    data,
+  )
+
+  if (
+    !response ||
+    !response[0] ||
+    ethers.utils.hexStripZeros(response[0]) === '0x'
+  ) {
+    return
+  }
+  return response[0]
+}
+
+export default { raw, decode }

package/src/functions/getSpecificRecord.test.ts

@@ -0,0 +1,76 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+})
+
+describe('getSpecificRecord', () => {
+  describe('getContentHash', () => {
+    it('should return null for a non-existent name', async () => {
+      const result = await ENSInstance.getContentHash('test123123cool.eth')
+      expect(result).toBeUndefined()
+    })
+    it('should return null for a name with no contenthash record', async () => {
+      const result = await ENSInstance.getContentHash('jefflau.eth')
+      expect(result).toBeUndefined()
+    })
+    it('should return the contenthash for a name with the record set', async () => {
+      const result = await ENSInstance.getContentHash('matoken.eth')
+      expect(result).toMatchObject({
+        protocolType: 'ipfs',
+        decoded: 'bafybeico3uuyj3vphxpvbowchdwjlrlrh62awxscrnii7w7flu5z6fk77y',
+        error: undefined,
+      })
+    })
+  })
+
+  describe('getText', () => {
+    it('should return a record from a key', async () => {
+      const result = await ENSInstance.getText('jefflau.eth', 'description')
+      expect(result).toBe('Hello2')
+    })
+
+    it('should return null for a non-existent key', async () => {
+      const result = await ENSInstance.getText(
+        'jefflau.eth',
+        'thiskeydoesntexist',
+      )
+      expect(result).toBeUndefined()
+    })
+  })
+
+  describe('getAddr', () => {
+    it('should return the ETH addr record if no coinType is provided', async () => {
+      const result = await ENSInstance.getAddr('jefflau.eth')
+      expect(result).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+    })
+    it('should return the correct address based on a coin ID input as a number', async () => {
+      const result = await ENSInstance.getAddr('jefflau.eth', 61)
+      expect((result as any).addr).toBe(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      expect((result as any).coin).toBe('ETC')
+    })
+    it('should return the correct address based on a coin ID input as a string', async () => {
+      const result = await ENSInstance.getAddr('jefflau.eth', '61')
+      expect((result as any).addr).toBe(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      expect((result as any).coin).toBe('ETC')
+    })
+    it('should return the correct address based on a coin name', async () => {
+      const result = await ENSInstance.getAddr('jefflau.eth', 'ETC')
+      expect((result as any).addr).toBe(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      expect((result as any).coin).toBe('ETC')
+    })
+    it('should return null for a non-existent coin', async () => {
+      const result = await ENSInstance.getAddr('jefflau.eth', 'BNB')
+      expect(result).toBeUndefined()
+    })
+  })
+})

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.test.ts

@@ -0,0 +1,31 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+})
+
+const testProperties = (obj: object, ...properties: string[]) =>
+  properties.map((property) => expect(obj).toHaveProperty(property))
+
+describe('getSubnames', () => {
+  it('should get the subnames for a name', async () => {
+    const result = await ENSInstance.getSubnames({
+      name: 'jefflau.eth',
+    })
+    expect(result).toBeTruthy()
+    expect(result.length).toBeGreaterThan(0)
+    testProperties(
+      result[0],
+      'id',
+      'labelName',
+      'labelhash',
+      'name',
+      'isMigrated',
+      'owner',
+      'truncatedName',
+    )
+  })
+})

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'