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

package/src/functions/getSpecificRecord.test.ts

@@ -1,76 +0,0 @@
-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

@@ -1,365 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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/makeCommitment.test.ts

@@ -1,23 +0,0 @@
-import { ENS } from '..'
-import { makeCommitment } from '../utils/registerHelpers'
-import setup from '../tests/setup'
-
-let ENSInstance: ENS
-
-beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
-})
-
-describe('makeCommitment', () => {
-  it('should create a valid commitment', async () => {
-    const resolver = await ENSInstance.contracts!.getPublicResolver()!
-    const commitment = makeCommitment({
-      name: 'test.eth',
-      owner: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      duration: 1 * 365 * 24 * 60 * 60,
-      resolver: resolver,
-    })
-    expect(commitment).toHaveProperty('secret')
-    expect(commitment).toHaveProperty('commitment')
-  })
-})