@ensdomains/ensjs 3.0.0-alpha.16 → 3.0.0-alpha.17

package/dist/cjs/functions/burnFuses.d.ts

@@ -4,7 +4,7 @@ declare type FuseObj = typeof fuseEnum;
 declare type UnnamedFuseType = typeof unnamedFuses;
 declare type Fuse = keyof FuseObj;
 declare type UnnamedFuseValues = UnnamedFuseType[number];
-declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
+export declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
 /**
  * This type creates a type error if there are any duplicate fuses.
  * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
@@ -18,15 +18,16 @@ declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibili
     ...FusesWithoutDuplicates<Tail, Head | B>
 ] : A : [
 ];
-declare type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
-    namedFusesToBurn: FusesWithoutDuplicates<A>;
+export declare type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>;
+export declare type FusePropsNamedArray = {
+    namedFusesToBurn: NamedFusesToBurn;
 };
-declare type FusePropsUnnamedArray = {
+export declare type FusePropsUnnamedArray = {
     unnamedFusesToBurn: UnnamedFuseValues[];
 };
-declare type FusePropsNumber = {
+export declare type FusePropsNumber = {
     fuseNumberToBurn: number;
 };
-declare type FuseProps<A extends FuseArrayPossibilities> = (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray) | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
-export default function <A extends FuseArrayPossibilities>({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps<A>): Promise<import("ethers").PopulatedTransaction>;
+export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("ethers").PopulatedTransaction>;
 export {};

package/dist/cjs/functions/getFuses.js

@@ -20,10 +20,10 @@ const decode = async ({ contracts }, data) => {
             fuses.and(fuses_1.fuseEnum[fuse]).gt(0),
         ]));
         if (fuses.eq(0)) {
-            fuseObj.canDoEverything = true;
+            fuseObj.CAN_DO_EVERYTHING = true;
         }
         else {
-            fuseObj.canDoEverything = false;
+            fuseObj.CAN_DO_EVERYTHING = false;
         }
         const expiryDate = new Date(expiry * 1000);
         return {

package/dist/cjs/functions/getOwner.js

@@ -102,7 +102,8 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
         if (labels.length > 2 &&
             ethers_1.ethers.utils.hexStripZeros(registryOwner) !== '0x') {
             // this means that the subname is wrapped
-            if (registryOwner === nameWrapper.address) {
+            if (registryOwner === nameWrapper.address &&
+                ethers_1.ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x') {
                 return {
                     owner: nameWrapperOwner,
                     ownershipLevel: 'nameWrapper',
@@ -121,7 +122,8 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
     // there will only ever be an owner for non .eth names, not a registrant
     // this is because for unwrapped names, there is no associated NFT
     // and for wrapped names, owner and registrant are the same thing
-    if (registryOwner == nameWrapper.address) {
+    if (registryOwner == nameWrapper.address &&
+        ethers_1.ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x') {
         return {
             owner: nameWrapperOwner,
             ownershipLevel: 'nameWrapper',

package/dist/cjs/index.d.ts

@@ -18,6 +18,9 @@ import type transferSubname from './functions/transferSubname';
 import type unwrapName from './functions/unwrapName';
 import type wrapName from './functions/wrapName';
 import GqlManager from './GqlManager';
+import fuseEnum from './utils/fuses';
+export type { FusePropsNamedArray, FusePropsUnnamedArray, FusePropsNumber, FuseProps, NamedFusesToBurn } from './functions/burnFuses';
+export declare type FuseEnum = typeof fuseEnum;
 declare type ENSOptions = {
     graphURI?: string | null;
     getContractAddress?: typeof _getContractAddress;
@@ -464,4 +467,3 @@ export declare class ENS {
     registerName: WriteFunction<typeof registerName>;
     renewName: WriteFunction<typeof renewName>;
 }
-export {};

package/dist/esm/functions/burnFuses.d.ts

@@ -4,7 +4,7 @@ declare type FuseObj = typeof fuseEnum;
 declare type UnnamedFuseType = typeof unnamedFuses;
 declare type Fuse = keyof FuseObj;
 declare type UnnamedFuseValues = UnnamedFuseType[number];
-declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
+export declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
 /**
  * This type creates a type error if there are any duplicate fuses.
  * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
@@ -18,15 +18,16 @@ declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibili
     ...FusesWithoutDuplicates<Tail, Head | B>
 ] : A : [
 ];
-declare type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
-    namedFusesToBurn: FusesWithoutDuplicates<A>;
+export declare type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>;
+export declare type FusePropsNamedArray = {
+    namedFusesToBurn: NamedFusesToBurn;
 };
-declare type FusePropsUnnamedArray = {
+export declare type FusePropsUnnamedArray = {
     unnamedFusesToBurn: UnnamedFuseValues[];
 };
-declare type FusePropsNumber = {
+export declare type FusePropsNumber = {
     fuseNumberToBurn: number;
 };
-declare type FuseProps<A extends FuseArrayPossibilities> = (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray) | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
-export default function <A extends FuseArrayPossibilities>({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps<A>): Promise<import("ethers").PopulatedTransaction>;
+export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("ethers").PopulatedTransaction>;
 export {};

package/dist/esm/functions/getFuses.js

@@ -18,10 +18,10 @@ const decode = async ({ contracts }, data) => {
             fuses.and(fuseEnum[fuse]).gt(0),
         ]));
         if (fuses.eq(0)) {
-            fuseObj.canDoEverything = true;
+            fuseObj.CAN_DO_EVERYTHING = true;
         }
         else {
-            fuseObj.canDoEverything = false;
+            fuseObj.CAN_DO_EVERYTHING = false;
         }
         const expiryDate = new Date(expiry * 1000);
         return {

package/dist/esm/functions/getOwner.js

@@ -100,7 +100,8 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
         if (labels.length > 2 &&
             ethers.utils.hexStripZeros(registryOwner) !== '0x') {
             // this means that the subname is wrapped
-            if (registryOwner === nameWrapper.address) {
+            if (registryOwner === nameWrapper.address &&
+                ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x') {
                 return {
                     owner: nameWrapperOwner,
                     ownershipLevel: 'nameWrapper',
@@ -119,7 +120,8 @@ const decode = async ({ contracts, multicallWrapper }, data, name, contract) =>
     // there will only ever be an owner for non .eth names, not a registrant
     // this is because for unwrapped names, there is no associated NFT
     // and for wrapped names, owner and registrant are the same thing
-    if (registryOwner == nameWrapper.address) {
+    if (registryOwner == nameWrapper.address &&
+        ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x') {
         return {
             owner: nameWrapperOwner,
             ownershipLevel: 'nameWrapper',

package/dist/esm/index.d.ts

@@ -18,6 +18,9 @@ import type transferSubname from './functions/transferSubname';
 import type unwrapName from './functions/unwrapName';
 import type wrapName from './functions/wrapName';
 import GqlManager from './GqlManager';
+import fuseEnum from './utils/fuses';
+export type { FusePropsNamedArray, FusePropsUnnamedArray, FusePropsNumber, FuseProps, NamedFusesToBurn } from './functions/burnFuses';
+export declare type FuseEnum = typeof fuseEnum;
 declare type ENSOptions = {
     graphURI?: string | null;
     getContractAddress?: typeof _getContractAddress;
@@ -464,4 +467,3 @@ export declare class ENS {
     registerName: WriteFunction<typeof registerName>;
     renewName: WriteFunction<typeof renewName>;
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.16",
+  "version": "3.0.0-alpha.17",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",
@@ -69,6 +69,7 @@
   },
   "scripts": {
     "tenv": "ens-test-env -a",
+    "denv": "pnpm tenv start -ns -nb",
     "generate-types": "ts-node scripts/runTypechain.ts",
     "generate-abis": "hardhat export-abi",
     "start": "ts-node --files src/index.test.ts",

package/src/functions/burnFuses.ts

@@ -5,11 +5,10 @@ import { namehash } from '../utils/normalise'
 type FuseObj = typeof fuseEnum
 type UnnamedFuseType = typeof unnamedFuses
 type Fuse = keyof FuseObj
-type NamedFuseValues = FuseObj[Fuse]
 type UnnamedFuseValues = UnnamedFuseType[number]
 
 // We need this type so that the following type isn't infinite. This type limits the max length of the fuse array to 7.
-type FuseArrayPossibilities =
+export type FuseArrayPossibilities =
   | [Fuse]
   | [Fuse, Fuse]
   | [Fuse, Fuse, Fuse]
@@ -40,27 +39,29 @@ type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities
   : // CLAUSE A > FALSE: Return an empty array as it isn't a fuse tuple.
     []
 
-type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
-  namedFusesToBurn: FusesWithoutDuplicates<A>
+export type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>
+
+export type FusePropsNamedArray = {
+  namedFusesToBurn: NamedFusesToBurn 
 }
 
-type FusePropsUnnamedArray = {
+export type FusePropsUnnamedArray = {
   unnamedFusesToBurn: UnnamedFuseValues[]
 }
 
-type FusePropsNumber = {
+export type FusePropsNumber = {
   fuseNumberToBurn: number
 }
 
-type FuseProps<A extends FuseArrayPossibilities> =
-  | (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray)
-  | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>)
+export type FuseProps =
+  | (Partial<FusePropsNamedArray> & FusePropsUnnamedArray)
+  | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>)
   | FusePropsNumber
 
-export default async function <A extends FuseArrayPossibilities>(
+export default async function (
   { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  props: FuseProps<A>,
+  props: FuseProps,
 ) {
   const isNumber = 'fuseNumberToBurn' in props
   const hasNamedArray = 'namedFusesToBurn' in props

package/src/functions/getFuses.test.ts

@@ -19,7 +19,7 @@ const unwrappedNameDefault = {
     CANNOT_TRANSFER: false,
     CANNOT_UNWRAP: false,
     PARENT_CANNOT_CONTROL: false,
-    canDoEverything: true,
+    CAN_DO_EVERYTHING: true,
   },
   owner: '0x0000000000000000000000000000000000000000',
   rawFuses: BigNumber.from(0),
@@ -48,12 +48,12 @@ describe('getFuses', () => {
       unwrappedNameDefault,
     )
   })
-  it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
+  it('should return with CAN_DO_EVERYTHING set to true for a name with no fuses burned', async () => {
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
     const result = await ENSInstance.getFuses('test.wrapped-with-subnames.eth')
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.fuseObj.canDoEverything).toBe(true)
+      expect(result.fuseObj.CAN_DO_EVERYTHING).toBe(true)
       expect(
         Object.values(result.fuseObj).reduce(
           (prev, curr) => (curr ? prev + 1 : prev),
@@ -85,7 +85,7 @@ describe('getFuses', () => {
         CANNOT_SET_TTL: true,
         CANNOT_CREATE_SUBDOMAIN: true,
         PARENT_CANNOT_CONTROL: true,
-        canDoEverything: false,
+        CAN_DO_EVERYTHING: false,
       })
       expect(result.rawFuses.toHexString()).toBe('0x71')
     }

package/src/functions/getFuses.ts

@@ -33,9 +33,9 @@ const decode = async (
     )
 
     if (fuses.eq(0)) {
-      fuseObj.canDoEverything = true
+      fuseObj.CAN_DO_EVERYTHING = true
     } else {
-      fuseObj.canDoEverything = false
+      fuseObj.CAN_DO_EVERYTHING = false
     }
 
     const expiryDate = new Date(expiry * 1000)

package/src/functions/getOwner.test.ts

@@ -55,4 +55,17 @@ describe('getOwner', () => {
     expect(result?.ownershipLevel).toBe('registry')
     expect(result?.owner).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
   })
+  it('should return registry ownership for a pseudo-wrapped name', async () => {
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()
+    const tx = await ENSInstance.transferSubname('test.with-subnames.eth', {
+      contract: 'registry',
+      owner: nameWrapper.address,
+      addressOrIndex: 1,
+    })
+    await tx.wait()
+
+    const result = await ENSInstance.getOwner('test.with-subnames.eth')
+    expect(result?.ownershipLevel).toBe('registry')
+    expect(result?.owner).toBe(nameWrapper.address)
+  })
 })

package/src/functions/getOwner.ts

@@ -161,7 +161,10 @@ const decode = async (
       ethers.utils.hexStripZeros(registryOwner) !== '0x'
     ) {
       // this means that the subname is wrapped
-      if (registryOwner === nameWrapper.address) {
+      if (
+        registryOwner === nameWrapper.address &&
+        ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x'
+      ) {
         return {
           owner: nameWrapperOwner,
           ownershipLevel: 'nameWrapper',
@@ -181,7 +184,10 @@ const decode = async (
   // there will only ever be an owner for non .eth names, not a registrant
   // this is because for unwrapped names, there is no associated NFT
   // and for wrapped names, owner and registrant are the same thing
-  if (registryOwner == nameWrapper.address) {
+  if (
+    registryOwner == nameWrapper.address &&
+    ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x'
+  ) {
     return {
       owner: nameWrapperOwner,
       ownershipLevel: 'nameWrapper',

package/src/index.ts

@@ -48,6 +48,9 @@ import singleCall from './utils/singleCall'
 import writeTx from './utils/writeTx'
 import fuseEnum from './utils/fuses'
 
+export type { FusePropsNamedArray, FusePropsUnnamedArray, FusePropsNumber, FuseProps, NamedFusesToBurn } from './functions/burnFuses'
+export type FuseEnum = typeof fuseEnum 
+
 type ENSOptions = {
   graphURI?: string | null
   getContractAddress?: typeof _getContractAddress