@ensdomains/ensjs 3.0.0-alpha.27 → 3.0.0-alpha.29

package/dist/cjs/functions/getNames.js

@@ -22,6 +22,7 @@ __export(getNames_exports, {
 });
 module.exports = __toCommonJS(getNames_exports);
 var import_format = require("../utils/format");
+var import_fuses = require("../utils/fuses");
 var import_labels = require("../utils/labels");
 const mapDomain = (domain) => {
   const decrypted = (0, import_labels.decryptName)(domain.name);
@@ -33,6 +34,15 @@ const mapDomain = (domain) => {
     type: "domain"
   };
 };
+const mapWrappedDomain = (wrappedDomain) => {
+  const domain = mapDomain(wrappedDomain.domain);
+  return {
+    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1e3),
+    fuses: (0, import_fuses.decodeFuses)(wrappedDomain.fuses),
+    ...domain,
+    type: "wrappedDomain"
+  };
+};
 const mapRegistration = (registration) => {
   const decrypted = (0, import_labels.decryptName)(registration.domain.name);
   return {
@@ -87,6 +97,17 @@ const getNames = async ({ gqlInstance }, {
             ${domainQueryData}
             createdAt
           }
+          wrappedDomains(first: 1000) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              registration {
+                registrationDate
+                expiryDate
+              }
+            }
+          }
         }
       }
     `;
@@ -145,6 +166,69 @@ const getNames = async ({ gqlInstance }, {
         orderDirection
       };
     }
+  } else if (type === "wrappedOwner") {
+    if (typeof page !== "number") {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+        $expiryDate: Int
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+            where: { expiryDate_gt: $expiryDate }
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      }
+    `;
+      queryVars = {
+        id: address,
+        expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+      };
+    } else {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $first: Int
+        $skip: Int
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            first: $first
+            skip: $skip
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      }
+    `;
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy,
+        orderDirection
+      };
+    }
   } else if (typeof page !== "number") {
     finalQuery = gqlInstance.gql`
         query getNames(
@@ -214,7 +298,8 @@ const getNames = async ({ gqlInstance }, {
   if (type === "all") {
     return [
       ...account.domains.map(mapDomain),
-      ...account.registrations.map(mapRegistration)
+      ...account.registrations.map(mapRegistration),
+      ...account.wrappedDomains.map(mapWrappedDomain)
     ].sort((a, b) => {
       if (orderDirection === "desc") {
         if (orderBy === "labelName") {
@@ -231,6 +316,9 @@ const getNames = async ({ gqlInstance }, {
   if (type === "owner") {
     return account.domains.map(mapDomain);
   }
+  if (type === "wrappedOwner") {
+    return account.wrappedDomains.map(mapWrappedDomain);
+  }
   return account.registrations.map(mapRegistration);
 };
 var getNames_default = getNames;

package/dist/cjs/functions/getWrapperData.js

@@ -39,17 +39,7 @@ const decode = async ({ contracts }, data) => {
       data
     );
     const fuses = import_ethers.BigNumber.from(_fuses);
-    const fuseObj = Object.fromEntries(
-      Object.keys(import_fuses.fuseEnum).map((fuse) => [
-        fuse,
-        fuses.and(import_fuses.fuseEnum[fuse]).gt(0)
-      ])
-    );
-    if (fuses.eq(0)) {
-      fuseObj.CAN_DO_EVERYTHING = true;
-    } else {
-      fuseObj.CAN_DO_EVERYTHING = false;
-    }
+    const fuseObj = (0, import_fuses.decodeFuses)(fuses);
     const expiryDate = new Date(expiry * 1e3);
     return {
       fuseObj,

package/dist/cjs/utils/fuses.js

@@ -18,12 +18,14 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var fuses_exports = {};
 __export(fuses_exports, {
+  decodeFuses: () => decodeFuses,
   default: () => fuses_default,
   fuseEnum: () => fuseEnum,
   unnamedFuses: () => unnamedFuses,
   validateFuses: () => validateFuses
 });
 module.exports = __toCommonJS(fuses_exports);
+var import_ethers = require("ethers");
 const CANNOT_UNWRAP = 1;
 const CANNOT_BURN_FUSES = 2;
 const CANNOT_TRANSFER = 4;
@@ -114,4 +116,19 @@ const validateFuses = (fuses) => {
   }
   return encodedFuses;
 };
+const decodeFuses = (fuses) => {
+  const bnFuses = import_ethers.BigNumber.from(fuses);
+  const fuseObj = Object.fromEntries(
+    Object.keys(fuseEnum).map((fuse) => [
+      fuse,
+      bnFuses.and(fuseEnum[fuse]).gt(0)
+    ])
+  );
+  if (bnFuses.eq(0)) {
+    fuseObj.CAN_DO_EVERYTHING = true;
+  } else {
+    fuseObj.CAN_DO_EVERYTHING = false;
+  }
+  return fuseObj;
+};
 var fuses_default = fullFuseEnum;

package/dist/cjs/utils/generateFuseInput.js

@@ -30,8 +30,8 @@ module.exports = __toCommonJS(generateFuseInput_exports);
 var import_ethers = require("ethers");
 var import_fuses = __toESM(require("./fuses"));
 var generateFuseInput_default = (fuseOptions) => {
-  const fuseKeys = Object.keys(fuseOptions).filter((opt) => fuseOptions[opt] === true).map(
-    (opt) => opt.split(/(?=[A-Z])/).join("_").toUpperCase()
+  const fuseKeys = Object.keys(fuseOptions).filter(
+    (opt) => fuseOptions[opt] === true
   );
   const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
     return prev.or(import_fuses.default[curr]);

package/dist/esm/functions/getNames.mjs

@@ -1,5 +1,6 @@
 // src/functions/getNames.ts
 import { truncateFormat } from "../utils/format.mjs";
+import { decodeFuses } from "../utils/fuses.mjs";
 import { decryptName } from "../utils/labels.mjs";
 var mapDomain = (domain) => {
   const decrypted = decryptName(domain.name);
@@ -11,6 +12,15 @@ var mapDomain = (domain) => {
     type: "domain"
   };
 };
+var mapWrappedDomain = (wrappedDomain) => {
+  const domain = mapDomain(wrappedDomain.domain);
+  return {
+    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1e3),
+    fuses: decodeFuses(wrappedDomain.fuses),
+    ...domain,
+    type: "wrappedDomain"
+  };
+};
 var mapRegistration = (registration) => {
   const decrypted = decryptName(registration.domain.name);
   return {
@@ -65,6 +75,17 @@ var getNames = async ({ gqlInstance }, {
             ${domainQueryData}
             createdAt
           }
+          wrappedDomains(first: 1000) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              registration {
+                registrationDate
+                expiryDate
+              }
+            }
+          }
         }
       }
     `;
@@ -123,6 +144,69 @@ var getNames = async ({ gqlInstance }, {
         orderDirection
       };
     }
+  } else if (type === "wrappedOwner") {
+    if (typeof page !== "number") {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+        $expiryDate: Int
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+            where: { expiryDate_gt: $expiryDate }
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      }
+    `;
+      queryVars = {
+        id: address,
+        expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+      };
+    } else {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $first: Int
+        $skip: Int
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            first: $first
+            skip: $skip
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      }
+    `;
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy,
+        orderDirection
+      };
+    }
   } else if (typeof page !== "number") {
     finalQuery = gqlInstance.gql`
         query getNames(
@@ -192,7 +276,8 @@ var getNames = async ({ gqlInstance }, {
   if (type === "all") {
     return [
       ...account.domains.map(mapDomain),
-      ...account.registrations.map(mapRegistration)
+      ...account.registrations.map(mapRegistration),
+      ...account.wrappedDomains.map(mapWrappedDomain)
     ].sort((a, b) => {
       if (orderDirection === "desc") {
         if (orderBy === "labelName") {
@@ -209,6 +294,9 @@ var getNames = async ({ gqlInstance }, {
   if (type === "owner") {
     return account.domains.map(mapDomain);
   }
+  if (type === "wrappedOwner") {
+    return account.wrappedDomains.map(mapWrappedDomain);
+  }
   return account.registrations.map(mapRegistration);
 };
 var getNames_default = getNames;

package/dist/esm/functions/getWrapperData.mjs

@@ -1,6 +1,6 @@
 // src/functions/getWrapperData.ts
 import { BigNumber } from "ethers";
-import { fuseEnum } from "../utils/fuses.mjs";
+import { decodeFuses } from "../utils/fuses.mjs";
 import { namehash } from "../utils/normalise.mjs";
 var raw = async ({ contracts }, name) => {
   const nameWrapper = await contracts?.getNameWrapper();
@@ -17,17 +17,7 @@ var decode = async ({ contracts }, data) => {
       data
     );
     const fuses = BigNumber.from(_fuses);
-    const fuseObj = Object.fromEntries(
-      Object.keys(fuseEnum).map((fuse) => [
-        fuse,
-        fuses.and(fuseEnum[fuse]).gt(0)
-      ])
-    );
-    if (fuses.eq(0)) {
-      fuseObj.CAN_DO_EVERYTHING = true;
-    } else {
-      fuseObj.CAN_DO_EVERYTHING = false;
-    }
+    const fuseObj = decodeFuses(fuses);
     const expiryDate = new Date(expiry * 1e3);
     return {
       fuseObj,

package/dist/esm/utils/fuses.mjs

@@ -1,4 +1,5 @@
 // src/utils/fuses.ts
+import { BigNumber } from "ethers";
 var CANNOT_UNWRAP = 1;
 var CANNOT_BURN_FUSES = 2;
 var CANNOT_TRANSFER = 4;
@@ -89,8 +90,24 @@ var validateFuses = (fuses) => {
   }
   return encodedFuses;
 };
+var decodeFuses = (fuses) => {
+  const bnFuses = BigNumber.from(fuses);
+  const fuseObj = Object.fromEntries(
+    Object.keys(fuseEnum).map((fuse) => [
+      fuse,
+      bnFuses.and(fuseEnum[fuse]).gt(0)
+    ])
+  );
+  if (bnFuses.eq(0)) {
+    fuseObj.CAN_DO_EVERYTHING = true;
+  } else {
+    fuseObj.CAN_DO_EVERYTHING = false;
+  }
+  return fuseObj;
+};
 var fuses_default = fullFuseEnum;
 export {
+  decodeFuses,
   fuses_default as default,
   fuseEnum,
   unnamedFuses,

package/dist/esm/utils/generateFuseInput.mjs

@@ -2,8 +2,8 @@
 import { ethers } from "ethers";
 import fuses from "./fuses.mjs";
 var generateFuseInput_default = (fuseOptions) => {
-  const fuseKeys = Object.keys(fuseOptions).filter((opt) => fuseOptions[opt] === true).map(
-    (opt) => opt.split(/(?=[A-Z])/).join("_").toUpperCase()
+  const fuseKeys = Object.keys(fuseOptions).filter(
+    (opt) => fuseOptions[opt] === true
   );
   const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
     return prev.or(fuses[curr]);

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

@@ -1,4 +1,5 @@
 import { ENSArgs } from '..';
+import { CurrentFuses } from '../utils/fuses';
 export declare type Name = {
     id: string;
     labelName: string | null;
@@ -12,11 +13,12 @@ export declare type Name = {
     createdAt?: Date;
     registrationDate?: Date;
     expiryDate?: Date;
-    type: 'domain' | 'registration';
+    fuses?: CurrentFuses;
+    type: 'domain' | 'registration' | 'wrappedDomain';
 };
 declare type BaseParams = {
     address: string;
-    type: 'registrant' | 'owner' | 'all';
+    type: 'registrant' | 'owner' | 'wrappedOwner' | 'all';
     page?: number;
     pageSize?: number;
     orderDirection?: 'asc' | 'desc';
@@ -29,12 +31,16 @@ declare type OwnerParams = {
     type: 'owner';
     orderBy?: 'createdAt' | 'labelName';
 };
+declare type WrappedOwnerParams = {
+    type: 'wrappedOwner';
+    orderBy?: 'expiryDate' | 'labelName';
+};
 declare type AllParams = {
     type: 'all';
     orderBy?: 'labelName' | 'creationDate';
     page?: never;
     pageSize?: never;
 };
-declare type Params = BaseParams & (RegistrantParams | OwnerParams | AllParams);
+declare type Params = BaseParams & (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams);
 declare const getNames: ({ gqlInstance }: ENSArgs<'gqlInstance'>, { address: _address, type, page, pageSize, orderDirection, orderBy, }: Params) => Promise<Name[]>;
 export default getNames;

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

@@ -1,13 +1,12 @@
 import { BigNumber } from 'ethers';
 import { ENSArgs } from '../index';
-import { CurrentFuses } from '../utils/fuses';
 declare const _default: {
     raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
         to: string;
         data: string;
     }>;
     decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
-        fuseObj: CurrentFuses;
+        fuseObj: import("../utils/fuses").CurrentFuses;
         expiryDate: Date;
         rawFuses: BigNumber;
         owner: any;

package/dist/types/index.d.ts

@@ -391,7 +391,7 @@ export declare class ENS {
     }>;
     getNames: (args_0: {
         address: string;
-        type: "owner" | "registrant" | "all";
+        type: "owner" | "wrappedOwner" | "registrant" | "all";
         page?: number | undefined;
         pageSize?: number | undefined;
         orderDirection?: "asc" | "desc" | undefined;
@@ -401,6 +401,9 @@ export declare class ENS {
     } | {
         type: "owner";
         orderBy?: "labelName" | "createdAt" | undefined;
+    } | {
+        type: "wrappedOwner";
+        orderBy?: "expiryDate" | "labelName" | undefined;
     } | {
         type: "all";
         orderBy?: "labelName" | "creationDate" | undefined;

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

@@ -1,3 +1,4 @@
+import { BigNumberish } from 'ethers';
 export declare const fuseEnum: {
     readonly CANNOT_UNWRAP: 1;
     readonly CANNOT_BURN_FUSES: 2;
@@ -53,4 +54,5 @@ export declare type FusePropsNumber = {
 };
 export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
 export declare const validateFuses: (fuses: FuseProps) => number;
+export declare const decodeFuses: (fuses: BigNumberish) => CurrentFuses;
 export default fullFuseEnum;

package/package.json

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

package/src/functions/getNames.test.ts

@@ -89,6 +89,25 @@ describe('getNames', () => {
     )
     testNotProperties(result[0], 'expiryDate', 'registrationDate')
   })
+  it('should get wrapped domains for an address', async () => {
+    const result = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'wrappedOwner',
+    })
+    expect(result).toBeTruthy()
+    testProperties(
+      result[0],
+      'id',
+      'labelName',
+      'labelhash',
+      'name',
+      'isMigrated',
+      'parent',
+      'truncatedName',
+      'expiryDate',
+      'fuses',
+    )
+  })
   it('should get the registrations for an address with pagination', async () => {
     const pageOne = await ensInstance.getNames({
       address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
@@ -147,6 +166,14 @@ describe('getNames', () => {
     })
     expect(pageFive).toHaveLength(totalOwnedNames % 10)
   })
+  it('should get wrapped domains for an address with pagination', async () => {
+    const pageOne = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'wrappedOwner',
+      page: 0,
+    })
+    expect(pageOne).toHaveLength(1)
+  })
   describe('orderBy', () => {
     describe('registrations', () => {
       it('descending registrationDate', async () => {

package/src/functions/getNames.ts

@@ -1,5 +1,6 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
+import { CurrentFuses, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
 
 export type Name = {
@@ -15,12 +16,13 @@ export type Name = {
   createdAt?: Date
   registrationDate?: Date
   expiryDate?: Date
-  type: 'domain' | 'registration'
+  fuses?: CurrentFuses
+  type: 'domain' | 'registration' | 'wrappedDomain'
 }
 
 type BaseParams = {
   address: string
-  type: 'registrant' | 'owner' | 'all'
+  type: 'registrant' | 'owner' | 'wrappedOwner' | 'all'
   page?: number
   pageSize?: number
   orderDirection?: 'asc' | 'desc'
@@ -36,6 +38,11 @@ type OwnerParams = {
   orderBy?: 'createdAt' | 'labelName'
 }
 
+type WrappedOwnerParams = {
+  type: 'wrappedOwner'
+  orderBy?: 'expiryDate' | 'labelName'
+}
+
 type AllParams = {
   type: 'all'
   orderBy?: 'labelName' | 'creationDate'
@@ -43,7 +50,8 @@ type AllParams = {
   pageSize?: never
 }
 
-type Params = BaseParams & (RegistrantParams | OwnerParams | AllParams)
+type Params = BaseParams &
+  (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams)
 
 const mapDomain = (domain: any) => {
   const decrypted = decryptName(domain.name)
@@ -56,6 +64,16 @@ const mapDomain = (domain: any) => {
   }
 }
 
+const mapWrappedDomain = (wrappedDomain: any) => {
+  const domain = mapDomain(wrappedDomain.domain)
+  return {
+    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1000),
+    fuses: decodeFuses(wrappedDomain.fuses),
+    ...domain,
+    type: 'wrappedDomain',
+  }
+}
+
 const mapRegistration = (registration: any) => {
   const decrypted = decryptName(registration.domain.name)
   return {
@@ -116,6 +134,17 @@ const getNames = async (
             ${domainQueryData}
             createdAt
           }
+          wrappedDomains(first: 1000) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              registration {
+                registrationDate
+                expiryDate
+              }
+            }
+          }
         }
       }
     `
@@ -167,6 +196,71 @@ const getNames = async (
         }
       `
 
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy,
+        orderDirection,
+      }
+    }
+  } else if (type === 'wrappedOwner') {
+    if (typeof page !== 'number') {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+        $expiryDate: Int
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+            where: { expiryDate_gt: $expiryDate }
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      }
+    `
+
+      queryVars = {
+        id: address,
+        expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
+      }
+    } else {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $first: Int
+        $skip: Int
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            first: $first
+            skip: $skip
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      }
+    `
+
       queryVars = {
         id: address,
         first: pageSize,
@@ -248,6 +342,7 @@ const getNames = async (
     return [
       ...account.domains.map(mapDomain),
       ...account.registrations.map(mapRegistration),
+      ...account.wrappedDomains.map(mapWrappedDomain),
     ].sort((a, b) => {
       if (orderDirection === 'desc') {
         if (orderBy === 'labelName') {
@@ -264,6 +359,9 @@ const getNames = async (
   if (type === 'owner') {
     return account.domains.map(mapDomain) as Name[]
   }
+  if (type === 'wrappedOwner') {
+    return account.wrappedDomains.map(mapWrappedDomain) as Name[]
+  }
   return account.registrations.map(mapRegistration) as Name[]
 }
 

package/src/functions/getWrapperData.ts

@@ -1,6 +1,6 @@
 import { BigNumber } from 'ethers'
 import { ENSArgs } from '../index'
-import { CurrentFuses, fuseEnum } from '../utils/fuses'
+import { decodeFuses } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 
 const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
@@ -20,24 +20,12 @@ const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
     )
 
     const fuses = BigNumber.from(_fuses)
-
-    const fuseObj = Object.fromEntries(
-      Object.keys(fuseEnum).map((fuse) => [
-        fuse,
-        fuses.and(fuseEnum[fuse as keyof typeof fuseEnum]).gt(0),
-      ]),
-    )
-
-    if (fuses.eq(0)) {
-      fuseObj.CAN_DO_EVERYTHING = true
-    } else {
-      fuseObj.CAN_DO_EVERYTHING = false
-    }
+    const fuseObj = decodeFuses(fuses)
 
     const expiryDate = new Date(expiry * 1000)
 
     return {
-      fuseObj: fuseObj as CurrentFuses,
+      fuseObj,
       expiryDate,
       rawFuses: fuses,
       owner,

package/src/utils/fuses.ts

@@ -1,3 +1,5 @@
+import { BigNumber, BigNumberish } from 'ethers'
+
 const CANNOT_UNWRAP = 1
 const CANNOT_BURN_FUSES = 2
 const CANNOT_TRANSFER = 4
@@ -134,4 +136,23 @@ export const validateFuses = (fuses: FuseProps) => {
   return encodedFuses
 }
 
+export const decodeFuses = (fuses: BigNumberish) => {
+  const bnFuses = BigNumber.from(fuses)
+
+  const fuseObj = Object.fromEntries(
+    Object.keys(fuseEnum).map((fuse) => [
+      fuse,
+      bnFuses.and(fuseEnum[fuse as keyof typeof fuseEnum]).gt(0),
+    ]),
+  )
+
+  if (bnFuses.eq(0)) {
+    fuseObj.CAN_DO_EVERYTHING = true
+  } else {
+    fuseObj.CAN_DO_EVERYTHING = false
+  }
+
+  return fuseObj as CurrentFuses
+}
+
 export default fullFuseEnum

package/src/utils/generateFuseInput.ts

@@ -3,14 +3,10 @@ import { FuseOptions } from '../@types/FuseOptions'
 import fuses from './fuses'
 
 export default (fuseOptions: FuseOptions) => {
-  const fuseKeys = Object.keys(fuseOptions)
-    .filter((opt) => fuseOptions[opt as keyof FuseOptions] === true)
-    .map((opt) =>
-      opt
-        .split(/(?=[A-Z])/)
-        .join('_')
-        .toUpperCase(),
-    )
+  const fuseKeys = Object.keys(fuseOptions).filter(
+    (opt) => fuseOptions[opt as keyof FuseOptions] === true,
+  )
+
   const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
     return prev.or(fuses[curr as keyof typeof fuses])
   }, ethers.BigNumber.from(0))