@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.30

package/dist/cjs/index.d.ts

@@ -1,471 +0,0 @@
-import { ethers } from 'ethers';
-import ContractManager from './contracts';
-import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
-import { SupportedNetworkId } from './contracts/types';
-import GqlManager from './GqlManager';
-declare type ENSOptions = {
-    graphURI?: string | null;
-    getContractAddress?: typeof _getContractAddress;
-};
-export declare type InternalENS = {
-    options?: ENSOptions;
-    provider?: ethers.providers.Provider;
-    graphURI?: string | null;
-} & ENS;
-export declare type ENSArgs<K extends keyof InternalENS> = {
-    [P in K]: InternalENS[P];
-};
-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;
-export declare type RawFunction = {
-    raw: (...args: any[]) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: (...args: any[]) => Promise<any>;
-};
-export declare type BatchFunctionResult<F extends RawFunction> = {
-    args: Parameters<OmitFirstArg<F['raw']>>;
-    raw: F['raw'];
-    decode: F['decode'];
-};
-declare type BatchFunction<F extends RawFunction> = (...args: Parameters<OmitFirstArg<F['raw']>>) => BatchFunctionResult<F>;
-export declare type RawFunctionWithBatch = {
-    batch: BatchFunction<any>;
-} & RawFunction;
-interface GeneratedRawFunction<F extends RawFunction> extends Function, RawFunction {
-    (...args: Parameters<OmitFirstArg<F['raw']>>): ReturnType<OmitFirstTwoArgs<F['decode']>>;
-    batch: BatchFunction<F>;
-}
-export interface GenericGeneratedRawFunction extends Function, RawFunctionWithBatch {
-}
-export declare class ENS {
-    [x: string]: any;
-    protected options?: ENSOptions;
-    protected provider?: ethers.providers.JsonRpcProvider;
-    protected graphURI?: string | null;
-    protected initialProvider?: ethers.providers.JsonRpcProvider;
-    contracts?: ContractManager;
-    getContractAddress: (networkId: SupportedNetworkId) => import("./contracts/getContractAddress").ContractAddressFetch;
-    gqlInstance: GqlManager;
-    constructor(options?: ENSOptions);
-    /**
-     * Checks for an initial provider and if it exists, sets it as the provider
-     * @returns {Promise<void>} - A promise that resolves when the provider is checked, and set if needed
-     */
-    private checkInitialProvider;
-    /**
-     * Creates an object of ENS properties from an array
-     * @param {FunctionDeps} dependencies - An array of ENS properties
-     * @returns {Object} - An object of ENS properties
-     */
-    private forwardDependenciesFromArray;
-    /**
-     * Creates a wrapper for a function to be dynamically imported, with the correct dependencies passed in
-     * @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
-     * @param {string} subFunc - The type of function being imported
-     * @returns {Function} - The generated wrapped function
-     */
-    private importGenerator;
-    /**
-     * Generates a normal 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 generateFunction;
-    /**
-     * Generates a wrapped function from raw and decode exports
-     * @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 {GeneratedRawFunction} - The generated wrapped function
-     */
-    private generateRawFunction;
-    /**
-     * Sets the provider for the ENS class
-     * @param {ethers.providers.JsonRpcProvider} provider - The provider to set
-     * @returns {Promise<void>} - A promise that resolves when the provider is set
-     */
-    setProvider: (provider: ethers.providers.JsonRpcProvider) => Promise<void>;
-    /**
-     * Creates a new ENS instance with a different provider, ideally should be used individually with any given function
-     * @param {ethers.providers.JsonRpcProvider} provider - The provider to use
-     * @returns {ENS} - A new ENS instance with the given provider
-     */
-    withProvider: (provider: ethers.providers.JsonRpcProvider) => ENS;
-    batch: GeneratedRawFunction<{
-        raw: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, ...items: BatchFunctionResult<RawFunction>[]) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
-    }>;
-    getProfile: (nameOrAddress: string, options?: {
-        contentHash?: boolean | undefined;
-        texts?: boolean | string[] | undefined;
-        coinTypes?: boolean | string[] | undefined;
-    } | undefined) => Promise<{
-        isMigrated: boolean | null;
-        createdAt: string | null;
-        address?: string | undefined;
-        name?: string | null | undefined;
-        match?: boolean | undefined;
-        message?: string | undefined;
-        records?: {
-            contentHash?: string | import("./utils/contentHash").DecodedContentHash | null | undefined;
-            texts?: {
-                key: string | number;
-                type: "addr" | "text" | "contentHash";
-                coin?: string | undefined;
-                value: string;
-            }[] | undefined;
-            coinTypes?: {
-                key: string | number;
-                type: "addr" | "text" | "contentHash";
-                coin?: string | undefined;
-                value: string;
-            }[] | undefined;
-        } | undefined;
-        resolverAddress?: string | undefined;
-        reverseResolverAddress?: string | undefined;
-    } | undefined>;
-    getRecords: (name: string, options?: {
-        contentHash?: boolean | undefined;
-        texts?: boolean | string[] | undefined;
-        coinTypes?: boolean | string[] | undefined;
-    } | undefined) => Promise<{
-        isMigrated: boolean | null;
-        createdAt: string | null;
-        address?: string | undefined;
-        name?: string | null | undefined;
-        match?: boolean | undefined;
-        message?: string | undefined;
-        records?: {
-            contentHash?: string | import("./utils/contentHash").DecodedContentHash | null | undefined;
-            texts?: {
-                key: string | number;
-                type: "addr" | "text" | "contentHash";
-                coin?: string | undefined;
-                value: string;
-            }[] | undefined;
-            coinTypes?: {
-                key: string | number;
-                type: "addr" | "text" | "contentHash";
-                coin?: string | undefined;
-                value: string;
-            }[] | undefined;
-        } | undefined;
-        resolverAddress?: string | undefined;
-        reverseResolverAddress?: string | undefined;
-    } | undefined>;
-    getName: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, address: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string, address: string) => Promise<{
-            name: any;
-            match: boolean;
-            reverseResolverAddress: any;
-            resolverAddress: any;
-        } | {
-            name: null;
-            match: boolean;
-            reverseResolverAddress?: undefined;
-            resolverAddress?: undefined;
-        } | undefined>;
-    }>;
-    getResolver: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
-    }>;
-    getFuses: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
-            fuseObj: {
-                [k: string]: any;
-            };
-            vulnerability: any;
-            vulnerableNode: null;
-            rawFuses: ethers.BigNumber;
-        } | 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>;
-        }[];
-        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>;
-    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;
-            data: string;
-        }>;
-        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<{
-            protocolType?: undefined;
-            decoded?: undefined;
-            error?: undefined;
-        } | {
-            protocolType: null;
-            decoded: any;
-            error?: undefined;
-        } | {
-            protocolType: string | undefined;
-            decoded: any;
-            error: any;
-        } | undefined>;
-    }>;
-    _getContentHash: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
-            protocolType?: undefined;
-            decoded?: undefined;
-            error?: undefined;
-        } | {
-            protocolType: null;
-            decoded: any;
-            error?: undefined;
-        } | {
-            protocolType: string | undefined;
-            decoded: any;
-            error: any;
-        } | undefined>;
-    }>;
-    getAddr: GeneratedRawFunction<{
-        raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string, coinType?: string | number | undefined) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
-            coin: string;
-            addr: string;
-        } | undefined>;
-    }>;
-    _getAddr: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, name: string, coinType?: string | number | undefined, bypassFormat?: boolean | undefined) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
-            coin: string;
-            addr: string;
-        } | undefined>;
-    }>;
-    getText: GeneratedRawFunction<{
-        raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string, key: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<any>;
-    }>;
-    _getText: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, name: string, key: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
-    }>;
-    getOwner: GeneratedRawFunction<{
-        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
-            registrant?: string | undefined;
-            owner?: string | undefined;
-            ownershipLevel: "nameWrapper" | "registrar" | "registry";
-        } | undefined>;
-    }>;
-    getExpiry: GeneratedRawFunction<{
-        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
-            expiry: Date | null;
-            gracePeriod: number;
-        } | undefined>;
-    }>;
-    getSubnames: (functionArgs: {
-        name: string;
-        page?: number | undefined;
-        pageSize?: number | undefined;
-        orderDirection?: "asc" | "desc" | undefined;
-        orderBy?: "labelName" | "createdAt" | undefined;
-        lastSubnames: any[];
-        isLargeQuery?: boolean | undefined;
-    }) => Promise<{
-        subnames: {
-            id: string;
-            labelName: string | null;
-            truncatedName?: string | undefined;
-            labelhash: string;
-            isMigrated: boolean;
-            name: string;
-            owner: {
-                id: string;
-            };
-        }[];
-        subnameCount: number;
-    }>;
-    getNames: (args_0: {
-        address: string;
-        type: "owner" | "registrant" | "all";
-        page?: number | undefined;
-        pageSize?: number | undefined;
-        orderDirection?: "asc" | "desc" | undefined;
-    } & ({
-        type: "registrant";
-        orderBy?: "expiryDate" | "registrationDate" | "labelName" | undefined;
-    } | {
-        type: "owner";
-        orderBy?: "labelName" | "createdAt" | undefined;
-    } | {
-        type: "all";
-        orderBy?: "labelName" | "creationDate" | undefined;
-        page?: undefined;
-        pageSize?: undefined;
-    })) => Promise<import("./functions/getNames").Name[]>;
-    getPrice: GeneratedRawFunction<{
-        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, duration: number, legacy?: boolean | undefined) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _name: string, _number: number, legacy?: boolean | undefined) => Promise<{
-            base: ethers.BigNumber;
-            premium: ethers.BigNumber;
-        } | undefined>;
-    }>;
-    universalWrapper: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, name: string, data: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
-            data: any;
-            resolver: any;
-        } | undefined>;
-    }>;
-    resolverMulticallWrapper: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, data: {
-            to: string;
-            data: string;
-        }[]) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<ethers.utils.Result | undefined>;
-    }>;
-    multicallWrapper: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        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>;
-    getDNSOwner: () => Promise<any>;
-}
-export {};

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

