@ensdomains/ensjs 3.0.0-alpha.45 → 3.0.0-alpha.47

package/dist/types/functions/getSubnames.d.ts

@@ -1,15 +1,27 @@
 import { ENSArgs } from '..';
-declare type Subname = {
+import { AllCurrentFuses } from '../utils/fuses';
+declare type BaseSubname = {
     id: string;
     labelName: string | null;
     truncatedName?: string;
     labelhash: string;
     isMigrated: boolean;
     name: string;
-    owner: {
-        id: string;
-    };
+    owner: string | undefined;
 };
+declare type UnwrappedSubname = BaseSubname & {
+    fuses?: never;
+    expiryDate?: never;
+    pccExpired?: never;
+    type: 'domain';
+};
+declare type WrappedSubname = BaseSubname & {
+    fuses: AllCurrentFuses;
+    expiryDate: Date;
+    pccExpired: boolean;
+    type: 'wrappedDomain';
+};
+declare type Subname = WrappedSubname | UnwrappedSubname;
 declare type Params = {
     name: string;
     page?: number;

package/dist/types/functions/transferSubname.d.ts

@@ -10,5 +10,5 @@ declare type NameWrapperArgs = {
     expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract, owner, resolverAddress, ...wrapperArgs }: Args): Promise<import("ethers").PopulatedTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, owner, resolverAddress, ...wrapperArgs }: Args): Promise<import("ethers").PopulatedTransaction>;
 export {};

package/dist/types/index.d.ts

@@ -461,17 +461,75 @@ export declare class ENS {
         lastSubnames?: any[] | undefined;
         search?: string | undefined;
     }) => Promise<{
-        subnames: {
+        subnames: (({
             id: string;
             labelName: string | null;
             truncatedName?: string | undefined;
             labelhash: string;
             isMigrated: boolean;
             name: string;
-            owner: {
-                id: string;
+            owner: string | undefined;
+        } & {
+            fuses?: undefined;
+            expiryDate?: undefined;
+            pccExpired?: undefined;
+            type: "domain";
+        }) | ({
+            id: string;
+            labelName: string | null;
+            truncatedName?: string | undefined;
+            labelhash: string;
+            isMigrated: boolean;
+            name: string;
+            owner: string | undefined;
+        } & {
+            fuses: {
+                parent: {
+                    unnamed: {
+                        524288: boolean;
+                        1048576: boolean;
+                        2097152: boolean;
+                        4194304: boolean;
+                        8388608: boolean;
+                        16777216: boolean;
+                        33554432: boolean;
+                        67108864: boolean;
+                        134217728: boolean;
+                        268435456: boolean;
+                        536870912: boolean;
+                        1073741824: boolean;
+                        2147483648: boolean;
+                    };
+                    IS_DOT_ETH: boolean;
+                    PARENT_CANNOT_CONTROL: boolean;
+                    CAN_EXTEND_EXPIRY: boolean;
+                };
+                child: {
+                    CAN_DO_EVERYTHING: boolean;
+                    unnamed: {
+                        1024: boolean;
+                        64: boolean;
+                        128: boolean;
+                        256: boolean;
+                        512: boolean;
+                        2048: boolean;
+                        4096: boolean;
+                        8192: boolean;
+                        16384: boolean;
+                        32768: boolean;
+                    };
+                    CANNOT_UNWRAP: boolean;
+                    CANNOT_BURN_FUSES: boolean;
+                    CANNOT_TRANSFER: boolean;
+                    CANNOT_SET_RESOLVER: boolean;
+                    CANNOT_SET_TTL: boolean;
+                    CANNOT_CREATE_SUBDOMAIN: boolean;
+                };
             };
-        }[];
+            expiryDate: Date;
+            pccExpired: boolean;
+            type: "wrappedDomain";
+        }))[];
         subnameCount: number;
     }>;
     getNames: (args_0: {

package/dist/types/utils/fuses.d.ts

@@ -128,5 +128,6 @@ export declare const decodeFuses: (fuses: number) => {
         CANNOT_CREATE_SUBDOMAIN: boolean;
     };
 };
+export declare const checkPCCBurned: (fuses: number) => boolean;
 export declare type AllCurrentFuses = ReturnType<typeof decodeFuses>;
 export default fullFuseEnum;

package/dist/types/utils/registry.d.ts

@@ -0,0 +1,2 @@
+import { ENSArgs } from '../index';
+export declare const makeResolver: ({ contracts }: ENSArgs<'contracts'>, name: string, resolver?: string) => Promise<string>;

package/dist/types/utils/wrapper.d.ts

@@ -2,5 +2,6 @@ import { BigNumber } from '@ethersproject/bignumber';
 import { ENSArgs } from '../index';
 export declare type Expiry = string | number | Date | BigNumber;
 export declare const MAX_EXPIRY: BigNumber;
+export declare const expiryToBigNumber: (expiry?: Expiry, defaultValue?: number) => BigNumber;
 export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry) => Promise<BigNumber>;
 export declare const wrappedLabelLengthCheck: (label: string) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.45",
+  "version": "3.0.0-alpha.47",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",

package/src/functions/deleteSubname.test.ts

@@ -1,12 +1,20 @@
+import { ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
 
 let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ensInstance, revert } = await setup())
