@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.51

package/dist/types/static.d.ts

@@ -0,0 +1,26 @@
+import type { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { gql, GraphQLClient } from 'graphql-request';
+import { ENS, FunctionSubtype } from './index';
+import type Factories from './contracts/factories';
+import type FunctionTypes from './functions/types';
+declare type Options = ConstructorParameters<typeof ENS>[0] & {
+    functions: Partial<FunctionTypes>;
+    contracts: Partial<Factories>;
+};
+declare class StaticENS extends ENS {
+    private functions;
+    private contractsObject;
+    gqlInstance: {
+        client: GraphQLClient | {
+            request: () => Promise<null>;
+        };
+        setUrl: () => Promise<void>;
+        gql: typeof gql | ((query: TemplateStringsArray) => string);
+    };
+    constructor(provider: StaticJsonRpcProvider, { functions, contracts, ...options }: Options);
+    setStaticProvider: (provider: StaticJsonRpcProvider) => void;
+    setProvider: (provider: StaticJsonRpcProvider) => Promise<void>;
+    protected getModule: () => Promise<Partial<FunctionTypes>>;
+    protected getFunction: (subFunc: FunctionSubtype | undefined, _writeable: boolean | undefined, exportName: string, mod: any, path: string) => any;
+}
+export default StaticENS;

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

@@ -0,0 +1,3 @@
+import type { BaseProvider, TransactionRequest } from '@ethersproject/providers';
+declare const ccipLookup: (provider: BaseProvider, transaction: TransactionRequest, result: string) => Promise<string | undefined>;
+export default ccipLookup;

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

@@ -0,0 +1,2 @@
+export declare const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const MAX_INT_64: bigint;

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

@@ -0,0 +1,133 @@
+export declare const CHILD_CONTROLLED_FUSES = 65535;
+export declare const PARENT_CONTROLLED_FUSES = 4294901760;
+export declare const USER_SETTABLE_FUSES = 4294836223;
+export declare const childFuseEnum: {
+    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;
+};
+export declare const parentFuseEnum: {
+    PARENT_CANNOT_CONTROL: number;
+    CAN_EXTEND_EXPIRY: number;
+};
+export declare const fullParentFuseEnum: {
+    readonly IS_DOT_ETH: 131072;
+    readonly PARENT_CANNOT_CONTROL: number;
+    readonly CAN_EXTEND_EXPIRY: number;
+};
+export declare const userSettableFuseEnum: {
+    readonly PARENT_CANNOT_CONTROL: number;
+    readonly CAN_EXTEND_EXPIRY: number;
+    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;
+};
+export declare const fullFuseEnum: {
+    CAN_DO_EVERYTHING: number;
+    IS_DOT_ETH: 131072;
+    PARENT_CANNOT_CONTROL: number;
+    CAN_EXTEND_EXPIRY: number;
+    CANNOT_UNWRAP: 1;
+    CANNOT_BURN_FUSES: 2;
+    CANNOT_TRANSFER: 4;
+    CANNOT_SET_RESOLVER: 8;
+    CANNOT_SET_TTL: 16;
+    CANNOT_CREATE_SUBDOMAIN: 32;
+};
+export declare const unnamedChildFuses: readonly [64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768];
+export declare const unnamedParentFuses: readonly [524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648];
+export declare const unnamedUserSettableFuses: readonly [64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648];
+export declare const childFuseKeys: ("CANNOT_UNWRAP" | "CANNOT_BURN_FUSES" | "CANNOT_TRANSFER" | "CANNOT_SET_RESOLVER" | "CANNOT_SET_TTL" | "CANNOT_CREATE_SUBDOMAIN")[];
+export declare const parentFuseKeys: ("PARENT_CANNOT_CONTROL" | "CAN_EXTEND_EXPIRY")[];
+export declare const fullParentFuseKeys: ("PARENT_CANNOT_CONTROL" | "CAN_EXTEND_EXPIRY" | "IS_DOT_ETH")[];
+export declare const userSettableFuseKeys: ("CANNOT_UNWRAP" | "CANNOT_BURN_FUSES" | "CANNOT_TRANSFER" | "CANNOT_SET_RESOLVER" | "CANNOT_SET_TTL" | "CANNOT_CREATE_SUBDOMAIN" | "PARENT_CANNOT_CONTROL" | "CAN_EXTEND_EXPIRY")[];
+declare type FuseType<Enum extends Record<string, number>, UnnamedTuple extends readonly number[], CustomFuses extends string = never> = {
+    fuse: keyof Enum;
+    options: {
+        -readonly [K in keyof Enum]?: boolean;
+    };
+    current: {
+        [K in keyof Enum]: boolean;
+    } & {
+        readonly [K in CustomFuses]: boolean;
+    };
+    unnamed: UnnamedTuple;
+    unnamedValues: UnnamedTuple[number];
+    unnamedObject: {
+        [K in UnnamedTuple[number]]: boolean;
+    };
+};
+export declare type ChildFuses = FuseType<typeof childFuseEnum, typeof unnamedChildFuses, 'CAN_DO_EVERYTHING'>;
+export declare type ParentFuses = FuseType<typeof parentFuseEnum, typeof unnamedParentFuses>;
+export declare type FullParentFuses = FuseType<typeof fullParentFuseEnum, typeof unnamedParentFuses>;
+export declare type UserSettableFuses = FuseType<typeof userSettableFuseEnum, typeof unnamedUserSettableFuses>;
+declare type InputFuses<NamedFuse extends string, UnnamedFuse extends number> = {
+    named: readonly NamedFuse[];
+} | {
+    unnamed: readonly UnnamedFuse[];
+} | {
+    named: readonly NamedFuse[];
+    unnamed: readonly UnnamedFuse[];
+} | {
+    number: number;
+};
+export declare type CombinedFuseInput = {
+    child: InputFuses<ChildFuses['fuse'], ChildFuses['unnamedValues']>;
+    parent: InputFuses<ParentFuses['fuse'], ParentFuses['unnamedValues']>;
+};
+export declare const hasFuses: (fuses: any) => boolean;
+export declare function encodeFuses(fuses: Partial<CombinedFuseInput> | number): number;
+export declare function encodeFuses(fuses: CombinedFuseInput['child'], restrictTo: 'child'): number;
+export declare function encodeFuses(fuses: CombinedFuseInput['parent'], restrictTo: 'parent'): number;
+export declare const decodeFuses: (fuses: number) => {
+    parent: {
+        unnamed: {
+            524288: boolean;
+            1048576: boolean;
+            2097152: boolean;
+            4194304: boolean;
+            8388608: boolean;
+            16777216: boolean;
+            33554432: boolean;
+            67108864: boolean;
+            134217728: boolean;
+            268435456: boolean;
+            536870912: boolean;
+            1073741824: boolean;
+            2147483648: boolean;
+        };
+        IS_DOT_ETH: boolean;
+        PARENT_CANNOT_CONTROL: boolean;
+        CAN_EXTEND_EXPIRY: boolean;
+    };
+    child: {
+        CAN_DO_EVERYTHING: boolean;
+        unnamed: {
+            1024: boolean;
+            64: boolean;
+            128: boolean;
+            256: boolean;
+            512: boolean;
+            2048: boolean;
+            4096: boolean;
+            8192: boolean;
+            16384: boolean;
+            32768: boolean;
+        };
+        CANNOT_UNWRAP: boolean;
+        CANNOT_BURN_FUSES: boolean;
+        CANNOT_TRANSFER: boolean;
+        CANNOT_SET_RESOLVER: boolean;
+        CANNOT_SET_TTL: boolean;
+        CANNOT_CREATE_SUBDOMAIN: boolean;
+    };
+};
+export declare const checkPCCBurned: (fuses: number) => boolean;
+export declare type AllCurrentFuses = ReturnType<typeof decodeFuses>;
+export default fullFuseEnum;

package/dist/{cjs → types}/utils/hexEncodedName.d.ts

@@ -1 +1,2 @@
 export declare const hexEncodeName: (name: string) => string;
+export declare const hexDecodeName: (hex: string) => string;

package/dist/{cjs → types}/utils/labels.d.ts

@@ -5,10 +5,11 @@ export declare function encodeLabelhash(hash: string): string;
 export declare function isEncodedLabelhash(hash: string): boolean;
 export declare function saveLabel(label: string): string;
 export declare function saveName(name: string): void;
-export declare function checkLabel(hash: string): string | undefined;
+export declare function checkLabel(hash: string): string;
 export declare function encodeLabel(label: any): any;
 export declare function parseName(name: string): string;
 export declare function checkIsDecrypted(string: string | string[]): boolean;
 export declare function decryptName(name: string): string;
 export declare const truncateUndecryptedName: (name: string) => string;
 export declare function checkLocalStorageSize(): string;
+export declare const getEncryptedLabelAmount: (name: string) => number;

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/types/utils/recordHelpers.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import type { BigNumberish } from 'ethers';
+import type { PublicResolver } from '../generated';
+declare type RecordItem = {
+    key: string;
+    value: string;
+};
+declare type ABIEncodeAs = 'json' | 'zlib' | 'cbor' | 'uri';
+declare type ABIItem = {
+    contentType?: BigNumberish;
+    data: object | string;
+};
+export declare type RecordOptions = {
+    clearRecords?: boolean;
+    contentHash?: string;
+    texts?: RecordItem[];
+    coinTypes?: RecordItem[];
+    abi?: ABIItem;
+};
+export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
+export declare const generateABIInput: (encodeAs: ABIEncodeAs, data: object | string) => Promise<{
+    contentType: number;
+    data: string | Uint8Array | Buffer;
+}>;
+export declare type RecordTypes = 'contentHash' | 'text' | 'addr' | 'abi';
+export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : T extends 'abi' ? ABIItem : 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,41 @@
+import type { PublicResolver } from '../generated';
+import { CombinedFuseInput } from './fuses';
+import { RecordOptions } from './recordHelpers';
+export declare type BaseRegistrationParams = {
+    owner: string;
+    duration: number;
+    secret: string;
+    resolverAddress?: string;
+    records?: RecordOptions;
+    reverseRecord?: boolean;
+    fuses?: CombinedFuseInput['child'];
+};
+export declare type RegistrationParams = Omit<BaseRegistrationParams, 'resolverAddress'> & {
+    name: string;
+    resolver: PublicResolver;
+};
+export declare type CommitmentParams = Omit<RegistrationParams, 'secret'> & {
+    secret?: string;
+};
+export declare type RegistrationTuple = [
+    name: string,
+    owner: string,
+    duration: number,
+    secret: string,
+    resolver: string,
+    data: string[],
+    reverseRecord: boolean,
+    ownerControlledFuses: number
+];
+export declare const randomSecret: () => string;
+export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, secret, }: Omit<RegistrationParams, "secret"> & {
+    secret?: string | undefined;
+} & {
+    secret: string;
+}) => RegistrationTuple;
+export declare const makeRegistrationData: (params: RegistrationParams) => RegistrationTuple;
+export declare const _makeCommitment: (params: RegistrationTuple) => string;
+export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
+    secret: string;
+    commitment: string;
+};

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

