@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

package/dist/cjs/utils/labels.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkLocalStorageSize = exports.truncateUndecryptedName = exports.decryptName = exports.checkIsDecrypted = exports.parseName = exports.encodeLabel = exports.checkLabel = exports.saveName = exports.saveLabel = exports.isEncodedLabelhash = exports.encodeLabelhash = exports.decodeLabelhash = exports.keccakFromString = exports.labelhash = void 0;
+const utils_1 = require("ethers/lib/utils");
+const format_1 = require("./format");
+const hasLocalStorage = typeof localStorage !== 'undefined';
+const labelhash = (input) => (0, utils_1.solidityKeccak256)(['string'], [input]);
+exports.labelhash = labelhash;
+const keccakFromString = (input) => (0, exports.labelhash)(input);
+exports.keccakFromString = keccakFromString;
+function decodeLabelhash(hash) {
+    if (!(hash.startsWith('[') && hash.endsWith(']'))) {
+        throw Error('Expected encoded labelhash to start and end with square brackets');
+    }
+    if (hash.length !== 66) {
+        throw Error('Expected encoded labelhash to have a length of 66');
+    }
+    return `0x${hash.slice(1, -1)}`;
+}
+exports.decodeLabelhash = decodeLabelhash;
+function encodeLabelhash(hash) {
+    if (!hash.startsWith('0x')) {
+        throw new Error('Expected label hash to start with 0x');
+    }
+    if (hash.length !== 66) {
+        throw new Error('Expected label hash to have a length of 66');
+    }
+    return `[${hash.slice(2)}]`;
+}
+exports.encodeLabelhash = encodeLabelhash;
+function isEncodedLabelhash(hash) {
+    return hash.startsWith('[') && hash.endsWith(']') && hash.length === 66;
+}
+exports.isEncodedLabelhash = isEncodedLabelhash;
+function getLabels() {
+    return hasLocalStorage
+        ? JSON.parse(localStorage.getItem('ensjs:labels')) || {}
+        : {};
+}
+function _saveLabel(hash, label) {
+    if (!hasLocalStorage)
+        return hash;
+    const labels = getLabels();
+    localStorage.setItem('ensjs:labels', JSON.stringify({
+        ...labels,
+        [hash]: label,
+    }));
+    return hash;
+}
+function saveLabel(label) {
+    const hash = `${(0, exports.labelhash)(label.toLowerCase())}`;
+    return _saveLabel(hash, label);
+}
+exports.saveLabel = saveLabel;
+function saveName(name) {
+    const nameArray = name.split('.');
+    nameArray.forEach((label) => {
+        saveLabel(label);
+    });
+}
+exports.saveName = saveName;
+// eslint-disable-next-line consistent-return
+function checkLabel(hash) {
+    const labels = getLabels();
+    if (isEncodedLabelhash(hash)) {
+        return labels[decodeLabelhash(hash)];
+    }
+    if (hash.startsWith('0x')) {
+        return labels[`${hash.slice(2)}`];
+    }
+}
+exports.checkLabel = checkLabel;
+function encodeLabel(label) {
+    try {
+        return encodeLabelhash(label);
+    }
+    catch {
+        return label;
+    }
+}
+exports.encodeLabel = encodeLabel;
+function parseName(name) {
+    const nameArray = name.split('.');
+    return nameArray.map((label) => encodeLabel(label)).join('.');
+}
+exports.parseName = parseName;
+function checkIsDecrypted(string) {
+    return !string?.includes('[');
+}
+exports.checkIsDecrypted = checkIsDecrypted;
+function decryptName(name) {
+    return name
+        .split('.')
+        .map((label) => checkLabel(label) || label)
+        .join('.');
+}
+exports.decryptName = decryptName;
+const truncateUndecryptedName = (name) => (0, format_1.truncateFormat)(name);
+exports.truncateUndecryptedName = truncateUndecryptedName;
+function checkLocalStorageSize() {
+    if (!hasLocalStorage)
+        return 'Empty (0 KB)';
+    let allStrings = '';
+    for (const key in window.localStorage) {
+        if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {
+            allStrings += window.localStorage[key];
+        }
+    }
+    return allStrings
+        ? `${3 + (allStrings.length * 16) / (8 * 1024)} KB`
+        : 'Empty (0 KB)';
+}
+exports.checkLocalStorageSize = checkLocalStorageSize;

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

