@ensdomains/ensjs 3.0.0-alpha.10 → 3.0.0-alpha.13

package/src/functions/getHistory.ts

@@ -2,7 +2,6 @@ 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'
@@ -63,7 +62,7 @@ const eventFormat: Record<
     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 }),
+    TextChanged: (args: any) => ({ key: args.key, value: args.value }),
     ContenthashChanged: (args: any) => ({ hash: decodeContenthash(args.hash) }),
     InterfaceChanged: (args: any) => ({
       interfaceId: args.interfaceId,
@@ -86,37 +85,6 @@ const mapEvents = (eventArray: any[], type: EventTypes) =>
     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,
@@ -200,6 +168,7 @@ export async function getHistory(
               }
               ...on TextChanged {
                 key
+                value
               }
               ...on ContenthashChanged {
                 hash
@@ -251,97 +220,3 @@ export async function getHistory(
     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

@@ -19,11 +19,11 @@ afterAll(async () => {
 describe('getName', () => {
   it('should get a primary name from an address', async () => {
     const result = await ENSInstance.getName(
-      '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
     )
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.name).toBe('jefflau.eth')
+      expect(result.name).toBe('with-profile.eth')
       expect(result.match).toBeTruthy()
     }
   })
@@ -31,16 +31,16 @@ describe('getName', () => {
     const result = await ENSInstance.getName(
       '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0',
     )
-    expect(result).toBeUndefined()
+    expect(result?.name).toBeUndefined()
   })
   it('should return with a false match for a name with no forward resolution', async () => {
-    const tx = await ENSInstance.setName('jefflau.eth')
+    const tx = await ENSInstance.setName('with-profile.eth')
     await tx?.wait()
 
     const result = await ENSInstance.getName(accounts[0])
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.name).toBe('jefflau.eth')
+      expect(result.name).toBe('with-profile.eth')
       expect(result.match).toBeFalsy()
     }
   })

package/src/functions/getName.ts

@@ -31,7 +31,7 @@ const decode = async (
       resolverAddress: result['3'],
     }
   } catch {
-    return { name: null, match: false }
+    return { name: undefined }
   }
 }
 

package/src/functions/getNames.test.ts

@@ -1,6 +1,6 @@
 import { ENS } from '..'
-import { OwnedName, Registration } from '../functions/getNames'
 import setup from '../tests/setup'
+import { Name } from './getNames'
 
 let ENSInstance: ENS
 
@@ -14,12 +14,43 @@ const testProperties = (obj: object, ...properties: string[]) =>
 const testNotProperties = (obj: object, ...properties: string[]) =>
   properties.map((property) => expect(obj).not.toHaveProperty(property))
 
+const letterItems = [
+  'w',
+  '9',
+  '8',
+  '7',
+  '6',
+  '5',
+  '4',
+  ...Array(5).fill('3'),
+  ...Array(11).fill('2'),
+  ...Array(11).fill('1'),
+  '0',
+]
+
+const domainLetterItems = [
+  '[',
+  'w',
+  't',
+  't',
+  '9',
+  '8',
+  '7',
+  '6',
+  '5',
+  '4',
+  ...Array(5).fill('3'),
+  ...Array(11).fill('2'),
+  ...Array(11).fill('1'),
+  '0',
+]
+
 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',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'registrant',
     })
     totalRegistrations = result.length
@@ -39,7 +70,7 @@ describe('getNames', () => {
   })
   it('should get the owned names for an address', async () => {
     const result = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
     })
     totalOwnedNames = result.length
@@ -58,39 +89,51 @@ describe('getNames', () => {
   })
   it('should get the registrations for an address with pagination', async () => {
     const pageOne = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'registrant',
       page: 0,
     })
     expect(pageOne).toHaveLength(10)
     const pageTwo = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'registrant',
       page: 1,
     })