@@ -0,0 +1,2 @@
+import { ENSArgs } from '../index';
+export declare const makeResolver: ({ contracts }: ENSArgs<'contracts'>, name: string, resolver?: string) => Promise<string>;

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

@@ -1,8 +1,9 @@
-import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.Provider, ensData: any, func: {
+import type { Provider } from '@ethersproject/providers';
+declare const _default: (provider: Provider, ensData: any, func: {
     raw: (...args: any[]) => Promise<{
         to: string;
         data: string;
+        passthrough?: any;
     }>;
     decode: (...args: any[]) => Promise<any>;
 }, ...data: any[]) => Promise<any>;

package/dist/types/utils/subgraph-types.d.ts

@@ -0,0 +1,284 @@
+export declare type Maybe<T> = T | null;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    Bytes: string;
+    BigInt: string;
+};
+export declare type Domain = {
+    __typename?: 'Domain';
+    id: Scalars['ID'];
+    name?: Maybe<Scalars['String']>;
+    labelName?: Maybe<Scalars['String']>;
+    labelhash?: Maybe<Scalars['Bytes']>;
+    parent?: Maybe<Domain>;
+    subdomains: Array<Domain>;
+    subdomainCount: Scalars['Int'];
+    resolvedAddress?: Maybe<Account>;
+    owner: Account;
+    resolver?: Maybe<Resolver>;
+    ttl?: Maybe<Scalars['BigInt']>;
+    isMigrated: Scalars['Boolean'];
+    createdAt: Scalars['BigInt'];
+    events: Array<DomainEvent>;
+    registration?: Maybe<Registration>;
+    wrappedDomain?: Maybe<WrappedDomain>;
+};
+export declare type DomainEvent = {
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type Transfer = DomainEvent & {
+    __typename?: 'Transfer';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NewOwner = DomainEvent & {
+    __typename?: 'NewOwner';
+    id: Scalars['ID'];
+    parentDomain: Domain;
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NewResolver = DomainEvent & {
+    __typename?: 'NewResolver';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    resolver: Resolver;
+};
+export declare type NewTtl = DomainEvent & {
+    __typename?: 'NewTTL';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    ttl: Scalars['BigInt'];
+};
+export declare type WrappedTransfer = DomainEvent & {
+    __typename?: 'WrappedTransfer';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NameWrapped = DomainEvent & {
+    __typename?: 'NameWrapped';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    name: Scalars['String'];
+    fuses: Scalars['Int'];
+    owner: Account;
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameUnwrapped = DomainEvent & {
+    __typename?: 'NameUnwrapped';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type FusesSet = DomainEvent & {
+    __typename?: 'FusesSet';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    fuses: Scalars['Int'];
+};
+export declare type ExpiryExtended = DomainEvent & {
+    __typename?: 'ExpiryExtended';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    expiryDate: Scalars['BigInt'];
+};
+export declare type Registration = {
+    __typename?: 'Registration';
+    id: Scalars['ID'];
+    domain: Domain;
+    registrationDate: Scalars['BigInt'];
+    expiryDate: Scalars['BigInt'];
+    cost?: Maybe<Scalars['BigInt']>;
+    registrant: Account;
+    labelName?: Maybe<Scalars['String']>;
+    events: Array<RegistrationEvent>;
+};
+export declare type RegistrationEvent = {
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type NameRegistered = RegistrationEvent & {
+    __typename?: 'NameRegistered';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    registrant: Account;
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameRenewed = RegistrationEvent & {
+    __typename?: 'NameRenewed';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameTransferred = RegistrationEvent & {
+    __typename?: 'NameTransferred';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    newOwner: Account;
+};
+export declare type WrappedDomain = {
+    __typename?: 'WrappedDomain';
+    id: Scalars['ID'];
+    domain: Domain;
+    expiryDate: Scalars['BigInt'];
+    fuses: Scalars['Int'];
+    owner: Account;
+    name?: Maybe<Scalars['String']>;
+};
+export declare type Account = {
+    __typename?: 'Account';
+    id: Scalars['ID'];
+    domains: Array<Domain>;
+    wrappedDomains?: Maybe<Array<WrappedDomain>>;
+    registrations?: Maybe<Array<Registration>>;
+};
+export declare type Resolver = {
+    __typename?: 'Resolver';
+    id: Scalars['ID'];
+    domain?: Maybe<Domain>;
+    address: Scalars['Bytes'];
+    addr?: Maybe<Account>;
+    contentHash?: Maybe<Scalars['Bytes']>;
+    texts?: Maybe<Array<Scalars['String']>>;
+    coinTypes?: Maybe<Array<Scalars['BigInt']>>;
+    events: Array<ResolverEvent>;
+};
+export declare type ResolverEvent = {
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type AddrChanged = ResolverEvent & {
+    __typename?: 'AddrChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    addr: Account;
+};
+export declare type MulticoinAddrChanged = ResolverEvent & {
+    __typename?: 'MulticoinAddrChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    coinType: Scalars['BigInt'];
+    addr: Scalars['Bytes'];
+};
+export declare type NameChanged = ResolverEvent & {
+    __typename?: 'NameChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    name: Scalars['String'];
+};
+export declare type AbiChanged = ResolverEvent & {
+    __typename?: 'AbiChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    contentType: Scalars['BigInt'];
+};
+export declare type PubkeyChanged = ResolverEvent & {
+    __typename?: 'PubkeyChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    x: Scalars['Bytes'];
+    y: Scalars['Bytes'];
+};
+export declare type TextChanged = ResolverEvent & {
+    __typename?: 'TextChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    key: Scalars['String'];
+    value?: Maybe<Scalars['String']>;
+};
+export declare type ContenthashChanged = ResolverEvent & {
+    __typename?: 'ContenthashChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    hash: Scalars['Bytes'];
+};
+export declare type InterfaceChanged = ResolverEvent & {
+    __typename?: 'InterfaceChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    interfaceID: Scalars['Bytes'];
+    implementer: Scalars['Bytes'];
+};
+export declare type AuthorisationChanged = ResolverEvent & {
+    __typename?: 'AuthorisationChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Scalars['Bytes'];
+    target: Scalars['Bytes'];
+    isAuthorized: Scalars['Boolean'];
+};
+export declare type VersionChanged = ResolverEvent & {
+    __typename?: 'VersionChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    version: Scalars['BigInt'];
+};

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

@@ -5,4 +5,5 @@ declare type InputType = {
     info?: 'short' | 'supported' | 'unsupported';
 };
 export declare const parseInputType: (input: string) => InputType;
+export declare const checkIsDotEth: (labels: string[]) => boolean;
 export {};

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

@@ -0,0 +1,7 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ENSArgs } from '../index';
+export declare type Expiry = string | number | Date | BigNumber;
+export declare const MAX_EXPIRY: BigNumber;
+export declare const expiryToBigNumber: (expiry?: Expiry, defaultValue?: number) => BigNumber;
+export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry) => Promise<BigNumber>;
+export declare const wrappedLabelLengthCheck: (label: string) => void;

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

@@ -0,0 +1,21 @@
+import type { PopulatedTransaction } from '@ethersproject/contracts';
+import type { JsonRpcSigner } from '@ethersproject/providers';
+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("@ethersproject/transactions").AccessList | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
+    ccipReadEnabled?: boolean | undefined;
+} | Promise<import("@ethersproject/abstract-provider").TransactionResponse | (import("@ethersproject/abstract-provider").TransactionResponse & {
+    customData: CustomData;
+})>;
+export default _default;