@@ -0,0 +1,2 @@
+export declare const makeOtherIndexes: (data: string, findStr: string) => number[];
+export declare const makeNamehashIndexes: (data: string, name: string) => number[];

package/dist/cjs/utils/makeHashIndexes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNamehashIndexes = exports.makeOtherIndexes = void 0;
+const normalise_1 = require("./normalise");
+const makeOtherIndexes = (data, findStr) => Array.from(data.matchAll(findStr)).map((x) => x.index / 2 - 1);
+exports.makeOtherIndexes = makeOtherIndexes;
+const makeNamehashIndexes = (data, name) => Array.from(data.matchAll((0, normalise_1.namehash)(name).substring(2))).map((x) => x.index / 2 - 1);
+exports.makeNamehashIndexes = makeNamehashIndexes;

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

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

package/dist/cjs/utils/normalise.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.namehash = exports.normalise = void 0;
+const utils_1 = require("ethers/lib/utils");
+const uts46bundle_js_1 = __importDefault(require("idna-uts46-hx/uts46bundle.js"));
+const labels_1 = require("./labels");
+const zeros = new Uint8Array(32);
+zeros.fill(0);
+const normalise = (name) => name ? uts46bundle_js_1.default.toUnicode(name, { useStd3ASCII: true }) : name;
+exports.normalise = normalise;
+const namehash = (name) => {
+    let result = zeros;
+    if (name) {
+        const labels = name.split('.');
+        for (var i = labels.length - 1; i >= 0; i--) {
+            let labelSha;
+            if ((0, labels_1.isEncodedLabelhash)(labels[i])) {
+                labelSha = (0, labels_1.decodeLabelhash)(labels[i]);
+            }
+            else {
+                const normalised = (0, exports.normalise)(labels[i]);
+                labelSha = (0, utils_1.keccak256)((0, utils_1.toUtf8Bytes)(normalised));
+            }
+            result = (0, utils_1.keccak256)((0, utils_1.concat)([result, labelSha]));
+        }
+    }
+    else {
+        result = (0, utils_1.hexlify)(zeros);
+    }
+    return result;
+};
+exports.namehash = namehash;

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

@@ -0,0 +1,16 @@
+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 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/cjs/utils/recordHelpers.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRecordCallArray = exports.generateSingleRecordCall = exports.generateSetAddr = void 0;
+const address_encoder_1 = require("@ensdomains/address-encoder");
+const contentHash_1 = require("./contentHash");
+const generateSetAddr = (namehash, coinType, address, resolver) => {
+    let coinTypeInstance;
+    if (!isNaN(parseInt(coinType))) {
+        coinTypeInstance = address_encoder_1.formatsByCoinType[parseInt(coinType)];
+    }
+    else {
+        coinTypeInstance = address_encoder_1.formatsByName[coinType.toUpperCase()];
+    }
+    const inputCoinType = coinTypeInstance.coinType;
+    const encodedAddress = coinTypeInstance.decoder(address);
+    return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
+};
+exports.generateSetAddr = generateSetAddr;
+function generateSingleRecordCall(namehash, resolver, type) {
+    if (type === 'contentHash') {
+        return (_r) => {
+            const record = _r;
+            let _contentHash = '';
+            if (record !== _contentHash) {
+                const encoded = (0, contentHash_1.encodeContenthash)(record);
+                if (encoded.error)
+                    throw new Error(encoded.error);
+                _contentHash = encoded.encoded;
+            }
+            return resolver.interface.encodeFunctionData('setContenthash', [
+                namehash,
+                _contentHash,
+            ]);
+        };
+    }
+    else {
+        return (_r) => {
+            const record = _r;
+            if (type === 'text') {
+                return resolver.interface.encodeFunctionData('setText', [
+                    namehash,
+                    record.key,
+                    record.value,
+                ]);
+            }
+            else {
+                return (0, exports.generateSetAddr)(namehash, record.key, record.value, resolver);
+            }
+        };
+    }
+}
+exports.generateSingleRecordCall = generateSingleRecordCall;
+const generateRecordCallArray = (namehash, records, resolver) => {
+    const calls = [];
+    if (records.contentHash) {
+        const data = generateSingleRecordCall(namehash, resolver, 'contentHash')(records.contentHash);
+        data && calls.push(data);
+    }
+    if (records.texts && records.texts.length > 0) {
+        records.texts
+            .map(generateSingleRecordCall(namehash, resolver, 'text'))
+            .forEach((call) => calls.push(call));
+    }
+    if (records.coinTypes && records.coinTypes.length > 0) {
+        records.coinTypes
+            .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+            .forEach((call) => calls.push(call));
+    }
+    return calls;
+};
+exports.generateRecordCallArray = generateRecordCallArray;

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