@@ -1,20 +0,0 @@
-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;
-};
-declare const _default: {
-    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;
-};
-export default _default;

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

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

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

@@ -1,13 +0,0 @@
-import type { PublicResolver } from '../generated';
-declare type RecordItem = {
-    key: string;
-    value: string;
-};
-export declare type RecordOptions = {
-    contentHash?: string;
-    texts?: RecordItem[];
-    coinTypes?: RecordItem[];
-};
-export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
-export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
-export {};

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

@@ -1,26 +0,0 @@
-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, }: {
-    name: string;
-    owner: string;
-    duration: number;
-    resolver: PublicResolver;
-    records?: RecordOptions | undefined;
-    reverseRecord?: boolean | undefined;
-    fuses?: FuseOptions | undefined;
-}) => {
-    secret: string;
-    commitment: string;
-};
-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;

package/dist/esm/GqlManager.d.ts

@@ -1,6 +0,0 @@
-export default class GqlManager {
-    gql: any;
-    client?: any | null;
-    setUrl: (url: string | null) => Promise<void>;
-    request: (...arg: any[]) => any;
-}

package/dist/esm/GqlManager.js

@@ -1,18 +0,0 @@
-export default class GqlManager {
-    constructor() {
-        this.gql = () => null;
-        this.client = null;
-        this.setUrl = async (url) => {
-            if (url) {
-                const imported = await import('graphql-request');
-                this.client = new imported.GraphQLClient(url);
-                this.gql = imported.gql;
-            }
-            else {
-                this.client = null;
-                this.gql = () => null;
-            }
-        };
-        this.request = (...arg) => this.client ? this.client.request(...arg) : null;
-    }
-}

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

