@ensdomains/ensjs 3.0.0-alpha.40 → 3.0.0-alpha.42

package/src/functions/createSubname.ts

@@ -1,8 +1,7 @@
 import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
 import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
-import { FuseOptions } from '../utils/fuses'
-import generateFuseInput from '../utils/generateFuseInput'
+import { CombinedFuseInput, encodeFuses } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 import { Expiry, makeExpiry, wrappedLabelLengthCheck } from '../utils/wrapper'
 
@@ -14,7 +13,7 @@ type BaseArgs = {
 
 type NameWrapperArgs = {
   contract: 'nameWrapper'
-  fuses?: FuseOptions
+  fuses?: CombinedFuseInput
   expiry?: Expiry
 } & BaseArgs
 
@@ -70,8 +69,8 @@ export default async function (
 
       const generatedFuses =
         'fuses' in wrapperArgs && wrapperArgs.fuses
-          ? generateFuseInput(wrapperArgs.fuses)
-          : '0'
+          ? encodeFuses(wrapperArgs.fuses)
+          : 0
 
       return nameWrapper.populateTransaction.setSubnodeRecord(
         parentNodehash,

package/src/functions/getHistory.ts

@@ -4,6 +4,30 @@ import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
 import { labelhash } from '../utils/labels'
 import { namehash } from '../utils/normalise'
+import {
+  AbiChanged,
+  AddrChanged,
+  AuthorisationChanged,
+  ContenthashChanged,
+  ExpiryExtended,
+  FusesSet,
+  InterfaceChanged,
+  MulticoinAddrChanged,
+  NameChanged,
+  NameRegistered,
+  NameRenewed,
+  NameTransferred,
+  NameUnwrapped,
+  NameWrapped,
+  NewOwner,
+  NewResolver,
+  NewTtl,
+  PubkeyChanged,
+  TextChanged,
+  Transfer,
+  VersionChanged,
+  WrappedTransfer,
+} from '../utils/subgraph-types'
 
 type DomainEvent =
   | 'NewOwner'
@@ -14,6 +38,7 @@ type DomainEvent =
   | 'NameWrapped'
   | 'NameUnwrapped'
   | 'FusesSet'
+  | 'ExpiryExtended'
 type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred'
 type ResolverEvent =
   | 'AddrChanged'
@@ -38,30 +63,35 @@ const eventFormat: {
   [key in EventTypes]: { [n in EventFormat[key]]: (args: any) => object }
 } = {
   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 }),
-    WrappedTransfer: (args: any) => ({ owner: args.owner.id }),
-    NameWrapped: (args: any) => ({
+    NewOwner: (args: NewOwner) => ({ owner: args.owner.id }),
+    NewResolver: (args: NewResolver) => ({
+      resolver: args.resolver.id.split('-')[0],
+    }),
+    Transfer: (args: Transfer) => ({ owner: args.owner.id }),
+    NewTTL: (args: NewTtl) => ({ ttl: args.ttl }),
+    WrappedTransfer: (args: WrappedTransfer) => ({ owner: args.owner.id }),
+    NameWrapped: (args: NameWrapped) => ({
       fuses: args.fuses,
       owner: args.owner.id,
-      expiry: args.expiry,
+      expiryDate: args.expiryDate,
     }),
-    NameUnwrapped: (args: any) => ({ owner: args.owner.id }),
-    FusesSet: (args: any) => ({ fuses: args.fuses, expiry: args.expiry }),
+    NameUnwrapped: (args: NameUnwrapped) => ({ owner: args.owner.id }),
+    FusesSet: (args: FusesSet) => ({ fuses: args.fuses }),
+    ExpiryExtended: (args: ExpiryExtended) => ({ expiryDate: args.expiryDate }),
   },
   Registration: {
-    NameRegistered: (args: any) => ({
+    NameRegistered: (args: NameRegistered) => ({
       registrant: args.registrant.id,
       expiryDate: args.expiryDate,
     }),
-    NameRenewed: (args: any) => ({ expiryDate: args.expiryDate }),
-    NameTransferred: (args: any) => ({ owner: args.newOwner.id }),
+    NameRenewed: (args: NameRenewed) => ({ expiryDate: args.expiryDate }),
+    NameTransferred: (args: NameTransferred) => ({ owner: args.newOwner.id }),
   },
   Resolver: {
-    AddrChanged: (args: any) => ({ addr: args.addr.id }),
-    MulticoinAddrChanged: (args: any) => {
+    AddrChanged: (args: AddrChanged) => ({ addr: args.addr.id }),
+    MulticoinAddrChanged: (
+      args: Omit<MulticoinAddrChanged, 'addr'> & { multiaddr: string },
+    ) => {
       const format = formatsByCoinType[parseInt(args.coinType)]
       if (!format) {
         return {
@@ -82,21 +112,23 @@ const eventFormat: {
         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, value: args.value }),
-    ContenthashChanged: (args: any) => ({ hash: decodeContenthash(args.hash) }),
-    InterfaceChanged: (args: any) => ({
-      interfaceId: args.interfaceId,
+    NameChanged: (args: NameChanged) => ({ name: args.name }),
+    AbiChanged: (args: AbiChanged) => ({ contentType: args.contentType }),
+    PubkeyChanged: (args: PubkeyChanged) => ({ x: args.x, y: args.y }),
+    TextChanged: (args: TextChanged) => ({ key: args.key, value: args.value }),
+    ContenthashChanged: (args: ContenthashChanged) => ({
+      hash: decodeContenthash(args.hash),
+    }),
+    InterfaceChanged: (args: InterfaceChanged) => ({
+      interfaceId: args.interfaceID,
       implementer: args.implementer,
     }),
-    AuthorisationChanged: (args: any) => ({
+    AuthorisationChanged: (args: AuthorisationChanged) => ({
       owner: args.owner,
       target: args.target,
       isAuthorized: args.isAuthorized,
     }),
-    VersionChanged: (args: any) => ({ version: args.version }),
+    VersionChanged: (args: VersionChanged) => ({ version: args.version }),
   },
 }
 
@@ -154,7 +186,7 @@ export async function getHistory(
             }
             ...on NameWrapped {
               fuses
-              expiry
+              expiryDate
               owner {
                 id
               }
@@ -166,7 +198,9 @@ export async function getHistory(
             }
             ...on FusesSet {
               fuses
-              expiry
+            }
+            ...on ExpiryExtended {
+              expiryDate
             }
           }
           registration {

package/src/functions/getNames.test.ts

@@ -172,7 +172,7 @@ describe('getNames', () => {
       type: 'wrappedOwner',
       page: 0,
     })
-    expect(pageOne).toHaveLength(1)
+    expect(pageOne).toHaveLength(2)
   })
   describe('orderBy', () => {
     describe('registrations', () => {

package/src/functions/getNames.ts

@@ -1,7 +1,8 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
-import { CurrentFuses, decodeFuses } from '../utils/fuses'
+import { AllCurrentFuses, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
+import { Domain, Registration, WrappedDomain } from '../utils/subgraph-types'
 
 export type Name = {
   id: string
@@ -16,7 +17,7 @@ export type Name = {
   createdAt?: Date
   registrationDate?: Date
   expiryDate?: Date
-  fuses?: CurrentFuses
+  fuses?: AllCurrentFuses
   registration?: {
     expiryDate: Date
     registrationDate: Date
@@ -44,7 +45,7 @@ type OwnerParams = {
 
 type WrappedOwnerParams = {
   type: 'wrappedOwner'
-  orderBy?: 'expiryDate' | 'labelName'
+  orderBy?: 'expiryDate' | 'name'
 }
 
 type AllParams = {
@@ -57,23 +58,35 @@ type AllParams = {
 type Params = BaseParams &
   (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams)
 
-const mapDomain = (domain: any) => {
-  const decrypted = decryptName(domain.name)
+const mapDomain = ({ name, ...domain }: Domain) => {
+  const decrypted = name ? decryptName(name) : undefined
   return {
     ...domain,
     name: decrypted,
-    truncatedName: truncateFormat(decrypted),
+    truncatedName: decrypted ? truncateFormat(decrypted) : undefined,
     createdAt: new Date(parseInt(domain.createdAt) * 1000),
     type: 'domain',
   }
 }
 
-const mapWrappedDomain = (wrappedDomain: any) => {
-  const domain = mapDomain(wrappedDomain.domain)
+const mapWrappedDomain = (wrappedDomain: WrappedDomain) => {
+  const domain = mapDomain(wrappedDomain.domain) as Omit<
+    ReturnType<typeof mapDomain>,
+    'registration'
+  > & {
+    registration?: {
+      expiryDate: string | Date
+      registrationDate: string | Date
+    }
+  }
   if (domain.registration) {
     domain.registration = {
-      expiryDate: new Date(parseInt(domain.registration.expiryDate) * 1000),
-      registrationDate: new Date(domain.registration.registrationDate * 1000),
+      expiryDate: new Date(
+        parseInt(domain.registration.expiryDate as string) * 1000,
+      ),
+      registrationDate: new Date(
+        parseInt(domain.registration.registrationDate as string) * 1000,
+      ),
     }
   }
   return {
@@ -84,8 +97,8 @@ const mapWrappedDomain = (wrappedDomain: any) => {
   }
 }
 
-const mapRegistration = (registration: any) => {
-  const decrypted = decryptName(registration.domain.name)
+const mapRegistration = (registration: Registration) => {
+  const decrypted = decryptName(registration.domain.name!)
   return {
     expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
     registrationDate: new Date(parseInt(registration.registrationDate) * 1000),
@@ -275,7 +288,7 @@ const getNames = async (
         id: address,
         first: pageSize,
         skip: (page || 0) * pageSize,
-        orderBy,
+        orderBy: orderBy === 'labelName' ? 'name' : orderBy,
         orderDirection,
       }
     }

package/src/functions/getOwner.test.ts

@@ -1,11 +1,15 @@
+import { JsonRpcProvider } from '@ethersproject/providers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
 let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: JsonRpcProvider
+let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ensInstance, revert } = await setup())
+  ;({ ensInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
 })
 
 afterAll(async () => {
@@ -13,8 +17,63 @@ afterAll(async () => {
 })
 
 describe('getOwner', () => {
-  it('should return nameWrapper as the ownership level for a wrapped name', async () => {
+  it('should return correct ownership level and values for a wrapped .eth name', async () => {
     const result = await ensInstance.getOwner('wrapped.eth')
-    expect(result?.ownershipLevel).toBe('nameWrapper')
+    expect(result).toEqual({
+      ownershipLevel: 'nameWrapper',
+      owner: accounts[1],
+      expired: false,
+    })
+  })
+  it('should return correct ownership level and values for an expired wrapped .eth name', async () => {
+    const result = await ensInstance.getOwner('expired-wrapped.eth')
+    expect(result).toEqual({
+      ownershipLevel: 'nameWrapper',
+      owner: '0x0000000000000000000000000000000000000000',
+      expired: true,
+    })
+  })
+  it('should return correct ownership level and values for an unwrapped .eth name', async () => {
+    const result = await ensInstance.getOwner('test123.eth')
+    expect(result).toEqual({
+      ownershipLevel: 'registrar',
+      owner: accounts[1],
+      registrant: accounts[1],
+      expired: false,
+    })
+  })
+  it('should return correct ownership level and values for an expired unwrapped .eth name', async () => {
+    const result = await ensInstance.getOwner('expired.eth')
+    expect(result).toEqual({
+      ownershipLevel: 'registrar',
+      owner: accounts[1],
+      registrant: accounts[1].toLowerCase(),
+      expired: true,
+    })
+  })
+  describe('subname', () => {
+    it('should return correct ownership level and values for a unwrapped name', async () => {
+      const result = await ensInstance.getOwner('test.with-subnames.eth')
+      expect(result).toEqual({
+        ownershipLevel: 'registry',
+        owner: accounts[2],
+      })
+    })
+    it('should return correct ownership level and values for a wrapped name', async () => {
+      const result = await ensInstance.getOwner(
+        'test.wrapped-with-subnames.eth',
+      )
+      expect(result).toEqual({
+        ownershipLevel: 'nameWrapper',
+        owner: accounts[2],
+      })
+    })
+    it('should return correct ownership level and values for an expired wrapped name', async () => {
+      const result = await ensInstance.getOwner('test.expired-wrapped.eth')
+      expect(result).toEqual({
+        ownershipLevel: 'nameWrapper',
+        owner: accounts[2],
+      })
+    })
   })
 })

package/src/functions/getOwner.ts

@@ -9,6 +9,7 @@ type Owner = {
   registrant?: string
   owner?: string
   ownershipLevel: 'nameWrapper' | 'registry' | 'registrar'
+  expired?: boolean
 }
 
 const singleContractOwnerRaw = async (
@@ -146,26 +147,43 @@ const decode = async (
 
   const registryOwner = (decodedData[0] as Result)[0]
   const nameWrapperOwner = (decodedData[1] as Result)[0]
-  let registrarOwner = (decodedData[2] as Result | undefined)?.[0]
+  let registrarOwner: string | undefined = (
+    decodedData[2] as Result | undefined
+  )?.[0]
+  let baseReturnObject: {
+    expired?: boolean
+  } = {}
 
   // check for only .eth names
   if (labels[labels.length - 1] === 'eth') {
-    if (!registrarOwner && labels.length === 2) {
-      const graphRegistrantResult = await gqlInstance.client.request(
-        registrantQuery,
-        {
-          namehash: makeNamehash(name),
-        },
-      )
-      registrarOwner =
-        graphRegistrantResult.domain?.registration?.registrant?.id
+    // if there is no registrar owner, the name is expired
+    // but we still want to get the registrar owner prior to expiry
+    if (labels.length === 2) {
+      if (!registrarOwner) {
+        const graphRegistrantResult = await gqlInstance.client.request(
+          registrantQuery,
+          {
+            namehash: makeNamehash(name),
+          },
+        )
+        registrarOwner =
+          graphRegistrantResult.domain?.registration?.registrant?.id
+        baseReturnObject = {
+          expired: true,
+        }
+      } else {
+        baseReturnObject = {
+          expired: false,
+        }
+      }
     }
     // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner
     // there is no "registrant" for wrapped names
-    if (registrarOwner === nameWrapper.address) {
+    if (registrarOwner?.toLowerCase() === nameWrapper.address.toLowerCase()) {
       return {
         owner: nameWrapperOwner,
         ownershipLevel: 'nameWrapper',
+        ...baseReturnObject,
       }
     }
     // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
@@ -177,6 +195,7 @@ const decode = async (
         registrant: registrarOwner,
         owner: registryOwner,
         ownershipLevel: 'registrar',
+        ...baseReturnObject,
       }
     }
     if (hexStripZeros(registryOwner) !== '0x') {
@@ -187,6 +206,7 @@ const decode = async (
           registrant: undefined,
           owner: registryOwner,
           ownershipLevel: 'registrar',
+          expired: true,
         }
       }
       // this means that the subname is wrapped

package/src/functions/getSpecificRecord.test.ts

@@ -7,6 +7,125 @@ beforeAll(async () => {
   ;({ ensInstance } = await setup())
 })
 
+const dummyABI = [
+  {
+    type: 'event',
+    anonymous: false,
+    name: 'ABIChanged',
+    inputs: [
+      {
+        type: 'bytes32',
+        indexed: true,
+      },
+      {
+        type: 'uint256',
+        indexed: true,
+      },
+    ],
+  },
+  {
+    type: 'event',
+    anonymous: false,
+    name: 'VersionChanged',
+    inputs: [
+      {
+        type: 'bytes32',
+        indexed: true,
+      },
+      {
+        type: 'uint64',
+      },
+    ],
+  },
+  {
+    type: 'function',
+    name: 'ABI',
+    constant: true,
+    stateMutability: 'view',
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes32',
+      },
+      {
+        type: 'uint256',
+      },
+    ],
+    outputs: [
+      {
+        type: 'uint256',
+      },
+      {
+        type: 'bytes',
+      },
+    ],
+  },
+  {
+    type: 'function',
+    name: 'clearRecords',
+    constant: false,
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes32',
+      },
+    ],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'recordVersions',
+    constant: true,
+    stateMutability: 'view',
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes32',
+      },
+    ],
+    outputs: [
+      {
+        type: 'uint64',
+      },
+    ],
+  },
+  {
+    type: 'function',
+    name: 'setABI',
+    constant: false,
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes32',
+      },
+      {
+        type: 'uint256',
+      },
+      {
+        type: 'bytes',
+      },
+    ],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'supportsInterface',
+    constant: true,
+    stateMutability: 'view',
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes4',
+      },
+    ],
+    outputs: [
+      {
+        type: 'bool',
+      },
+    ],
+  },
+]
+
 describe('getSpecificRecord', () => {
   describe('getContentHash', () => {
     it('should return null for a non-existent name', async () => {
@@ -76,4 +195,47 @@ describe('getSpecificRecord', () => {
       expect(result).toBeUndefined()
     })
   })
+
+  describe('getABI', () => {
+    it('should return object for type 1 ABI', async () => {
+      const result = await ensInstance.getABI('with-type-1-abi.eth')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.contentType).toBe(1)
+        expect(result.decoded).toBe(true)
+        expect(result.abi).toMatchObject(dummyABI)
+      }
+    })
+    it('should return object for type 2 ABI', async () => {
+      const result = await ensInstance.getABI('with-type-2-abi.eth')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.contentType).toBe(2)
+        expect(result.decoded).toBe(true)
+        expect(result.abi).toMatchObject(dummyABI)
+      }
+    })
+    it('should return object for type 4 ABI', async () => {
+      const result = await ensInstance.getABI('with-type-4-abi.eth')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.contentType).toBe(4)
+        expect(result.decoded).toBe(true)
+        expect(result.abi).toMatchObject(dummyABI)
+      }
+    })
+    it('should return unresolved URI for type 8 ABI', async () => {
+      const result = await ensInstance.getABI('with-type-8-abi.eth')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.contentType).toBe(8)
+        expect(result.decoded).toBe(false)
+        expect(result.abi).toBe('https://example.com')
+      }
+    })
+    it('should return undefined if unsupported contentType', async () => {
+      const result = await ensInstance.getABI('with-type-256-abi.eth')
+      expect(result).toBeUndefined()
+    })
+  })
 })