@@ -0,0 +1,26 @@
+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/cjs/utils/registerHelpers.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._makeCommitment = exports.makeCommitment = exports.randomSecret = void 0;
+const ethers_1 = require("ethers");
+const generateFuseInput_1 = __importDefault(require("./generateFuseInput"));
+const labels_1 = require("./labels");
+const normalise_1 = require("./normalise");
+const recordHelpers_1 = require("./recordHelpers");
+const randomSecret = () => {
+    const bytes = Buffer.allocUnsafe(32);
+    return '0x' + crypto.getRandomValues(bytes).toString('hex');
+};
+exports.randomSecret = randomSecret;
+const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
+    const label = (0, labels_1.labelhash)(name.split('.')[0]);
+    const hash = (0, normalise_1.namehash)(name);
+    const resolverAddress = resolver.address;
+    const data = records ? (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver) : [];
+    const secret = (0, exports.randomSecret)();
+    const fuseData = fuses ? (0, generateFuseInput_1.default)(fuses) : '0';
+    const commitment = (0, exports._makeCommitment)({
+        labelhash: label,
+        owner,
+        duration,
+        secret,
+        resolver: resolverAddress,
+        data,
+        reverseRecord: !!reverseRecord,
+        fuses: fuseData,
+    });
+    return {
+        secret,
+        commitment,
+    };
+};
+exports.makeCommitment = makeCommitment;
+const _makeCommitment = ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }) => {
+    return ethers_1.utils.solidityKeccak256([
+        'bytes32',
+        'address',
+        'uint256',
+        'bytes32',
+        'address',
+        'bytes[]',
+        'bool',
+        'uint96',
+    ], [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses]);
+};
+exports._makeCommitment = _makeCommitment;

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

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

package/dist/cjs/utils/singleCall.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = async (provider, ensData, func, ...data) => func
+    .raw(ensData, ...data)
+    .then((rawData) => provider.call(rawData))
+    .catch(() => null)
+    .then((ret) => func.decode(ensData, ret, ...data));

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

@@ -0,0 +1,8 @@
+export declare const validateName: (name: string) => string;
+export declare const validateTLD: (name: string) => string;
+declare type InputType = {
+    type: 'name' | 'label' | 'address' | 'unknown';
+    info?: 'short' | 'supported' | 'unsupported';
+};
+export declare const parseInputType: (input: string) => InputType;
+export {};

