@ensdomains/ensjs 3.0.0-alpha.11 → 3.0.0-alpha.14

package/dist/cjs/index.js

@@ -32,6 +32,7 @@ const getContractAddress_1 = require("./contracts/getContractAddress");
 const GqlManager_1 = __importDefault(require("./GqlManager"));
 const singleCall_1 = __importDefault(require("./utils/singleCall"));
 const writeTx_1 = __importDefault(require("./utils/writeTx"));
+const fuses_1 = __importDefault(require("./utils/fuses"));
 const graphURIEndpoints = {
     1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
     3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -46,6 +47,7 @@ class ENS {
     contracts;
     getContractAddress = getContractAddress_1.getContractAddress;
     gqlInstance = new GqlManager_1.default();
+    fuses = fuses_1.default;
     constructor(options) {
         this.options = options;
         this.getContractAddress = options?.getContractAddress || getContractAddress_1.getContractAddress;
@@ -205,8 +207,6 @@ class ENS {
         'contracts',
     ]);
     getHistory = this.generateFunction('getHistory', ['gqlInstance'], 'getHistory');
-    getHistoryWithDetail = this.generateFunction('getHistory', ['contracts', 'gqlInstance', 'provider'], 'getHistoryWithDetail');
-    getHistoryDetailForTransactionHash = this.generateFunction('getHistory', ['contracts', 'provider'], 'getHistoryDetailForTransactionHash');
     getContentHash = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getContentHash');
     _getContentHash = this.generateRawFunction('initialGetters', ['contracts'], '_getContentHash');
     getAddr = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getAddr');
@@ -218,6 +218,7 @@ class ENS {
     getSubnames = this.generateFunction('initialGetters', ['gqlInstance'], 'getSubnames');
     getNames = this.generateFunction('initialGetters', ['gqlInstance'], 'getNames');
     getPrice = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getPrice');
+    getDNSOwner = this.generateFunction('getDNSOwner', []);
     universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
     resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
     multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
@@ -243,6 +244,10 @@ class ENS {
     createSubname = this.generateWriteFunction('createSubname', ['contracts', 'getExpiry']);
     deleteSubname = this.generateWriteFunction('deleteSubname', ['transferSubname']);
     transferSubname = this.generateWriteFunction('transferSubname', ['contracts', 'getExpiry']);
-    getDNSOwner = this.generateFunction('getDNSOwner', []);
+    commitName = this.generateWriteFunction('commitName', ['contracts']);
+    registerName = this.generateWriteFunction('registerName', ['contracts']);
+    renewName = this.generateWriteFunction('renewName', [
+        'contracts',
+    ]);
 }
 exports.ENS = ENS;

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

@@ -1,20 +1,21 @@
-export declare const testable: {
-    CANNOT_UNWRAP: number;
-    CANNOT_BURN_FUSES: number;
-    CANNOT_TRANSFER: number;
-    CANNOT_SET_RESOLVER: number;
-    CANNOT_SET_TTL: number;
-    CANNOT_CREATE_SUBDOMAIN: number;
-    PARENT_CANNOT_CONTROL: number;
+export declare const fuseEnum: {
+    readonly CANNOT_UNWRAP: 1;
+    readonly CANNOT_BURN_FUSES: 2;
+    readonly CANNOT_TRANSFER: 4;
+    readonly CANNOT_SET_RESOLVER: 8;
+    readonly CANNOT_SET_TTL: 16;
+    readonly CANNOT_CREATE_SUBDOMAIN: 32;
+    readonly PARENT_CANNOT_CONTROL: 64;
 };
-declare const _default: {
+export declare const unnamedFuses: readonly [128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296];
+declare const fullFuseEnum: {
     CAN_DO_EVERYTHING: number;
-    CANNOT_UNWRAP: number;
-    CANNOT_BURN_FUSES: number;
-    CANNOT_TRANSFER: number;
-    CANNOT_SET_RESOLVER: number;
-    CANNOT_SET_TTL: number;
-    CANNOT_CREATE_SUBDOMAIN: number;
-    PARENT_CANNOT_CONTROL: number;
+    CANNOT_UNWRAP: 1;
+    CANNOT_BURN_FUSES: 2;
+    CANNOT_TRANSFER: 4;
+    CANNOT_SET_RESOLVER: 8;
+    CANNOT_SET_TTL: 16;
+    CANNOT_CREATE_SUBDOMAIN: 32;
+    PARENT_CANNOT_CONTROL: 64;
 };
-export default _default;
+export default fullFuseEnum;

package/dist/cjs/utils/fuses.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testable = void 0;
+exports.unnamedFuses = exports.fuseEnum = void 0;
 const CANNOT_UNWRAP = 1;
 const CANNOT_BURN_FUSES = 2;
 const CANNOT_TRANSFER = 4;
@@ -9,7 +9,7 @@ const CANNOT_SET_TTL = 16;
 const CANNOT_CREATE_SUBDOMAIN = 32;
 const PARENT_CANNOT_CONTROL = 64;
 const CAN_DO_EVERYTHING = 0;
-exports.testable = {
+exports.fuseEnum = {
     CANNOT_UNWRAP,
     CANNOT_BURN_FUSES,
     CANNOT_TRANSFER,
@@ -18,7 +18,13 @@ exports.testable = {
     CANNOT_CREATE_SUBDOMAIN,
     PARENT_CANNOT_CONTROL,
 };
-exports.default = {
-    ...exports.testable,
+exports.unnamedFuses = [
+    128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+    524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864,
+    134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296,
+];
+const fullFuseEnum = {
+    ...exports.fuseEnum,
     CAN_DO_EVERYTHING,
 };
+exports.default = fullFuseEnum;

package/dist/cjs/utils/registerHelpers.d.ts

@@ -1,26 +1,54 @@
 import type { FuseOptions } from '../@types/FuseOptions';
 import type { PublicResolver } from '../generated';
 import { RecordOptions } from './recordHelpers';
-export declare const randomSecret: () => string;
-export declare const makeCommitment: ({ name, owner, duration, resolver, records, reverseRecord, fuses, }: {
+export declare type RegistrationParams = {
     name: string;
     owner: string;
     duration: number;
+    secret: string;
     resolver: PublicResolver;
-    records?: RecordOptions | undefined;
-    reverseRecord?: boolean | undefined;
-    fuses?: FuseOptions | undefined;
-}) => {
+    records?: RecordOptions;
+    reverseRecord?: boolean;
+    fuses?: FuseOptions;
+    wrapperExpiry: number;
+};
+export declare type CommitmentParams = Omit<RegistrationParams, 'secret' | 'wrapperExpiry'> & {
+    secret?: string;
+    wrapperExpiry?: number;
+};
+export declare type RegistrationTuple = [
+    name: string,
+    owner: string,
+    duration: number,
+    secret: string,
+    resolver: string,
+    data: string[],
+    reverseRecord: boolean,
+    fuses: string,
+    wrapperExpiry: number
+];
+export declare type CommitmentTuple = [
+    labelhash: string,
+    owner: string,
+    duration: number,
+    resolver: string,
+    data: string[],
+    secret: string,
+    reverseRecord: boolean,
+    fuses: string,
+    wrapperExpiry: number
+];
+export declare const randomSecret: () => string;
+export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }: Omit<RegistrationParams, "secret" | "wrapperExpiry"> & {
+    secret?: string | undefined;
+    wrapperExpiry?: number | undefined;
+} & {
+    secret: string;
+}) => CommitmentTuple;
+export declare const makeRegistrationData: (params: RegistrationParams) => RegistrationTuple;
+export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
     secret: string;
     commitment: string;
+    wrapperExpiry: number;
 };
-export declare const _makeCommitment: ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }: {
-    labelhash: string;
-    owner: string;
-    duration: number;
-    secret: string;
-    resolver: string;
-    data: string[];
-    reverseRecord: boolean;
-    fuses: string;
-}) => string;
+export declare const _makeCommitment: (params: CommitmentTuple) => string;

package/dist/cjs/utils/registerHelpers.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._makeCommitment = exports.makeCommitment = exports.randomSecret = void 0;
+exports._makeCommitment = exports.makeCommitment = exports.makeRegistrationData = exports.makeCommitmentData = exports.randomSecret = void 0;
 const ethers_1 = require("ethers");
 const generateFuseInput_1 = __importDefault(require("./generateFuseInput"));
 const labels_1 = require("./labels");
@@ -14,39 +14,67 @@ const randomSecret = () => {
     return '0x' + crypto.getRandomValues(bytes).toString('hex');
 };
 exports.randomSecret = randomSecret;
-const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
+const makeCommitmentData = ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }) => {
     const label = (0, labels_1.labelhash)(name.split('.')[0]);
     const hash = (0, normalise_1.namehash)(name);
     const resolverAddress = resolver.address;
-    const data = records ? (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver) : [];
-    const secret = (0, exports.randomSecret)();
     const fuseData = fuses ? (0, generateFuseInput_1.default)(fuses) : '0';
-    const commitment = (0, exports._makeCommitment)({
-        labelhash: label,
+    if (reverseRecord) {
+        if (!records) {
+            records = { coinTypes: [{ key: 'ETH', value: owner }] };
+        }
+        else if (!records.coinTypes?.find((c) => c.key === 'ETH')) {
+            if (!records.coinTypes)
+                records.coinTypes = [];
+            records.coinTypes.push({ key: 'ETH', value: owner });
+        }
+    }
+    const data = records ? (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver) : [];
+    return [
+        label,
         owner,
         duration,
-        secret,
-        resolver: resolverAddress,
+        resolverAddress,
         data,
-        reverseRecord: !!reverseRecord,
-        fuses: fuseData,
+        secret,
+        !!reverseRecord,
+        fuseData,
+        wrapperExpiry || Math.floor(Date.now() / 1000) + duration,
+    ];
+};
+exports.makeCommitmentData = makeCommitmentData;
+const makeRegistrationData = (params) => {
+    const commitmentData = (0, exports.makeCommitmentData)(params);
+    commitmentData[0] = params.name.split('.')[0];
+    const secret = commitmentData.splice(5, 1)[0];
+    commitmentData.splice(3, 0, secret);
+    return commitmentData;
+};
+exports.makeRegistrationData = makeRegistrationData;
+const makeCommitment = ({ secret = (0, exports.randomSecret)(), ...inputParams }) => {
+    const generatedParams = (0, exports.makeCommitmentData)({
+        ...inputParams,
+        secret,
     });
+    const commitment = (0, exports._makeCommitment)(generatedParams);
     return {
         secret,
         commitment,
+        wrapperExpiry: generatedParams[8],
     };
 };
 exports.makeCommitment = makeCommitment;
-const _makeCommitment = ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }) => {
-    return ethers_1.utils.solidityKeccak256([
+const _makeCommitment = (params) => {
+    return ethers_1.utils.keccak256(ethers_1.utils.defaultAbiCoder.encode([
         'bytes32',
         'address',
         'uint256',
-        'bytes32',
         'address',
         'bytes[]',
+        'bytes32',
         'bool',
-        'uint96',
-    ], [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses]);
+        'uint32',
+        'uint64',
+    ], params));
 };
 exports._makeCommitment = _makeCommitment;

package/dist/cjs/utils/wrapperExpiry.d.ts

@@ -2,4 +2,4 @@ import { BigNumber } from 'ethers';
 import { ENSArgs } from '..';
 export declare type Expiry = string | number | Date | BigNumber;
 export declare const MAX_EXPIRY: BigNumber;
-export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry | undefined) => Promise<BigNumber>;
+export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry) => Promise<BigNumber>;

package/dist/cjs/utils/writeTx.d.ts

@@ -1,4 +1,21 @@
 import { JsonRpcSigner } from '@ethersproject/providers';
 import type { PopulatedTransaction } from 'ethers';
-declare const _default: (signer: JsonRpcSigner, populate: boolean) => (tx: PopulatedTransaction) => PopulatedTransaction | Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+declare type CustomData = Record<string, any>;
+declare const _default: (signer: JsonRpcSigner, populate: boolean) => ({ customData, ...tx }: PopulatedTransaction) => {
+    to?: string | undefined;
+    from?: string | undefined;
+    nonce?: number | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
+    data?: string | undefined;
+    value?: import("ethers").BigNumber | undefined;
+    chainId?: number | undefined;
+    type?: number | undefined;
+    accessList?: import("ethers/lib/utils").AccessList | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
+    ccipReadEnabled?: boolean | undefined;
+} | Promise<import("@ethersproject/providers").TransactionResponse | (import("@ethersproject/providers").TransactionResponse & {
+    customData: CustomData;
+})>;
 export default _default;

package/dist/cjs/utils/writeTx.js

@@ -1,3 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);
+const withCustomData = (tx, customData) => customData ? { ...tx, customData } : tx;
+exports.default = (signer, populate) => ({ customData, ...tx }) => populate
+    ? withCustomData(tx, customData)
+    : signer.sendTransaction(tx).then((r) => withCustomData(r, customData));