+  ;({ ensInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+beforeEach(async () => {
+  await revert()
 })
 
 afterAll(async () => {
@@ -17,27 +25,34 @@ describe('deleteSubname', () => {
   beforeEach(async () => {
     await revert()
   })
-  it('should allow deleting a subname on the registry', async () => {
+  it('should allow deleting a subname on the registry by parent owner', async () => {
+    const registry = await ensInstance.contracts!.getRegistry()!
+    const parentOwner = await registry.owner(namehash('with-subnames.eth'))
+
     const tx = await ensInstance.deleteSubname('test.with-subnames.eth', {
       contract: 'registry',
-      addressOrIndex: 1,
+      addressOrIndex: parentOwner,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const registry = await ensInstance.contracts!.getRegistry()!
     const result = await registry.owner(namehash('test.with-subnames.eth'))
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
 
-  it('should allow deleting a subname on the nameWrapper', async () => {
+  it('should allow deleting a subname on the nameWrapper by parent owner', async () => {
     const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
 
+    const parentOwner = await nameWrapper.ownerOf(
+      namehash('wrapped-with-subnames.eth'),
+    )
+
     const tx = await ensInstance.deleteSubname(
       'test.wrapped-with-subnames.eth',
       {
         contract: 'nameWrapper',
-        addressOrIndex: 1,
+        method: 'setSubnodeOwner',
+        addressOrIndex: parentOwner,
       },
     )
     expect(tx).toBeTruthy()
@@ -49,10 +64,128 @@ describe('deleteSubname', () => {
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
 
+  it('should allow deleting a subname on the nameWrapper by name owner', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+    const nameOwner = await nameWrapper.ownerOf(
+      namehash('addr.wrapped-with-subnames.eth'),
+    )
+
+    await ensInstance.deleteSubname('addr.wrapped-with-subnames.eth', {
+      contract: 'nameWrapper',
+      method: 'setRecord',
+      addressOrIndex: nameOwner,
+    })
+
+    const result = await nameWrapper.ownerOf(
+      namehash('addr.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+
+  it('should allow deleting a subname on the nameWrapper with PCC burned by name owner', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+    const parentOwner = await nameWrapper.ownerOf(
+      namehash('wrapped-with-subnames.eth'),
+    )
+
+    const tx0 = await ensInstance.setFuses('wrapped-with-subnames.eth', {
+      named: ['CANNOT_UNWRAP'],
+      addressOrIndex: parentOwner,
+    })
+    expect(tx0).toBeTruthy()
+    await tx0.wait()
+
+    const tx1 = await ensInstance.setChildFuses(
+      'xyz.wrapped-with-subnames.eth',
+      {
+        fuses: {
+          parent: {
+            named: ['PARENT_CANNOT_CONTROL'],
+          },
+        },
+        addressOrIndex: parentOwner,
+      },
+    )
+    expect(tx1).toBeTruthy()
+    await tx1.wait()
+
+    const nameOwner = await nameWrapper.ownerOf(
+      namehash('xyz.wrapped-with-subnames.eth'),
+    )
+
+    expect(parentOwner === nameOwner).toBe(false)
+
+    const tx = await ensInstance.deleteSubname(
+      'xyz.wrapped-with-subnames.eth',
+      {
+        contract: 'nameWrapper',
+        method: 'setRecord',
+        addressOrIndex: nameOwner,
+      },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const result = await nameWrapper.ownerOf(
+      namehash('xyz.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+
+  it('should NOT allow deleting a subname on the nameWrapper with PCC burned by parent owner', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+    const parentOwner = await nameWrapper.ownerOf(
+      namehash('wrapped-with-subnames.eth'),
+    )
+
+    const tx0 = await ensInstance.setFuses('wrapped-with-subnames.eth', {
+      named: ['CANNOT_UNWRAP'],
+      addressOrIndex: parentOwner,
+    })
+    expect(tx0).toBeTruthy()
+    await tx0.wait()
+
+    const tx1 = await ensInstance.setChildFuses(
+      'legacy.wrapped-with-subnames.eth',
+      {
+        fuses: {
+          parent: {
+            named: ['PARENT_CANNOT_CONTROL'],
+          },
+        },
+        addressOrIndex: parentOwner,
+      },
+    )
+    expect(tx1).toBeTruthy()
+    await tx1.wait()
+
+    const checkOwner = await nameWrapper.ownerOf(
+      namehash('legacy.wrapped-with-subnames.eth'),
+    )
+    expect(checkOwner).toBe(accounts[2])
+
+    await expect(
+      ensInstance.deleteSubname('legacy.wrapped-with-subnames.eth', {
+        contract: 'nameWrapper',
+        method: 'setSubnodeOwner',
+        addressOrIndex: parentOwner,
+      }),
+    ).rejects.toThrow()
+
+    const result = await nameWrapper.ownerOf(
+      namehash('legacy.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe(accounts[2])
+  })
+
   it('should not allow deleting 1LD', async () => {
     await expect(
       ensInstance.deleteSubname('eth', {
         contract: 'nameWrapper',
+        method: 'setRecord',
         addressOrIndex: 1,
       }),
     ).rejects.toThrow()

package/src/functions/deleteSubname.ts

@@ -2,28 +2,34 @@ import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'
 
-type Args = {
+type BaseArgs = {
   contract: 'registry' | 'nameWrapper'
+  method?: 'setRecord' | 'setSubnodeOwner'
 }
 
+type NameWrapperArgs = {
+  contract: 'nameWrapper'
+  method: 'setRecord' | 'setSubnodeOwner'
+}
+
+type Args = BaseArgs | NameWrapperArgs
+
 export default async function (
-  { contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  { contract }: Args,
+  { contract, ...args }: Args,
 ) {
   const labels = name.split('.')
-
   if (labels.length < 3) {
     throw new Error(`${name} is not a valid subname`)
   }
 
-  const label = labels.shift() as string
-  const labelhash = solidityKeccak256(['string'], [label])
-  const parentNodehash = namehash(labels.join('.'))
-
   switch (contract) {
     case 'registry': {
       const registry = (await contracts!.getRegistry()!).connect(signer)
+      const label = labels.shift() as string
+      const labelhash = solidityKeccak256(['string'], [label])
+      const parentNodehash = namehash(labels.join('.'))
 
       return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
@@ -35,13 +41,24 @@ export default async function (
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+      const { method } = args as NameWrapperArgs
+
+      if (method === 'setRecord') {
+        const node = namehash(name)
+        return nameWrapper.populateTransaction.setRecord(
+          node,
+          '0x0000000000000000000000000000000000000000',
+          '0x0000000000000000000000000000000000000000',
+          0,
+        )
+      }
 
-      return nameWrapper.populateTransaction.setSubnodeRecord(
+      const label = labels.shift() as string
+      const parentNodehash = namehash(labels.join('.'))
+      return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,
         label,
         '0x0000000000000000000000000000000000000000',
-        '0x0000000000000000000000000000000000000000',
-        0,
         0,
         0,
       )

package/src/functions/getNames.test.ts

@@ -1,6 +1,7 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
 import { Name } from './getNames'
+import { names as wrappedNames } from '../../deploy/00_register_wrapped'
 
 let ensInstance: ENS
 
@@ -166,13 +167,25 @@ describe('getNames', () => {
     })
     expect(pageFive).toHaveLength(totalOwnedNames % 10)
   })
-  it('should get wrapped domains for an address with pagination', async () => {
+  it('should get wrapped domains for an address with pagination, and filter out pcc expired names', async () => {
     const pageOne = await ensInstance.getNames({
       address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'wrappedOwner',
       page: 0,
     })
-    expect(pageOne).toHaveLength(2)
+
+    const nameCout = wrappedNames.reduce<number>((count, name) => {
+      if (name.namedOwner === 'owner2') count += 1
+      ;(name.subnames || []).forEach((subname: any) => {
+        if (subname.namedOwner === 'owner2') count += 1
+      })
+      return count
+    }, 0)
+
+    // length of page one should be all the names on 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC
+    // minus 1 for the PCC expired name.
+    // the result here implies that the PCC expired name is not returned
+    expect(pageOne).toHaveLength(nameCout - 1)
   })
   describe('orderBy', () => {
     describe('registrations', () => {

package/src/functions/getNames.ts

@@ -1,6 +1,6 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
-import { AllCurrentFuses, decodeFuses } from '../utils/fuses'
+import { AllCurrentFuses, checkPCCBurned, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
 import { Domain, Registration, WrappedDomain } from '../utils/subgraph-types'
 
@@ -60,8 +60,21 @@ type Params = BaseParams &
 
 const mapDomain = ({ name, ...domain }: Domain) => {
   const decrypted = name ? decryptName(name) : undefined
+
   return {
     ...domain,
+    ...(domain.registration
+      ? {
+          registration: {
+            expiryDate: new Date(
+              parseInt(domain.registration.expiryDate) * 1000,
+            ),
+            registrationDate: new Date(
+              parseInt(domain.registration.registrationDate) * 1000,
+            ),
+          },
+        }
+      : {}),
     name: decrypted,
     truncatedName: decrypted ? truncateFormat(decrypted) : undefined,
     createdAt: new Date(parseInt(domain.createdAt) * 1000),
@@ -70,27 +83,27 @@ const mapDomain = ({ name, ...domain }: 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 as string) * 1000,
-      ),
-      registrationDate: new Date(
-        parseInt(domain.registration.registrationDate as string) * 1000,
-      ),
-    }
+  const expiryDate =
+    wrappedDomain.expiryDate && wrappedDomain.expiryDate !== '0'
+      ? new Date(parseInt(wrappedDomain.expiryDate) * 1000)
+      : undefined
+  if (
+    expiryDate &&
+    expiryDate < new Date() &&
+    checkPCCBurned(wrappedDomain.fuses)
+  ) {
+    // PCC was burned previously and now the fuses are expired meaning that the
+    // owner is now 0x0 so we need to filter this out
+    // if a user's local time is out of sync with the blockchain, this could potentially
+    // be incorrect. the likelihood of that happening though is very low, and devs
+    // shouldn't be relying on this value for anything critical anyway.
+    return null
   }
+
+  const domain = mapDomain(wrappedDomain.domain)
+
   return {
-    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1000),
+    expiryDate,
     fuses: decodeFuses(wrappedDomain.fuses),
     ...domain,
     type: 'wrappedDomain',
@@ -156,6 +169,10 @@ const getNames = async (
           domains(first: 1000) {
             ${domainQueryData}
             createdAt
+            registration {
+              registrationDate
+              expiryDate
+            }
           }
           wrappedDomains(first: 1000) {
             expiryDate
@@ -187,6 +204,10 @@ const getNames = async (
             domains(orderBy: $orderBy, orderDirection: $orderDirection) {
               ${domainQueryData}
               createdAt
+              registration {
+                registrationDate
+                expiryDate
+              }
             }
           }
         }
@@ -366,7 +387,8 @@ const getNames = async (
     return [
       ...(account?.domains.map(mapDomain) || []),
       ...(account?.registrations.map(mapRegistration) || []),
-      ...(account?.wrappedDomains.map(mapWrappedDomain) || []),
+      ...(account?.wrappedDomains.map(mapWrappedDomain).filter((d: any) => d) ||
+        []),
     ].sort((a, b) => {
       if (orderDirection === 'desc') {
         if (orderBy === 'labelName') {
@@ -384,7 +406,9 @@ const getNames = async (
     return (account?.domains.map(mapDomain) || []) as Name[]
   }
   if (type === 'wrappedOwner') {
-    return (account?.wrappedDomains.map(mapWrappedDomain) || []) as Name[]
+    return (account?.wrappedDomains
+      .map(mapWrappedDomain)
+      .filter((d: any) => d) || []) as Name[]
   }
   return (account?.registrations.map(mapRegistration) || []) as Name[]
 }