@ensdomains/ensjs 3.0.0-alpha.2 → 3.0.0-alpha.20

package/dist/types/generated/factories/index.d.ts

@@ -0,0 +1,20 @@
+export { BaseRegistrarImplementation__factory } from "./BaseRegistrarImplementation__factory";
+export { DNSRegistrar__factory } from "./DNSRegistrar__factory";
+export { DNSSECImpl__factory } from "./DNSSECImpl__factory";
+export { DefaultReverseResolver__factory } from "./DefaultReverseResolver__factory";
+export { ENSRegistry__factory } from "./ENSRegistry__factory";
+export { ETHRegistrarController__factory } from "./ETHRegistrarController__factory";
+export { Multicall__factory } from "./Multicall__factory";
+export { NameWrapper__factory } from "./NameWrapper__factory";
+export { P256SHA256Algorithm__factory } from "./P256SHA256Algorithm__factory";
+export { PublicResolver__factory } from "./PublicResolver__factory";
+export { RSASHA1Algorithm__factory } from "./RSASHA1Algorithm__factory";
+export { RSASHA256Algorithm__factory } from "./RSASHA256Algorithm__factory";
+export { ReverseRegistrar__factory } from "./ReverseRegistrar__factory";
+export { Root__factory } from "./Root__factory";
+export { SHA1Digest__factory } from "./SHA1Digest__factory";
+export { SHA1NSEC3Digest__factory } from "./SHA1NSEC3Digest__factory";
+export { SHA256Digest__factory } from "./SHA256Digest__factory";
+export { StaticMetadataService__factory } from "./StaticMetadataService__factory";
+export { TLDPublicSuffixList__factory } from "./TLDPublicSuffixList__factory";
+export { UniversalResolver__factory } from "./UniversalResolver__factory";

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

@@ -0,0 +1,41 @@
+export type { BaseRegistrarImplementation } from "./BaseRegistrarImplementation";
+export type { DNSRegistrar } from "./DNSRegistrar";
+export type { DNSSECImpl } from "./DNSSECImpl";
+export type { DefaultReverseResolver } from "./DefaultReverseResolver";
+export type { ENSRegistry } from "./ENSRegistry";
+export type { ETHRegistrarController } from "./ETHRegistrarController";
+export type { Multicall } from "./Multicall";
+export type { NameWrapper } from "./NameWrapper";
+export type { P256SHA256Algorithm } from "./P256SHA256Algorithm";
+export type { PublicResolver } from "./PublicResolver";
+export type { RSASHA1Algorithm } from "./RSASHA1Algorithm";
+export type { RSASHA256Algorithm } from "./RSASHA256Algorithm";
+export type { ReverseRegistrar } from "./ReverseRegistrar";
+export type { Root } from "./Root";
+export type { SHA1Digest } from "./SHA1Digest";
+export type { SHA1NSEC3Digest } from "./SHA1NSEC3Digest";
+export type { SHA256Digest } from "./SHA256Digest";
+export type { StaticMetadataService } from "./StaticMetadataService";
+export type { TLDPublicSuffixList } from "./TLDPublicSuffixList";
+export type { UniversalResolver } from "./UniversalResolver";
+export * as factories from "./factories";
+export { BaseRegistrarImplementation__factory } from "./factories/BaseRegistrarImplementation__factory";
+export { DefaultReverseResolver__factory } from "./factories/DefaultReverseResolver__factory";
+export { DNSRegistrar__factory } from "./factories/DNSRegistrar__factory";
+export { DNSSECImpl__factory } from "./factories/DNSSECImpl__factory";
+export { ENSRegistry__factory } from "./factories/ENSRegistry__factory";
+export { ETHRegistrarController__factory } from "./factories/ETHRegistrarController__factory";
+export { P256SHA256Algorithm__factory } from "./factories/P256SHA256Algorithm__factory";
+export { PublicResolver__factory } from "./factories/PublicResolver__factory";
+export { ReverseRegistrar__factory } from "./factories/ReverseRegistrar__factory";
+export { Root__factory } from "./factories/Root__factory";
+export { RSASHA1Algorithm__factory } from "./factories/RSASHA1Algorithm__factory";
+export { RSASHA256Algorithm__factory } from "./factories/RSASHA256Algorithm__factory";
+export { SHA1Digest__factory } from "./factories/SHA1Digest__factory";
+export { SHA1NSEC3Digest__factory } from "./factories/SHA1NSEC3Digest__factory";
+export { SHA256Digest__factory } from "./factories/SHA256Digest__factory";
+export { TLDPublicSuffixList__factory } from "./factories/TLDPublicSuffixList__factory";
+export { Multicall__factory } from "./factories/Multicall__factory";
+export { NameWrapper__factory } from "./factories/NameWrapper__factory";
+export { StaticMetadataService__factory } from "./factories/StaticMetadataService__factory";
+export { UniversalResolver__factory } from "./factories/UniversalResolver__factory";