package/dist/esm/contracts/index.d.ts

@@ -5,12 +5,12 @@ export default class ContractManager {
     private fetchAddress;
     constructor(provider: ethers.providers.Provider, fetchAddress: ContractAddressFetch);
     private generateContractGetter;
-    getPublicResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").PublicResolver>;
-    getUniversalResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").UniversalResolver>;
-    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ENSRegistry>;
-    getReverseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ReverseRegistrar>;
-    getNameWrapper: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").NameWrapper>;
-    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").BaseRegistrarImplementation>;
-    getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
-    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").Multicall>;
+    getPublicResolver: (passedProvider?: any, address?: string) => Promise<import("../generated").PublicResolver>;
+    getUniversalResolver: (passedProvider?: any, address?: string) => Promise<import("../generated").UniversalResolver>;
+    getRegistry: (passedProvider?: any, address?: string) => Promise<import("../generated").ENSRegistry>;
+    getReverseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated").ReverseRegistrar>;
+    getNameWrapper: (passedProvider?: any, address?: string) => Promise<import("../generated").NameWrapper>;
+    getBaseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated").BaseRegistrarImplementation>;
+    getEthRegistrarController: (passedProvider?: any, address?: string) => Promise<import("../generated").ETHRegistrarController>;
+    getMulticall: (passedProvider?: any, address?: string) => Promise<import("../generated").Multicall>;
 }

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

