@ensdomains/ensjs 3.0.0-alpha.8 → 3.0.0-beta.1

package/src/functions/getHistory.ts

@@ -1,347 +0,0 @@
-import { formatsByCoinType } from '@ensdomains/address-encoder'
-import { ethers } from 'ethers'
-import { ENSArgs } from '..'
-import { decodeContenthash } from '../utils/contentHash'
-import { makeOtherIndexes } from '../utils/makeHashIndexes'
-
-type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL'
-type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred'
-type ResolverEvent =
-  | 'AddrChanged'
-  | 'MulticoinAddrChanged'
-  | 'NameChanged'
-  | 'AbiChanged'
-  | 'PubkeyChanged'
-  | 'TextChanged'
-  | 'ContenthashChanged'
-  | 'InterfaceChanged'
-  | 'AuthorisationChanged'
-
-type EventTypes = 'Domain' | 'Registration' | 'Resolver'
-
-const eventFormat: Record<
-  EventTypes,
-  Record<string, (args: any) => Record<string, any>>
-> = {
-  Domain: {
-    NewOwner: (args: any) => ({ owner: args.owner.id }),
-    NewResolver: (args: any) => ({ resolver: args.resolver.id.split('-')[0] }),
-    Transfer: (args: any) => ({ owner: args.owner.id }),
-    NewTTL: (args: any) => ({ ttl: args.ttl }),
-  },
-  Registration: {
-    NameRegistered: (args: any) => ({
-      registrant: args.registrant.id,
-      expiryDate: args.expiryDate,
-    }),
-    NameRenewed: (args: any) => ({ expiryDate: args.expiryDate }),
-    NameTransferred: (args: any) => ({ owner: args.newOwner.id }),
-  },
-  Resolver: {
-    AddrChanged: (args: any) => ({ addr: args.addr.id }),
-    MulticoinAddrChanged: (args: any) => {
-      const format = formatsByCoinType[parseInt(args.coinType)]
-      if (!format) {
-        return {
-          coinType: args.coinType,
-          rawAddr: args.multiaddr,
-        }
-      }
-      if (ethers.utils.hexStripZeros(args.multiaddr) === '0x') {
-        return {
-          coinType: args.coinType,
-          coinName: format.name,
-          rawAddr: '0x',
-        }
-      }
-      return {
-        coinType: args.coinType,
-        coinName: format.name,
-        addr: format.encoder(Buffer.from(args.multiaddr.slice(2), 'hex')),
-      }
-    },
-    NameChanged: (args: any) => ({ name: args.name }),
-    AbiChanged: (args: any) => ({ contentType: args.contentType }),
-    PubkeyChanged: (args: any) => ({ x: args.x, y: args.y }),
-    TextChanged: (args: any) => ({ key: args.key }),
-    ContenthashChanged: (args: any) => ({ hash: decodeContenthash(args.hash) }),
-    InterfaceChanged: (args: any) => ({
-      interfaceId: args.interfaceId,
-      implementer: args.implementer,
-    }),
-    AuthorisationChanged: (args: any) => ({
-      owner: args.owner,
-      target: args.target,
-      isAuthorized: args.isAuthorized,
-    }),
-  },
-}
-
-const mapEvents = (eventArray: any[], type: EventTypes) =>
-  eventArray.map((event: any) => ({
-    type: event.__typename,
-    blockNumber: event.blockNumber,
-    transactionHash: event.transactionID,
-    id: event.id,
-    data: eventFormat[type][event.__typename](event),
-  }))
-
-const mapResultDetailDecode =
-  (publicResolver: ethers.Contract) => (result: any) => {
-    const hashIndexes = makeOtherIndexes(result.input, '10f13a8c')
-    const abiLengths = hashIndexes.map((x: number) => ({
-      index: x,
-      length:
-        x === 0
-          ? ethers.utils.hexDataLength(result.input)
-          : parseInt(ethers.utils.hexDataSlice(result.input, x - 32, x), 16),
-    }))
-    const ABIs = abiLengths.map(({ index, length }) =>
-      ethers.utils.hexDataSlice(result.input, index, index + length),
-    )
-    return ABIs.map((abi: string) => {
-      try {
-        return publicResolver.interface.decodeFunctionData(
-          'setText(bytes32,string,string)',
-          abi,
-        )
-      } catch {
-        return
-      }
-    })
-  }
-
-const expandDecode = (prev: any, curr: any) => {
-  if (!curr) return [...prev, { value: null }]
-  if (!curr.length) return [...prev, curr]
-  return [...prev, ...curr]
-}
-
-export async function getHistory(
-  { gqlInstance }: ENSArgs<'gqlInstance'>,
-  name: string,
-) {
-  const client = gqlInstance.client
-  const query = gqlInstance.gql`
-      query getHistory($name: String!, $label: String!) {
-        domains(where: { name: $name }) {
-          events {
-            id
-            blockNumber
-            transactionID
-            __typename
-            ...on Transfer {
-              owner {
-                id
-              }
-            }
-            ...on NewOwner {
-              owner {
-                id
-              }
-            }
-            ...on NewResolver {
-              resolver {
-                id
-              }
-            }
-            ...on NewTTL {
-              ttl
-            }
-          }
-          owner {
-            registrations (where: { labelName: $label }) {
-              events {
-                id
-                blockNumber
-                transactionID
-                __typename
-                ...on NameRegistered {
-                  registrant {
-                    id
-                  }
-                  expiryDate
-                }
-                ...on NameRenewed {
-                  expiryDate
-                }
-                ...on NameTransferred {
-                  newOwner {
-                    id
-                  }
-                }
-              }
-            }
-          }
-          resolver {
-            events {
-              id
-              blockNumber
-              transactionID
-              __typename
-              ...on AddrChanged {
-                addr {
-                  id
-                }
-              }
-              ...on MulticoinAddrChanged {
-                coinType
-                multiaddr: addr
-              }
-              ...on NameChanged {
-                name
-              }
-              ...on AbiChanged {
-                contentType
-              }
-              ...on PubkeyChanged {
-                x
-                y
-              }
-              ...on TextChanged {
-                key
-              }
-              ...on ContenthashChanged {
-                hash
-              }
-              ...on InterfaceChanged {
-                interfaceID
-                implementer
-              }
-              ...on AuthorisationChanged {
-                owner
-                target
-                isAuthorized
-              }
-            }
-          }
-        }
-      }
-      `
-
-  const label = name.split('.')[0]
-
-  const { domains } = await client.request(query, { name, label })
-
-  if (!domains || domains.length === 0) return
-
-  const [
-    {
-      events: domainEvents,
-      owner: {
-        registrations: [{ events: registrationEvents }],
-      },
-      resolver: { events: resolverEvents },
-    },
-  ] = domains
-
-  const domainHistory = mapEvents(domainEvents, 'Domain')
-  const registrationHistory = mapEvents(registrationEvents, 'Registration')
-  let resolverHistory = mapEvents(
-    // remove duplicate events for ETH cointype
-    resolverEvents.filter(
-      (event: any) => !event.coinType || event.coinType !== '60',
-    ),
-    'Resolver',
-  )
-
-  return {
-    domain: domainHistory,
-    registration: registrationHistory,
-    resolver: resolverHistory,
-  }
-}
-
-export async function getHistoryWithDetail(
-  {
-    contracts,
-    gqlInstance,
-    provider,
-  }: ENSArgs<'contracts' | 'gqlInstance' | 'provider'>,
-  name: string,
-) {
-  const historyRes = await getHistory({ gqlInstance }, name)
-
-  if (!historyRes) return
-
-  const { domain, registration, resolver: resolverHistory } = historyRes
-
-  const textEvents = resolverHistory.filter(
-    (event) => event.type === 'TextChanged',
-  )
-
-  const transactions = textEvents.reduce((prev, curr) => {
-    if (prev.includes(curr.transactionHash)) {
-      return prev
-    }
-    return [...prev, curr.transactionHash]
-  }, [] as string[])
-
-  const publicResolver = await contracts?.getPublicResolver()!
-
-  const fetchResult = (
-    await ethers.utils.fetchJson(
-      provider!.connection,
-      JSON.stringify(
-        transactions.map((tx, i) => ({
-          jsonrpc: '2.0',
-          id: i,
-          method: 'eth_getTransactionByHash',
-          params: [tx],
-        })),
-      ),
-    )
-  )
-    .map((result: any) => result.result)
-    .map(mapResultDetailDecode(publicResolver))
-    .reduce(expandDecode, [])
-
-  const detailedResolverHistory = resolverHistory.map((event) => {
-    if (event.type !== 'TextChanged') return event
-    const { id } = event
-    const matchedTextInx = textEvents.findIndex((x) => x.id === id)
-    return {
-      ...event,
-      data: {
-        ...event.data,
-        value: fetchResult[matchedTextInx] && fetchResult[matchedTextInx].value,
-      },
-    }
-  })
-
-  return {
-    domain,
-    registration,
-    resolver: detailedResolverHistory,
-  }
-}
-
-export async function getHistoryDetailForTransactionHash(
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
-  hash: string,
-  indexInTransaction?: number,
-) {
-  const publicResolver = await contracts?.getPublicResolver()!
-  const transaction = await provider!.getTransaction(hash)
-  if (!transaction) return
-  const result = mapResultDetailDecode(publicResolver)({
-    input: transaction.data,
-  })
-  if (!result || !result.length) return
-  if (typeof indexInTransaction === 'number') {
-    if (indexInTransaction + 1 > result.length) return
-    const resultItem = result[indexInTransaction]
-    if (
-      !resultItem ||
-      !resultItem.key ||
-      (!resultItem.value && resultItem.value !== '')
-    )
-      return
-    return { key: resultItem.key, value: resultItem.value }
-  }
-  return result.map((item: any) => {
-    if (!item.key) return
-    if (!item.value && item.value !== '') return { key: item.key, value: null }
-    return { key: item.key, value: item.value }
-  })
-}