package/dist/{esm → types}/index.d.ts

@@ -1,8 +1,24 @@
-import { ethers } from 'ethers';
-import ContractManager from './contracts';
+import type { JsonRpcSigner } from '@ethersproject/providers';
+import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
+import ContractManager from './contracts/index';
 import { SupportedNetworkId } from './contracts/types';
+import type burnFuses from './functions/burnFuses';
+import type commitName from './functions/commitName';
+import type createSubname from './functions/createSubname';
+import type deleteSubname from './functions/deleteSubname';
+import type registerName from './functions/registerName';
+import type renewName from './functions/renewName';
+import type setName from './functions/setName';
+import type setRecord from './functions/setRecord';
+import type setRecords from './functions/setRecords';
+import type setResolver from './functions/setResolver';
+import type transferName from './functions/transferName';
+import type transferSubname from './functions/transferSubname';
+import type unwrapName from './functions/unwrapName';
+import type wrapName from './functions/wrapName';
 import GqlManager from './GqlManager';
+export type { Fuse, FuseArrayPossibilities, FuseObj, NamedFusesToBurn, UnnamedFuseType, UnnamedFuseValues, } from './utils/fuses';
 declare type ENSOptions = {
     graphURI?: string | null;
     getContractAddress?: typeof _getContractAddress;
@@ -10,6 +26,7 @@ declare type ENSOptions = {
 export declare type InternalENS = {
     options?: ENSOptions;
     provider?: ethers.providers.Provider;
+    signer: JsonRpcSigner;
     graphURI?: string | null;
 } & ENS;
 export declare type ENSArgs<K extends keyof InternalENS> = {
@@ -17,6 +34,17 @@ export declare type ENSArgs<K extends keyof InternalENS> = {
 };
 declare type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;
 declare type OmitFirstTwoArgs<F> = F extends (x: any, y: any, ...args: infer P) => infer R ? (...args: P) => R : never;
+declare type WriteOptions = {
+    addressOrIndex?: string | number;
+    signer?: JsonRpcSigner;
+};
+declare type OptionalWriteOptions<F> = F extends (x: any, arg_0: infer Z, options?: infer P) => infer R ? (name: Z, options?: P & WriteOptions) => R : F extends (x: any, arg_0: infer Z, options: infer P) => infer R ? (name: Z, options: P & WriteOptions) => R : never;
+interface WriteFunction<F extends (...args: any) => any> extends Function {
+    (...args: Parameters<OptionalWriteOptions<F>>): Promise<ContractTransaction & {
+        customData?: Record<string, any>;
+    }>;
+    populateTransaction: (...args: Parameters<OptionalWriteOptions<F>>) => Promise<PopulatedTransaction>;
+}
 export declare type RawFunction = {
     raw: (...args: any[]) => Promise<{
         to: string;
@@ -77,6 +105,14 @@ export declare class ENS {
      * @returns {OmitFirstArg} - The generated wrapped function
      */
     private generateFunction;
+    /**
+     * Generates a write wrapped function
+     * @param {string} path - The path of the exported function
+     * @param {FunctionDeps} dependencies - An array of ENS properties
+     * @param {string} exportName - The export name of the target function
+     * @returns {OmitFirstArg} - The generated wrapped function
+     */
+    private generateWriteFunction;
     /**
      * Generates a wrapped function from raw and decode exports
      * @param {string} path - The path of the exported function
@@ -104,11 +140,13 @@ export declare class ENS {
         }>;
         decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
     }>;
-    getProfile: (nameOrAddress: string, options?: {
+    getProfile: (nameOrAddress: string, options?: ({
         contentHash?: boolean | undefined;
         texts?: boolean | string[] | undefined;
         coinTypes?: boolean | string[] | undefined;
-    } | undefined) => Promise<{
+    } & {
+        resolverAddress?: string | undefined;
+    }) | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
         address?: string | undefined;
@@ -137,6 +175,7 @@ export declare class ENS {
         contentHash?: boolean | undefined;
         texts?: boolean | string[] | undefined;
         coinTypes?: boolean | string[] | undefined;
+        resolverAddress?: string | undefined;
     } | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
@@ -173,8 +212,8 @@ export declare class ENS {
             reverseResolverAddress: any;
             resolverAddress: any;
         } | {
-            name: null;
-            match: boolean;
+            name: undefined;
+            match?: undefined;
             reverseResolverAddress?: undefined;
             resolverAddress?: undefined;
         } | undefined>;
@@ -191,68 +230,36 @@ export declare class ENS {
             to: string;
             data: string;
         }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
-            fuseObj: {
-                [k: string]: any;
-            };
-            vulnerability: any;
-            vulnerableNode: null;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+            fuseObj: import("./utils/fuses").CurrentFuses;
+            expiryDate: Date;
             rawFuses: ethers.BigNumber;
+            owner: any;
         } | undefined>;
     }>;
     getHistory: (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>;
-    getHistoryWithDetail: (name: string) => Promise<{
-        domain: {
-            type: any;
-            blockNumber: any;
-            transactionHash: any;
-            id: any;
-            data: Record<string, any>;
+            type: "Transfer" | "NewOwner" | "NewResolver" | "NewTTL";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
         }[];
         registration: {
-            type: any;
-            blockNumber: any;
-            transactionHash: any;
-            id: any;
-            data: Record<string, any>;
+            type: "NameRegistered" | "NameRenewed" | "NameTransferred";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
         }[];
         resolver: {
-            type: any;
-            blockNumber: any;
-            transactionHash: any;
-            id: any;
-            data: Record<string, any>;
+            type: "AddrChanged" | "ContenthashChanged" | "InterfaceChanged" | "NameChanged" | "PubkeyChanged" | "TextChanged" | "MulticoinAddrChanged" | "AbiChanged" | "AuthorisationChanged";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
         }[];
     } | undefined>;
-    getHistoryDetailForTransactionHash: (hash: string, indexInTransaction?: number | undefined) => Promise<({
-        key: any;
-        value: any;
-    } | undefined)[] | {
-        key: any;
-        value: any;
-    } | undefined>;
     getContentHash: GeneratedRawFunction<{
         raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string) => Promise<{
             to: string;
@@ -337,11 +344,18 @@ export declare class ENS {
         } | undefined>;
     }>;
     getExpiry: GeneratedRawFunction<{
-        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string) => Promise<{
+        raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: {
+            contract?: ("nameWrapper" | "registrar") | undefined;
+        }) => Promise<{
             to: string;
             data: string;
         }>;
-        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
+        decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: {
+            contract?: ("nameWrapper" | "registrar") | undefined;
+        }) => Promise<{
+            expiry: Date;
+            gracePeriod: null;
+        } | {
             expiry: Date | null;
             gracePeriod: number;
         } | undefined>;
@@ -352,7 +366,7 @@ export declare class ENS {
         pageSize?: number | undefined;
         orderDirection?: "asc" | "desc" | undefined;
         orderBy?: "labelName" | "createdAt" | undefined;
-        lastSubnames: any[];
+        lastSubnames?: any[] | undefined;
         isLargeQuery?: boolean | undefined;
     }) => Promise<{
         subnames: {
@@ -396,6 +410,7 @@ export declare class ENS {
             premium: ethers.BigNumber;
         } | undefined>;
     }>;
+    getDNSOwner: (dnsName: string) => Promise<any>;
     universalWrapper: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string, data: string) => Promise<{
             to: string;
@@ -417,54 +432,24 @@ export declare class ENS {
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<ethers.utils.Result | undefined>;
     }>;
     multicallWrapper: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean) => Promise<{
+        raw({ contracts }: ENSArgs<"contracts">, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean): Promise<{
             to: string;
             data: string;
         }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
+        decode({ contracts }: ENSArgs<"contracts">, data: string): Promise<any>;
     }>;
-    setName: (name: string, address?: string | undefined, resolver?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction | undefined>;
-    setRecords: (name: string, records: import("./utils/recordHelpers").RecordOptions) => Promise<ethers.ContractTransaction | undefined>;
-    setResolver: (name: string, contract: "nameWrapper" | "registry", resolver?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    transferName: (name: string, newOwner: string, contract: "nameWrapper" | "registry" | "baseRegistrar", options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    wrapName: (name: string, wrappedOwner: string, fuseOptions?: string | number | import("./@types/FuseOptions").FuseOptions | undefined, resolverAddress?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    unwrapName: (name: string, newController: string, newRegistrant?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    burnFuses: (name: string, fusesToBurn: import("./@types/FuseOptions").FuseOptions) => Promise<ethers.ContractTransaction>;
-    createSubname: (args_0: {
-        name: string;
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-        options?: {
-            addressOrIndex?: string | number | undefined;
-        } | undefined;
-    } | ({
-        contract: "nameWrapper";
-        fuses?: import("./@types/FuseOptions").FuseOptions | undefined;
-    } & {
-        name: string;
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-        options?: {
-            addressOrIndex?: string | number | undefined;
-        } | undefined;
-    })) => Promise<ethers.ContractTransaction>;
-    deleteSubname: (name: string, contract: "nameWrapper" | "registry", options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    transferSubname: (name: string, contract: "nameWrapper" | "registry", address: string, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
+    setName: WriteFunction<typeof setName>;
+    setRecords: WriteFunction<typeof setRecords>;
+    setRecord: WriteFunction<typeof setRecord>;
+    setResolver: WriteFunction<typeof setResolver>;
+    transferName: WriteFunction<typeof transferName>;
+    wrapName: WriteFunction<typeof wrapName>;
+    unwrapName: WriteFunction<typeof unwrapName>;
+    burnFuses: WriteFunction<typeof burnFuses>;
+    createSubname: WriteFunction<typeof createSubname>;
+    deleteSubname: WriteFunction<typeof deleteSubname>;
+    transferSubname: WriteFunction<typeof transferSubname>;
+    commitName: WriteFunction<typeof commitName>;
+    registerName: WriteFunction<typeof registerName>;
+    renewName: WriteFunction<typeof renewName>;
 }
-export {};

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

@@ -0,0 +1,43 @@
+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;
+};
+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: 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 declare type FuseObj = typeof fuseEnum;
+export declare type CurrentFuses = {
+    [f in keyof FuseObj]: boolean;
+};
+export declare type UnnamedFuseType = typeof unnamedFuses;
+export declare type Fuse = keyof FuseObj;
+export declare type UnnamedFuseValues = UnnamedFuseType[number];
+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.
+ *
+ * @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 : [
+];
+export declare type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>;
+export default fullFuseEnum;

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

@@ -0,0 +1,2 @@
+export declare const normalise: (name: string) => any;
+export declare const namehash: (name: string) => string;

package/dist/{esm → types}/utils/recordHelpers.d.ts

@@ -9,5 +9,8 @@ export declare type RecordOptions = {
     coinTypes?: RecordItem[];
 };
 export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
+export declare type RecordTypes = 'contentHash' | 'text' | 'addr';
+export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : RecordItem;
+export declare function generateSingleRecordCall<T extends RecordTypes>(namehash: string, resolver: PublicResolver, type: T): (record: RecordInput<T>) => string;
 export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
 export {};

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

@@ -0,0 +1,54 @@
+import type { FuseOptions } from '../@types/FuseOptions';
+import type { PublicResolver } from '../generated';
+import { RecordOptions } from './recordHelpers';
+export declare type RegistrationParams = {
+    name: string;
+    owner: string;
+    duration: number;
+    secret: string;
+    resolver: PublicResolver;
+    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: (params: CommitmentTuple) => string;
+export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
+    secret: string;
+    commitment: string;
+    wrapperExpiry: number;
+};

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

@@ -0,0 +1,5 @@
+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) => Promise<BigNumber>;

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

@@ -0,0 +1,21 @@
+import type { JsonRpcSigner } from '@ethersproject/providers';
+import type { PopulatedTransaction } from 'ethers';
+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;