@@ -1,5 +1,32 @@
 import { ENSArgs } from '..';
-import { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { fusesToBurn, }: {
-    fusesToBurn: FuseOptions;
-}): Promise<import("ethers").PopulatedTransaction>;
+import { fuseEnum, unnamedFuses } from '../utils/fuses';
+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];
+/**
+ * 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.
+ *
+ * @template A The array to check for duplicates.
+ * @template B The union of all checked existing types.
+ */
+declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities ? A extends [infer Head, ...infer Tail] ? Head extends B ? [
+] : [
+    Head,
+    ...FusesWithoutDuplicates<Tail, Head | B>
+] : A : [
+];
+declare type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
+    namedFusesToBurn: FusesWithoutDuplicates<A>;
+};
+declare type FusePropsUnnamedArray = {
+    unnamedFusesToBurn: UnnamedFuseValues[];
+};
+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 {};

package/dist/esm/functions/burnFuses.js

@@ -1,8 +1,41 @@
-import generateFuseInput from '../utils/generateFuseInput';
+import { fuseEnum, unnamedFuses } from '../utils/fuses';
 import { namehash } from '../utils/normalise';
-export default async function ({ contracts, signer }, name, { fusesToBurn, }) {
+export default async function ({ contracts, signer }, name, props) {
+    const isNumber = 'fuseNumberToBurn' in props;
+    const hasNamedArray = 'namedFusesToBurn' in props;
+    const hasUnnamedArray = 'unnamedFusesToBurn' in props;
+    let encodedFuses = 0;
+    if (isNumber) {
+        if (props.fuseNumberToBurn > 2 ** 32 || props.fuseNumberToBurn < 1) {
+            throw new Error(`Fuse number must be limited to uint32, ${props.fuseNumberToBurn} was too ${props.fuseNumberToBurn < 1 ? 'low' : 'high'}.`);
+        }
+        else if (props.fuseNumberToBurn % 1 !== 0) {
+            throw new Error(`Fuse number must be an integer, ${props.fuseNumberToBurn} was not.`);
+        }
+        encodedFuses = props.fuseNumberToBurn;
+    }
+    else {
+        if (!hasNamedArray && !hasUnnamedArray) {
+            throw new Error('Please provide fuses to burn');
+        }
+        if (hasNamedArray) {
+            for (const fuse of props.namedFusesToBurn) {
+                if (!(fuse in fuseEnum)) {
+                    throw new Error(`${fuse} is not a valid named fuse.`);
+                }
+                encodedFuses |= fuseEnum[fuse];
+            }
+        }
+        if (hasUnnamedArray) {
+            for (const fuse of props.unnamedFusesToBurn) {
+                if (!unnamedFuses.includes(fuse)) {
+                    throw new Error(`${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`);
+                }
+                encodedFuses |= fuse;
+            }
+        }
+    }
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     const hash = namehash(name);
-    const encodedFuses = generateFuseInput(fusesToBurn);
     return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
 }

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

@@ -0,0 +1,26 @@
+import { ENSArgs } from '..';
+import { CommitmentParams } from '../utils/registerHelpers';
+declare type Params = Omit<CommitmentParams, 'resolver' | 'name'> & {
+    resolverAddress?: string;
+};
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, ...params }: Params): Promise<{
+    customData: {
+        secret: string;
+        commitment: string;
+        wrapperExpiry: number;
+    };
+    to?: string | undefined;
+    from?: string | undefined;
+    nonce?: number | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
+    data?: string | undefined;
+    value?: import("ethers").BigNumber | undefined;
+    chainId?: number | undefined;
+    type?: number | undefined;
+    accessList?: import("ethers/lib/utils").AccessList | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
+    ccipReadEnabled?: boolean | undefined;
+}>;
+export {};