-    expect(pageTwo).toHaveLength(totalRegistrations % 10)
+    expect(pageTwo).toHaveLength(10)
+    const pageThree = await ENSInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'registrant',
+      page: 2,
+    })
+    expect(pageThree).toHaveLength(10)
+    const pageFour = await ENSInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'registrant',
+      page: 3,
+    })
+    expect(pageFour).toHaveLength(totalRegistrations % 10)
   })
   it('should get the owned names for an address with pagination', async () => {
     const pageOne = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 0,
     })
     expect(pageOne).toHaveLength(10)
     const pageTwo = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 1,
     })
     expect(pageTwo).toHaveLength(10)
     const pageThree = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 2,
     })
     expect(pageThree).toHaveLength(10)
     const pageFour = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 3,
     })
@@ -100,147 +143,133 @@ describe('getNames', () => {
     describe('registrations', () => {
       it('descending registrationDate', async () => {
         const registrationDateOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'registrationDate',
           orderDirection: 'desc',
-        })) as Registration[]
+        })) as Name[]
         registrationDateOrderedDesc.reduce((prev, curr) => {
-          expect(prev.registrationDate.getTime()).toBeGreaterThanOrEqual(
-            curr.registrationDate.getTime(),
+          expect(prev.registrationDate!.getTime()).toBeGreaterThanOrEqual(
+            curr.registrationDate!.getTime(),
           )
           return curr
         })
       })
       it('ascending registrationDate', async () => {
         const registrationDateOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'registrationDate',
           orderDirection: 'asc',
-        })) as Registration[]
+        })) as Name[]
         registrationDateOrderedAsc.reduce((prev, curr) => {
-          expect(prev.registrationDate.getTime()).toBeLessThanOrEqual(
-            curr.registrationDate.getTime(),
+          expect(prev.registrationDate!.getTime()).toBeLessThanOrEqual(
+            curr.registrationDate!.getTime(),
           )
           return curr
         })
       })
       it('descending expiryDate', async () => {
         const expiryDateOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'expiryDate',
           orderDirection: 'desc',
-        })) as Registration[]
+        })) as Name[]
         expiryDateOrderedDesc.reduce((prev, curr) => {
-          expect(prev.expiryDate.getTime()).toBeGreaterThanOrEqual(
-            curr.expiryDate.getTime(),
+          expect(prev.expiryDate!.getTime()).toBeGreaterThanOrEqual(
+            curr.expiryDate!.getTime(),
           )
           return curr
         })
       })
       it('ascending expiryDate', async () => {
         const expiryDateOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'expiryDate',
           orderDirection: 'asc',
-        })) as Registration[]
+        })) as Name[]
         expiryDateOrderedAsc.reduce((prev, curr) => {
-          expect(prev.expiryDate.getTime()).toBeLessThanOrEqual(
-            curr.expiryDate.getTime(),
+          expect(prev.expiryDate!.getTime()).toBeLessThanOrEqual(
+            curr.expiryDate!.getTime(),
           )
           return curr
         })
       })
       it('descending labelName', async () => {
         const labelNameOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'labelName',
           orderDirection: 'desc',
-        })) as Registration[]
-        labelNameOrderedDesc.reduce((prev, curr) => {
-          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
+        })) as Name[]
+        expect(labelNameOrderedDesc.map((n) => n.labelName![0])).toStrictEqual(
+          letterItems,
+        )
       })
       it('ascending labelName', async () => {
         const labelNameOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'labelName',
           orderDirection: 'asc',
-        })) as Registration[]
-        labelNameOrderedAsc.reduce((prev, curr) => {
-          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
+        })) as Name[]
+        expect(labelNameOrderedAsc.map((n) => n.labelName![0])).toStrictEqual(
+          letterItems.reverse(),
+        )
       })
     })
     describe('owned names', () => {
       it('descending createdAt', async () => {
         const createdAtOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'owner',
           orderBy: 'createdAt',
           orderDirection: 'desc',
-        })) as OwnedName[]
+        })) as Name[]
         createdAtOrderedDesc.reduce((prev, curr) => {
-          expect(prev.createdAt.getTime()).toBeGreaterThanOrEqual(
-            curr.createdAt.getTime(),
+          expect(prev.createdAt!.getTime()).toBeGreaterThanOrEqual(
+            curr.createdAt!.getTime(),
           )
           return curr
         })
       })
       it('ascending createdAt', async () => {
         const createdAtOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'owner',
           orderBy: 'createdAt',
           orderDirection: 'asc',
-        })) as OwnedName[]
+        })) as Name[]
         createdAtOrderedAsc.reduce((prev, curr) => {
-          expect(prev.createdAt.getTime()).toBeLessThanOrEqual(
-            curr.createdAt.getTime(),
+          expect(prev.createdAt!.getTime()).toBeLessThanOrEqual(
+            curr.createdAt!.getTime(),
           )
           return curr
         })
       })
       it('descending labelName', async () => {
         const labelNameOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           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
-        })
+        })) as Name[]
+        expect(labelNameOrderedDesc.map((n) => n.name[0])).toStrictEqual(
+          domainLetterItems,
+        )
       })
       it('ascending labelName', async () => {
         const labelNameOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           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
-        })
+        })) as Name[]
+        expect(labelNameOrderedAsc.map((n) => n.name[0])).toStrictEqual(
+          domainLetterItems.reverse(),
+        )
       })
     })
   })