package/src/functions/getName.test.ts

@@ -1,47 +0,0 @@
-import { ethers } from 'ethers'
-import { ENS } from '..'
-import setup from '../tests/setup'
-
-let ENSInstance: ENS
-let revert: Awaited<ReturnType<typeof setup>>['revert']
-let provider: ethers.providers.JsonRpcProvider
-let accounts: string[]
-
-beforeAll(async () => {
-  ;({ ENSInstance, revert, provider } = await setup())
-  accounts = await provider.listAccounts()
-})
-
-afterAll(async () => {
-  await revert()
-})
-
-describe('getName', () => {
-  it('should get a primary name from an address', async () => {
-    const result = await ENSInstance.getName(
-      '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-    )
-    expect(result).toBeTruthy()
-    if (result) {
-      expect(result.name).toBe('jefflau.eth')
-      expect(result.match).toBeTruthy()
-    }
-  })
-  it('should return null for an address with no primary name', async () => {
-    const result = await ENSInstance.getName(
-      '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0',
-    )
-    expect(result).toBeUndefined()
-  })
-  it('should return with a false match for a name with no forward resolution', async () => {
-    const tx = await ENSInstance.setName('jefflau.eth')
-    await tx?.wait()
-
-    const result = await ENSInstance.getName(accounts[0])
-    expect(result).toBeTruthy()
-    if (result) {
-      expect(result.name).toBe('jefflau.eth')
-      expect(result.match).toBeFalsy()
-    }
-  })
-})

package/src/functions/getName.ts

@@ -1,41 +0,0 @@
-import { ENSArgs } from '..'
-import { hexEncodeName } from '../utils/hexEncodedName'
-
-const raw = async ({ contracts }: ENSArgs<'contracts'>, address: string) => {
-  const universalResolver = await contracts?.getUniversalResolver()!
-  const reverseNode = address.toLowerCase().substring(2) + '.addr.reverse'
-  return {
-    to: universalResolver.address,
-    data: universalResolver.interface.encodeFunctionData('reverse', [
-      hexEncodeName(reverseNode),
-    ]),
-  }
-}
-
-const decode = async (
-  { contracts }: ENSArgs<'contracts'>,
-  data: string,
-  address: string,
-) => {
-  if (data === null) return
-  const universalResolver = await contracts?.getUniversalResolver()!
-  try {
-    const result = universalResolver.interface.decodeFunctionResult(
-      'reverse',
-      data,
-    )
-    return {
-      name: result['0'],
-      match: result['1'].toLowerCase() === address.toLowerCase(),
-      reverseResolverAddress: result['2'],
-      resolverAddress: result['3'],
-    }
-  } catch {
-    return { name: null, match: false }
-  }
-}
-
-export default {
-  raw,
-  decode,
-}

package/src/functions/getNames.test.ts

@@ -1,247 +0,0 @@
-import { ENS } from '..'
-import { OwnedName, Registration } from '../functions/getNames'
-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))
-
-const testNotProperties = (obj: object, ...properties: string[]) =>
-  properties.map((property) => expect(obj).not.toHaveProperty(property))
-
-describe('getNames', () => {
-  let totalRegistrations: number = 0
-  let totalOwnedNames: number = 0
-  it('should get the registrations for an address', async () => {
-    const result = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      type: 'registrant',
-    })
-    totalRegistrations = result.length
-    expect(result).toBeTruthy()
-    testProperties(
-      result[0],
-      'expiryDate',
-      'registrationDate',
-      'id',
-      'labelName',
-      'labelhash',
-      'name',
-      'isMigrated',
-      'parent',
-      'truncatedName',
-    )
-  })
-  it('should get the owned names for an address', async () => {
-    const result = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      type: 'owner',
-    })
-    totalOwnedNames = result.length
-    expect(result).toBeTruthy()
-    testProperties(
-      result[0],
-      'id',
-      'labelName',
-      'labelhash',
-      'name',
-      'isMigrated',
-      'parent',
-      'truncatedName',
-    )
-    testNotProperties(result[0], 'expiryDate', 'registrationDate')
-  })
-  it('should get the registrations for an address with pagination', async () => {
-    const pageOne = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      type: 'registrant',
-      page: 0,
-    })
-    expect(pageOne).toHaveLength(10)
-    const pageTwo = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      type: 'registrant',
-      page: 1,
-    })
-    expect(pageTwo).toHaveLength(totalRegistrations % 10)
-  })
-  it('should get the owned names for an address with pagination', async () => {
-    const pageOne = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      type: 'owner',
-      page: 0,
-    })
-    expect(pageOne).toHaveLength(10)
-    const pageTwo = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      type: 'owner',
-      page: 1,
-    })
-    expect(pageTwo).toHaveLength(10)
-    const pageThree = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      type: 'owner',
-      page: 2,
-    })
-    expect(pageThree).toHaveLength(10)
-    const pageFour = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      type: 'owner',
-      page: 3,
-    })
-    expect(pageFour).toHaveLength(totalOwnedNames % 10)
-  })
-  describe('orderBy', () => {
-    describe('registrations', () => {
-      it('descending registrationDate', async () => {
-        const registrationDateOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-          type: 'registrant',
-          orderBy: 'registrationDate',
-          orderDirection: 'desc',
-        })) as Registration[]
-        registrationDateOrderedDesc.reduce((prev, curr) => {
-          expect(prev.registrationDate.getTime()).toBeGreaterThanOrEqual(
-            curr.registrationDate.getTime(),
-          )
-          return curr
-        })
-      })
-      it('ascending registrationDate', async () => {
-        const registrationDateOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-          type: 'registrant',
-          orderBy: 'registrationDate',
-          orderDirection: 'asc',
-        })) as Registration[]
-        registrationDateOrderedAsc.reduce((prev, curr) => {
-          expect(prev.registrationDate.getTime()).toBeLessThanOrEqual(
-            curr.registrationDate.getTime(),
-          )
-          return curr
-        })
-      })
-      it('descending expiryDate', async () => {
-        const expiryDateOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-          type: 'registrant',
-          orderBy: 'expiryDate',
-          orderDirection: 'desc',
-        })) as Registration[]
-        expiryDateOrderedDesc.reduce((prev, curr) => {
-          expect(prev.expiryDate.getTime()).toBeGreaterThanOrEqual(
-            curr.expiryDate.getTime(),
-          )
-          return curr
-        })
-      })
-      it('ascending expiryDate', async () => {
-        const expiryDateOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-          type: 'registrant',
-          orderBy: 'expiryDate',
-          orderDirection: 'asc',
-        })) as Registration[]
-        expiryDateOrderedAsc.reduce((prev, curr) => {
-          expect(prev.expiryDate.getTime()).toBeLessThanOrEqual(
-            curr.expiryDate.getTime(),
-          )
-          return curr
-        })
-      })
-      it('descending labelName', async () => {
-        const labelNameOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-          type: 'registrant',
-          orderBy: 'labelName',
-          orderDirection: 'desc',
-        })) as Registration[]
-        labelNameOrderedDesc.reduce((prev, curr) => {
-          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
-      })
-      it('ascending labelName', async () => {
-        const labelNameOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-          type: 'registrant',
-          orderBy: 'labelName',
-          orderDirection: 'asc',
-        })) as Registration[]
-        labelNameOrderedAsc.reduce((prev, curr) => {
-          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
-      })
-    })
-    describe('owned names', () => {
-      it('descending createdAt', async () => {
-        const createdAtOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-          type: 'owner',
-          orderBy: 'createdAt',
-          orderDirection: 'desc',
-        })) as OwnedName[]
-        createdAtOrderedDesc.reduce((prev, curr) => {
-          expect(prev.createdAt.getTime()).toBeGreaterThanOrEqual(
-            curr.createdAt.getTime(),
-          )
-          return curr
-        })
-      })
-      it('ascending createdAt', async () => {
-        const createdAtOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-          type: 'owner',
-          orderBy: 'createdAt',
-          orderDirection: 'asc',
-        })) as OwnedName[]
-        createdAtOrderedAsc.reduce((prev, curr) => {
-          expect(prev.createdAt.getTime()).toBeLessThanOrEqual(
-            curr.createdAt.getTime(),
-          )
-          return curr
-        })
-      })
-      it('descending labelName', async () => {
-        const labelNameOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-          type: 'owner',
-          orderBy: 'labelName',
-          orderDirection: 'desc',
-        })) as Registration[]
-        labelNameOrderedDesc.reduce((prev, curr) => {
-          if (
-            (!prev.labelName && !curr.labelName) ||
-            (!prev.labelName && curr.labelName)
-          )
-            return curr
-          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
-      })
-      it('ascending labelName', async () => {
-        const labelNameOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-          type: 'owner',
-          orderBy: 'labelName',
-          orderDirection: 'asc',
-        })) as Registration[]
-        labelNameOrderedAsc.reduce((prev, curr) => {
-          if (
-            (!prev.labelName && !curr.labelName) ||
-            (prev.labelName && !curr.labelName)
-          )
-            return curr
-          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
-      })
-    })
-  })
-})