package/dist/esm/functions/commitName.js

@@ -0,0 +1,21 @@
+import { makeCommitment } from '../utils/registerHelpers';
+export default async function ({ contracts }, name, { resolverAddress, ...params }) {
+    const labels = name.split('.');
+    if (labels.length !== 2 || labels[1] !== 'eth')
+        throw new Error('Currently only .eth TLD registrations are supported');
+    const controller = await contracts.getEthRegistrarController();
+    const resolver = await contracts.getPublicResolver(undefined, resolverAddress);
+    const { secret, commitment, wrapperExpiry } = makeCommitment({
+        name,
+        resolver,
+        ...params,
+    });
+    return {
+        ...(await controller.populateTransaction.commit(commitment)),
+        customData: {
+            secret,
+            commitment,
+            wrapperExpiry,
+        },
+    };
+}

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

@@ -5,12 +5,13 @@ declare const _default: {
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
         fuseObj: {
             [k: string]: boolean;
         };
         expiryDate: Date;
         rawFuses: BigNumber;
+        owner: any;
     } | undefined>;
 };
 export default _default;

package/dist/esm/functions/getFuses.js

@@ -1,32 +1,21 @@
 import { BigNumber } from 'ethers';
-import { testable as fuseEnums } from '../utils/fuses';
+import { fuseEnum } from '../utils/fuses';
 import { namehash } from '../utils/normalise';