package/dist/cjs/utils/validation.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInputType = exports.validateTLD = exports.validateName = void 0;
+const utils_1 = require("ethers/lib/utils");
+const labels_1 = require("./labels");
+const normalise_1 = require("./normalise");
+const validateName = (name) => {
+    const nameArray = name.split('.');
+    const hasEmptyLabels = nameArray.some((label) => label.length == 0);
+    if (hasEmptyLabels)
+        throw new Error('Name cannot have empty labels');
+    const normalizedArray = nameArray.map((label) => {
+        if (label === '[root]') {
+            return label;
+        }
+        else {
+            return (0, labels_1.isEncodedLabelhash)(label) ? label : (0, normalise_1.normalise)(label);
+        }
+    });
+    const normalizedName = normalizedArray.join('.');
+    (0, labels_1.saveName)(normalizedName);
+    return normalizedName;
+};
+exports.validateName = validateName;
+const validateTLD = (name) => {
+    const labels = name.split('.');
+    return (0, exports.validateName)(labels[labels.length - 1]);
+};
+exports.validateTLD = validateTLD;
+const parseInputType = (input) => {
+    const validTLD = (0, exports.validateTLD)(input);
+    let regex = /[^.]+$/;
+    try {
+        (0, exports.validateName)(input);
+    }
+    catch (e) {
+        return {
+            type: 'unknown',
+        };
+    }
+    if (input.indexOf('.') !== -1) {
+        const termArray = input.split('.');
+        const tld = input.match(regex) ? input.match(regex)[0] : '';
+        if (validTLD) {
+            if (tld === 'eth' && [...termArray[termArray.length - 2]].length < 3) {
+                // code-point length
+                return {
+                    type: 'name',
+                    info: 'short',
+                };
+            }
+            return {
+                type: 'name',
+                info: 'supported',
+            };
+        }
+        return {
+            type: 'name',
+            info: 'unsupported',
+        };
+    }
+    else if ((0, utils_1.isAddress)(input)) {
+        return {
+            type: 'address',
+        };
+    }
+    else {
+        return {
+            type: 'label',
+        };
+    }
+};
+exports.parseInputType = parseInputType;

package/dist/cjs/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 | undefined) => Promise<BigNumber>;

package/dist/cjs/utils/wrapperExpiry.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeExpiry = exports.MAX_EXPIRY = void 0;
+const ethers_1 = require("ethers");
+exports.MAX_EXPIRY = ethers_1.BigNumber.from(2).pow(64).sub(1);
+const makeExpiry = async ({ getExpiry }, name, expiry) => {
+    if (expiry) {
+        if (expiry instanceof Date) {
+            return ethers_1.BigNumber.from(expiry.getTime() / 1000);
+        }
+        else if (expiry instanceof ethers_1.BigNumber) {
+            return expiry;
+        }
+        else {
+            return ethers_1.BigNumber.from(expiry);
+        }
+    }
+    else {
+        if (name.endsWith('.eth')) {
+            const expResponse = await getExpiry(name);
+            if (!expResponse?.expiry)
+                throw new Error("Couldn't get expiry for name, please provide one.");
+            return ethers_1.BigNumber.from(expResponse.expiry.getTime() / 1000);
+        }
+        else {
+            return exports.MAX_EXPIRY;
+        }
+    }
+};
+exports.makeExpiry = makeExpiry;

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

@@ -0,0 +1,4 @@
+import { JsonRpcSigner } from '@ethersproject/providers';
+import type { PopulatedTransaction } from 'ethers';
+declare const _default: (signer: JsonRpcSigner, populate: boolean) => (tx: PopulatedTransaction) => PopulatedTransaction | Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+export default _default;

package/dist/cjs/utils/writeTx.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);

package/dist/esm/GqlManager.d.ts

@@ -0,0 +1,9 @@
+export declare const enter: (node: any) => any;
+export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
+export declare const responseMiddleware: (traverse: any) => (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

@@ -0,0 +1,74 @@
+// @ts-nocheck
+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) => {
+    if (node.kind === 'SelectionSet') {
+        const id = node.selections.find((x) => x.name && x.name.value === 'id');
+        const name = node.selections.find((x) => x.name && x.name.value === 'name');
+        if (!id && name) {
+            node.selections = [...node.selections, generateSelection('id')];
+            return node;
+        }
+    }
+};
+export const requestMiddleware = (visit, parse) => (request) => {
+    const requestBody = JSON.parse(request.body);
+    const rawQuery = requestBody.query;
+    const parsedQuery = parse(rawQuery);
+    const updatedQuery = visit(parsedQuery, { enter });
+    const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body };
+    return {
+        ...request,
+        body: JSON.stringify(updatedBody),
+    };
+};
+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 }] = await Promise.all([
+                    import('graphql-request'),
+                    import('traverse'),
+                    import('graphql/language'),
+                ]);
+                this.client = new imported.GraphQLClient(url, {
+                    requestMiddleware: requestMiddleware(visit, parse),
+                    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.d.ts

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

package/dist/esm/contracts/baseRegistrar.js

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

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

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

package/dist/esm/contracts/ethRegistrarController.js

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

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,16 @@
+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>;
+    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>;
+    getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
+    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").Multicall>;
+}