@ensdomains/ensjs 3.0.0-alpha.22 → 3.0.0-alpha.24

package/dist/esm/utils/fuses.mjs

@@ -48,9 +48,51 @@ var fullFuseEnum = {
   ...fuseEnum,
   CAN_DO_EVERYTHING
 };
+var validateFuses = (fuses) => {
+  const isNumber = "fuseNumberToBurn" in fuses;
+  const hasNamedArray = "namedFusesToBurn" in fuses;
+  const hasUnnamedArray = "unnamedFusesToBurn" in fuses;
+  let encodedFuses = 0;
+  if (isNumber) {
+    if (fuses.fuseNumberToBurn > 2 ** 32 || fuses.fuseNumberToBurn < 1) {
+      throw new Error(
+        `Fuse number must be limited to uint32, ${fuses.fuseNumberToBurn} was too ${fuses.fuseNumberToBurn < 1 ? "low" : "high"}.`
+      );
+    } else if (fuses.fuseNumberToBurn % 1 !== 0) {
+      throw new Error(
+        `Fuse number must be an integer, ${fuses.fuseNumberToBurn} was not.`
+      );
+    }
+    encodedFuses = fuses.fuseNumberToBurn;
+  } else {
+    if (!hasNamedArray && !hasUnnamedArray) {
+      throw new Error("Please provide fuses to burn");
+    }
+    if (hasNamedArray) {
+      for (const fuse of fuses.namedFusesToBurn) {
+        if (!(fuse in fuseEnum)) {
+          throw new Error(`${fuse} is not a valid named fuse.`);
+        }
+        encodedFuses |= fuseEnum[fuse];
+      }
+    }
+    if (hasUnnamedArray) {
+      for (const fuse of fuses.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;
+      }
+    }
+  }
+  return encodedFuses;
+};
 var fuses_default = fullFuseEnum;
 export {
   fuses_default as default,
   fuseEnum,
-  unnamedFuses
+  unnamedFuses,
+  validateFuses
 };

package/dist/esm/utils/recordHelpers.mjs