@@ -1,3 +0,0 @@
-import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation;
-export default _default;

package/dist/esm/contracts/baseRegistrar.js

@@ -1,2 +0,0 @@
-import { BaseRegistrarImplementation__factory } from '../generated/factories/BaseRegistrarImplementation__factory';
-export default (provider, address) => BaseRegistrarImplementation__factory.connect(address, provider);

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

@@ -1,3 +0,0 @@
-import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/DoNotCallOnChainUniversalResolverProxy").DoNotCallOnChainUniversalResolverProxy;
-export default _default;

package/dist/esm/contracts/doNotCallOnChainUniversalResolverProxy.js

@@ -1,2 +0,0 @@
-import { DoNotCallOnChainUniversalResolverProxy__factory } from '../generated/factories/DoNotCallOnChainUniversalResolverProxy__factory';
-export default (provider, address) => DoNotCallOnChainUniversalResolverProxy__factory.connect(address, provider);

package/dist/esm/contracts/ethRegistrarController.js

@@ -1,2 +0,0 @@
-import { ETHRegistrarController__factory } from '../generated/factories/ETHRegistrarController__factory';
-export default (provider, address) => ETHRegistrarController__factory.connect(address, provider);

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

@@ -1,3 +0,0 @@
-import { ContractName, SupportedNetworkId } from './types';
-export declare type ContractAddressFetch = (contractName: ContractName) => string;
-export declare const getContractAddress: (networkId: SupportedNetworkId) => ContractAddressFetch;

package/dist/esm/contracts/getContractAddress.js

@@ -1,42 +0,0 @@
-const addresses = {
-    BaseRegistrarImplementation: {
-        '1': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
-        '3': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
-        '4': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
-        '5': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
-    },
-    ETHRegistrarController: {
-        '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-        '3': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-        '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-        '5': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    },
-    Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
-    NameWrapper: '0x0000000000000000000000000000000000000000',
-    PublicResolver: {
-        '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
-    },
-    ENSRegistryWithFallback: {
-        '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
-        '3': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
-        '4': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
-        '5': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
-    },
-    ReverseRegistrar: {
-        '1': '0x084b1c3C81545d370f3634392De611CaaBFf8148',
-    },
-    UniversalResolver: {
-        '1': '0x580AF46E06DaaD47eb5940526FD64d95b815Cb70',
-        '4': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
-    },
-};
-export const getContractAddress = (networkId) => ((contractName) => {
-    try {
-        return typeof addresses[contractName] === 'string'
-            ? addresses[contractName]
-            : addresses[contractName][networkId];
-    }
-    catch {
-        throw new Error(`No address for contract ${contractName} on network ${networkId}`);
-    }
-});

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

@@ -1,16 +0,0 @@
-import { ethers } from 'ethers';
-import { ContractAddressFetch } from './getContractAddress';
-export default class ContractManager {
-    private provider;
-    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").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").BaseRegistrarImplementation>;
-    getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
-    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/Multicall").Multicall>;
-}