-const NameSafety = [
-    'Safe',
-    'RegistrantNotWrapped',
-    'ControllerNotWrapped',
-    'SubdomainReplacementAllowed',
-    'Expired',
-];
 const raw = async ({ contracts }, name) => {
     const nameWrapper = await contracts?.getNameWrapper();
     return {
         to: nameWrapper.address,
-        data: nameWrapper.interface.encodeFunctionData('getFuses', [
-            namehash(name),
-        ]),
+        data: nameWrapper.interface.encodeFunctionData('getData', [namehash(name)]),
     };
 };
-const decode = async ({ contracts }, data, name) => {
+const decode = async ({ contracts }, data) => {
     const nameWrapper = await contracts?.getNameWrapper();
     try {
-        const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult('getFuses', data);
+        const { owner, fuses: _fuses, expiry, } = nameWrapper.interface.decodeFunctionResult('getData', data);
         const fuses = BigNumber.from(_fuses);
-        const fuseObj = Object.fromEntries(Object.keys(fuseEnums).map((fuseEnum) => [
-            fuseEnum
-                .toLowerCase()
-                .replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace('-', '').replace('_', '')),
-            fuses.and(fuseEnums[fuseEnum]).gt(0),
+        const fuseObj = Object.fromEntries(Object.keys(fuseEnum).map((fuse) => [
+            fuse,
+            fuses.and(fuseEnum[fuse]).gt(0),
         ]));
         if (fuses.eq(0)) {
             fuseObj.canDoEverything = true;
@@ -39,9 +28,11 @@ const decode = async ({ contracts }, data, name) => {
             fuseObj,
             expiryDate,
             rawFuses: fuses,
+            owner,
         };
     }
-    catch {
+    catch (e) {
+        console.error('Error decoding fuses data: ', e);
         return;
     }
 };

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

@@ -22,33 +22,3 @@ export declare function getHistory({ gqlInstance }: ENSArgs<'gqlInstance'>, name
         data: Record<string, any>;
     }[];
 } | undefined>;
-export declare function getHistoryWithDetail({ contracts, gqlInstance, provider, }: ENSArgs<'contracts' | 'gqlInstance' | 'provider'>, name: string): Promise<{
-    domain: {
-        type: any;
-        blockNumber: any;
-        transactionHash: any;
-        id: any;
-        data: Record<string, any>;
-    }[];
-    registration: {
-        type: any;
-        blockNumber: any;
-        transactionHash: any;
-        id: any;
-        data: Record<string, any>;
-    }[];
-    resolver: {
-        type: any;
-        blockNumber: any;
-        transactionHash: any;
-        id: any;
-        data: Record<string, any>;
-    }[];
-} | undefined>;
-export declare function getHistoryDetailForTransactionHash({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, hash: string, indexInTransaction?: number): Promise<({
-    key: any;
-    value: any;
-} | undefined)[] | {
-    key: any;
-    value: any;
-} | undefined>;