@@ -46,6 +46,11 @@ function generateSingleRecordCall(namehash, resolver, type) {
 }
 var generateRecordCallArray = (namehash, records, resolver) => {
   const calls = [];
+  if (records.clearRecords) {
+    calls.push(
+      resolver.interface.encodeFunctionData("clearRecords", [namehash])
+    );
+  }
   if (records.contentHash) {
     const data = generateSingleRecordCall(
       namehash,

package/dist/esm/utils/registerHelpers.mjs

@@ -88,6 +88,7 @@ var makeCommitment = ({
   };
 };
 export {
+  MAX_INT_64,
   _makeCommitment,
   makeCommitment,
   makeCommitmentData,

package/dist/esm/utils/{wrapperExpiry.mjs → wrapper.mjs}

@@ -1,5 +1,6 @@
-// src/utils/wrapperExpiry.ts
+// src/utils/wrapper.ts
 import { BigNumber } from "ethers";
+import { toUtf8Bytes } from "ethers/lib/utils.js";
 var MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1);
 var makeExpiry = async ({ getExpiry }, name, expiry) => {
   if (expiry) {
@@ -19,7 +20,13 @@ var makeExpiry = async ({ getExpiry }, name, expiry) => {
   }
   return MAX_EXPIRY;
 };
+var wrappedLabelLengthCheck = (label) => {
+  const bytes = toUtf8Bytes(label);
+  if (bytes.byteLength > 255)
+    throw new Error("Label can't be longer than 255 bytes");
+};
 export {
   MAX_EXPIRY,
-  makeExpiry
+  makeExpiry,
+  wrappedLabelLengthCheck
 };

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

@@ -1,13 +1,3 @@
 import { ENSArgs } from '..';
-import { NamedFusesToBurn, UnnamedFuseValues } from '../utils/fuses';
-export declare type FusePropsNamedArray = {
-    namedFusesToBurn: NamedFusesToBurn;
-};
-export declare type FusePropsUnnamedArray = {
-    unnamedFusesToBurn: UnnamedFuseValues[];
-};
-export declare type FusePropsNumber = {
-    fuseNumberToBurn: number;
-};
-export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+import { FuseProps } from '../utils/fuses';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("ethers").PopulatedTransaction>;

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

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
-import { Expiry } from '../utils/wrapperExpiry';
+import { Expiry } from '../utils/wrapper';
 declare type BaseArgs = {
     owner: string;
     resolverAddress?: string;

package/dist/types/functions/{getFuses.d.ts → getWrapperData.d.ts}

@@ -1,5 +1,5 @@
 import { BigNumber } from 'ethers';
-import { ENSArgs } from '..';
+import { ENSArgs } from '../index';
 import { CurrentFuses } from '../utils/fuses';
 declare const _default: {
     raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{

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

@@ -1,6 +1,13 @@
-import { BigNumber } from 'ethers';
+import { BigNumber, BigNumberish } from 'ethers';
 import { ENSArgs } from '..';
-export default function ({ contracts }: ENSArgs<'contracts'>, nameOrNames: string | string[], { duration, value, }: {
+import { FuseProps } from '../utils/fuses';
+declare type BaseProps = {
     duration: number;
     value: BigNumber;
+};
+export declare function renewNameWithData({ contracts }: ENSArgs<'contracts'>, name: string, { duration, value, fuses, wrapperExpiry, }: BaseProps & {
+    fuses?: FuseProps;
+    wrapperExpiry?: BigNumberish;
 }): Promise<import("ethers").PopulatedTransaction>;
+export default function ({ contracts }: ENSArgs<'contracts'>, nameOrNames: string | string[], { duration, value }: BaseProps): Promise<import("ethers").PopulatedTransaction>;
+export {};

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

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, isOwner, }: {
+    newOwner: string;
+    isOwner: boolean;
+}): Promise<ethers.PopulatedTransaction>;

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

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
-import { Expiry } from '../utils/wrapperExpiry';
+import { Expiry } from '../utils/wrapper';
 declare type BaseArgs = {
     owner: string;
     resolverAddress?: string;

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

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import type { FuseOptions } from '../@types/FuseOptions';
-import { Expiry } from '../utils/wrapperExpiry';
+import { Expiry } from '../utils/wrapper';
 export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { wrappedOwner, fuseOptions, expiry, resolverAddress, }: {
     wrappedOwner: string;
     fuseOptions?: FuseOptions | string | number;

package/dist/types/generated/ETHRegistrarController.d.ts

@@ -24,8 +24,10 @@ export interface ETHRegistrarControllerInterface extends utils.Interface {
         "nameWrapper()": FunctionFragment;
         "owner()": FunctionFragment;
         "prices()": FunctionFragment;
+        "recoverFunds(address,address,uint256)": FunctionFragment;
         "register(string,address,uint256,bytes32,address,bytes[],bool,uint32,uint64)": FunctionFragment;
         "renew(string,uint256)": FunctionFragment;
+        "renewWithFuses(string,uint256,uint32,uint64)": FunctionFragment;
         "renounceOwnership()": FunctionFragment;
         "rentPrice(string,uint256)": FunctionFragment;
         "reverseRegistrar()": FunctionFragment;
@@ -34,7 +36,7 @@ export interface ETHRegistrarControllerInterface extends utils.Interface {
         "valid(string)": FunctionFragment;
         "withdraw()": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "MIN_REGISTRATION_DURATION" | "available" | "commit" | "commitments" | "makeCommitment" | "maxCommitmentAge" | "minCommitmentAge" | "nameWrapper" | "owner" | "prices" | "register" | "renew" | "renounceOwnership" | "rentPrice" | "reverseRegistrar" | "supportsInterface" | "transferOwnership" | "valid" | "withdraw"): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: "MIN_REGISTRATION_DURATION" | "available" | "commit" | "commitments" | "makeCommitment" | "maxCommitmentAge" | "minCommitmentAge" | "nameWrapper" | "owner" | "prices" | "recoverFunds" | "register" | "renew" | "renewWithFuses" | "renounceOwnership" | "rentPrice" | "reverseRegistrar" | "supportsInterface" | "transferOwnership" | "valid" | "withdraw"): FunctionFragment;
     encodeFunctionData(functionFragment: "MIN_REGISTRATION_DURATION", values?: undefined): string;
     encodeFunctionData(functionFragment: "available", values: [PromiseOrValue<string>]): string;
     encodeFunctionData(functionFragment: "commit", values: [PromiseOrValue<BytesLike>]): string;
@@ -55,6 +57,11 @@ export interface ETHRegistrarControllerInterface extends utils.Interface {
     encodeFunctionData(functionFragment: "nameWrapper", values?: undefined): string;
     encodeFunctionData(functionFragment: "owner", values?: undefined): string;
     encodeFunctionData(functionFragment: "prices", values?: undefined): string;
+    encodeFunctionData(functionFragment: "recoverFunds", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
     encodeFunctionData(functionFragment: "register", values: [
         PromiseOrValue<string>,
         PromiseOrValue<string>,
@@ -67,6 +74,12 @@ export interface ETHRegistrarControllerInterface extends utils.Interface {
         PromiseOrValue<BigNumberish>
     ]): string;
     encodeFunctionData(functionFragment: "renew", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "renewWithFuses", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
     encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
     encodeFunctionData(functionFragment: "rentPrice", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: "reverseRegistrar", values?: undefined): string;
@@ -84,8 +97,10 @@ export interface ETHRegistrarControllerInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "nameWrapper", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "prices", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recoverFunds", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "register", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "renew", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renewWithFuses", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "rentPrice", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "reverseRegistrar", data: BytesLike): Result;
@@ -168,12 +183,18 @@ export interface ETHRegistrarController extends BaseContract {
         nameWrapper(overrides?: CallOverrides): Promise<[string]>;
         owner(overrides?: CallOverrides): Promise<[string]>;
         prices(overrides?: CallOverrides): Promise<[string]>;
+        recoverFunds(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
         register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
         renew(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
+        renewWithFuses(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
         renounceOwnership(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
@@ -204,12 +225,18 @@ export interface ETHRegistrarController extends BaseContract {
     nameWrapper(overrides?: CallOverrides): Promise<string>;
     owner(overrides?: CallOverrides): Promise<string>;
     prices(overrides?: CallOverrides): Promise<string>;
+    recoverFunds(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
     register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
     renew(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
+    renewWithFuses(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
     renounceOwnership(overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
@@ -234,8 +261,10 @@ export interface ETHRegistrarController extends BaseContract {
         nameWrapper(overrides?: CallOverrides): Promise<string>;
         owner(overrides?: CallOverrides): Promise<string>;
         prices(overrides?: CallOverrides): Promise<string>;
+        recoverFunds(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
         register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
         renew(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        renewWithFuses(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
         renounceOwnership(overrides?: CallOverrides): Promise<void>;
         rentPrice(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<IPriceOracle.PriceStructOutput>;
         reverseRegistrar(overrides?: CallOverrides): Promise<string>;
@@ -265,12 +294,18 @@ export interface ETHRegistrarController extends BaseContract {
         nameWrapper(overrides?: CallOverrides): Promise<BigNumber>;
         owner(overrides?: CallOverrides): Promise<BigNumber>;
         prices(overrides?: CallOverrides): Promise<BigNumber>;
+        recoverFunds(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
         register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
         renew(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
+        renewWithFuses(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
         renounceOwnership(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
@@ -298,12 +333,18 @@ export interface ETHRegistrarController extends BaseContract {
         nameWrapper(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         prices(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recoverFunds(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
         register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
         renew(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
+        renewWithFuses(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
         renounceOwnership(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;