@ensdomains/ensjs 3.0.0-alpha.16 → 3.0.0-alpha.19

package/dist/cjs/index.d.ts

@@ -1,467 +0,0 @@
-import { JsonRpcSigner } from '@ethersproject/providers';
-import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers';
-import ContractManager from './contracts';
-import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
-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 registerName from './functions/registerName';
-import 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';
-declare type ENSOptions = {
-    graphURI?: string | null;
-    getContractAddress?: typeof _getContractAddress;
-};
-export declare type InternalENS = {
-    options?: ENSOptions;
-    provider?: ethers.providers.Provider;
-    signer: JsonRpcSigner;
-    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;
-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;
-        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;
-    fuses: {
-        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;
-    };
-    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 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
-     * @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;
-    } & {
-        resolverAddress?: 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;
-        resolverAddress?: 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: undefined;
-            match?: undefined;
-            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) => Promise<{
-            fuseObj: {
-                [k: string]: boolean;
-            };
-            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>;
-    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: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: {
-            contract?: ("nameWrapper" | "registrar") | undefined;
-        }) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        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>;
-    }>;
-    getSubnames: (functionArgs: {
-        name: string;
-        page?: number | undefined;
-        pageSize?: number | undefined;
-        orderDirection?: "asc" | "desc" | undefined;
-        orderBy?: "labelName" | "createdAt" | undefined;
-        lastSubnames?: any[] | undefined;
-        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>;
-    }>;
-    getDNSOwner: (dnsName: string) => Promise<any>;
-    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: 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/cjs/utils/fuses.d.ts

@@ -1,21 +0,0 @@
-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 default fullFuseEnum;

package/dist/esm/GqlManager.d.ts

@@ -1,11 +0,0 @@
-import type { parse as Parse, print as Print, SelectionSetNode, visit as Visit } from 'graphql';
-import type Traverse from 'traverse';
-export declare const enter: (node: SelectionSetNode) => SelectionSetNode | undefined;
-export declare const requestMiddleware: (visit: typeof Visit, parse: typeof Parse, print: typeof Print) => (request: any) => any;
-export declare const responseMiddleware: (traverse: typeof Traverse) => (response: any) => any;
-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,82 +0,0 @@
-import { namehash } from './utils/normalise';
-const generateSelection = (selection) => ({
-    kind: 'Field',
-    name: {
-        kind: 'Name',
-        value: selection,
-    },
-    arguments: [],
-    directives: [],
-    alias: undefined,
-    selectionSet: undefined,
-});
-export const enter = (node) => {
-    let hasName = false;
-    let hasId = false;
-    for (const selection of node.selections) {
-        if ('name' in selection) {
-            if (selection.name.value === 'name')
-                hasName = true;
-            else if (selection.name.value === 'id')
-                hasId = true;
-        }
-    }
-    if (hasName && !hasId) {
-        node.selections = [...node.selections, generateSelection('id')];
-        return node;
-    }
-};
-export const requestMiddleware = (visit, parse, print) => (request) => {
-    const requestBody = JSON.parse(request.body);
-    const rawQuery = requestBody.query;
-    const parsedQuery = parse(rawQuery);
-    const updatedQuery = visit(parsedQuery, {
-        SelectionSet: {
-            enter,
-        },
-    });
-    return {
-        ...request,
-        body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
-    };
-};
-export const responseMiddleware = (traverse) => (response) => {
-    traverse(response).forEach(function (responseItem) {
-        if (responseItem instanceof Object && responseItem.name) {
-            //Name already in hashed form
-            if (responseItem.name && responseItem.name.includes('[')) {
-                return;
-            }
-            const hashedName = namehash(responseItem.name);
-            if (responseItem.id !== hashedName) {
-                this.update({ ...responseItem, name: hashedName, invalidName: true });
-            }
-        }
-    });
-    return response;
-};
-export default class GqlManager {
-    constructor() {
-        this.gql = () => null;
-        this.client = null;
-        this.setUrl = async (url) => {
-            if (url) {
-                const [imported, traverse, { visit, parse, print }] = await Promise.all([
-                    import('graphql-request'),
-                    import('traverse'),
-                    import('graphql/language'),
-                ]);
-                this.client = new imported.GraphQLClient(url, {
-                    requestMiddleware: requestMiddleware(visit, parse, print),
-                    responseMiddleware: responseMiddleware(traverse.default),
-                });
-                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.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/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) => Promise<import("../generated").PublicResolver>;
-    getUniversalResolver: (passedProvider?: any, address?: string) => Promise<import("../generated").UniversalResolver>;
-    getRegistry: (passedProvider?: any, address?: string) => Promise<import("../generated").ENSRegistry>;
-    getReverseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated").ReverseRegistrar>;
-    getNameWrapper: (passedProvider?: any, address?: string) => Promise<import("../generated").NameWrapper>;
-    getBaseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated").BaseRegistrarImplementation>;
-    getEthRegistrarController: (passedProvider?: any, address?: string) => Promise<import("../generated").ETHRegistrarController>;
-    getMulticall: (passedProvider?: any, address?: string) => Promise<import("../generated").Multicall>;
-}