package/src/functions/getOwner.test.ts

@@ -10,10 +10,6 @@ let accounts: string[]
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', {
-    wrappedOwner: accounts[0],
-  })
-  await tx.wait()
 })
 
 afterAll(async () => {
@@ -26,19 +22,19 @@ describe('getOwner', () => {
     expect(result).toBeUndefined()
   })
   it('should return the owner, registrant, and ownership level for a registered name', async () => {
-    const result = await ENSInstance.getOwner('jefflau.eth')
+    const result = await ENSInstance.getOwner('with-profile.eth')
     expect(result).toMatchObject({
-      owner: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      registrant: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      owner: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      registrant: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       ownershipLevel: 'registrar',
     })
   })
   it('should return nameWrapper as the ownership level for a wrapped name', async () => {
-    const result = await ENSInstance.getOwner('parthtejpal.eth')
+    const result = await ENSInstance.getOwner('wrapped.eth')
     expect(result?.ownershipLevel).toBe('nameWrapper')
   })
   it('should return the owner at a specific level if specified', async () => {
-    const result = await ENSInstance.getOwner('parthtejpal.eth', 'registrar')
+    const result = await ENSInstance.getOwner('wrapped.eth', 'registrar')
     const nameWrapperAddress = (await ENSInstance.contracts!.getNameWrapper())
       .address
     expect(result?.ownershipLevel).toBe('registrar')
@@ -54,20 +50,9 @@ describe('getOwner', () => {
       baseRegistrarAddress.toLowerCase(),
     )
   })
-  // it('should return registry as the ownership level for an unwrapped subname', async () => {
-  //   const result0 = await ENSInstance.getOwner('fleek.eth')
-  //   console.log(result0?.owner, accounts[2])
-
-  //   const tx = await ENSInstance.createSubname({
-  //     name: 'test.fleek.eth',
-  //     contract: 'registry',
-  //     owner: accounts[0],
-  //     options: { addressOrIndex: accounts[1] },
-  //   })
-
-  //   await tx.wait()
-
-  //   const result = await ENSInstance.getOwner('test.fleek.eth')
-  //   expect(result?.ownershipLevel).toBe('registry')
-  // })
+  it('should return registry as the ownership level for an unwrapped subname', async () => {
+    const result = await ENSInstance.getOwner('test.with-subnames.eth')
+    expect(result?.ownershipLevel).toBe('registry')
+    expect(result?.owner).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
+  })
 })