@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.10

package/dist/cjs/index.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENS = void 0;
+const contracts_1 = __importDefault(require("./contracts"));
+const getContractAddress_1 = require("./contracts/getContractAddress");
+const GqlManager_1 = __importDefault(require("./GqlManager"));
+const singleCall_1 = __importDefault(require("./utils/singleCall"));
+const writeTx_1 = __importDefault(require("./utils/writeTx"));
+const graphURIEndpoints = {
+    1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
+    3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
+    4: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensrinkeby',
+    5: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensgoerli',
+};
+class ENS {
+    options;
+    provider;
+    graphURI;
+    initialProvider;
+    contracts;
+    getContractAddress = getContractAddress_1.getContractAddress;
+    gqlInstance = new GqlManager_1.default();
+    constructor(options) {
+        this.options = options;
+        this.getContractAddress = options?.getContractAddress || getContractAddress_1.getContractAddress;
+    }
+    /**
+     * 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
+     */
+    checkInitialProvider = async () => {
+        if (!this.initialProvider) {
+            return;
+        }
+        await this.setProvider(this.initialProvider);
+        return;
+    };
+    /**
+     * Creates an object of ENS properties from an array
+     * @param {FunctionDeps} dependencies - An array of ENS properties
+     * @returns {Object} - An object of ENS properties
+     */
+    forwardDependenciesFromArray = (dependencies) => 
+    // Creates an object from entries of the array
+    Object.fromEntries(
+    // Maps over dependencies and create arrays for each, e.g. ['contracts', contractObj]
+    dependencies.map((dep) => [dep, this[dep]]));
+    /**
+     * 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
+     */
+    importGenerator = (path, dependencies, exportName = 'default', subFunc, passthrough) => {
+        // if batch is specified, create batch func
+        if (subFunc === 'batch') {
+            return (...args) => ({ args, ...passthrough });
+        }
+        const thisRef = this;
+        const mainFunc = async function (...args) {
+            // check the initial provider and set if it exists
+            await thisRef.checkInitialProvider();
+            // import the module dynamically
+            const mod = await Promise.resolve().then(() => __importStar(require(
+            /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
+            `./functions/${path}`)));
+            // if combine isn't specified, run normally
+            // otherwise, create a function from the raw and decode functions
+            if (subFunc !== 'combine') {
+                const writeable = subFunc === 'write' || subFunc === 'populateTransaction';
+                // get the function to call
+                const func = subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName];
+                // get the dependencies to forward to the function as the first arg
+                let dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
+                // if func is write func, inject signer into dependencies
+                if (writeable) {
+                    const options = (args[1] || {});
+                    const signer = options.signer ||
+                        thisRef.provider?.getSigner(options.addressOrIndex);
+                    const populate = subFunc === 'populateTransaction';
+                    if (!signer) {
+                        throw new Error('No signer specified');
+                    }
+                    delete options.addressOrIndex;
+                    delete options.signer;
+                    dependenciesToForward = { ...dependenciesToForward, signer };
+                    return func(dependenciesToForward, args[0], options).then((0, writeTx_1.default)(signer, populate));
+                }
+                // return the function with the dependencies forwarded
+                return func(dependenciesToForward, ...args);
+            }
+            else {
+                // get the dependencies to forward from raw and decode functions
+                const dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
+                // return singleCall function with dependencies forwarded
+                return (0, singleCall_1.default)(thisRef.provider, dependenciesToForward, mod[exportName], ...args);
+            }
+        };
+        // if subfunc is combine, add raw and decode property methods to the function
+        if (subFunc === 'combine') {
+            mainFunc.raw = this.importGenerator(path, dependencies, exportName, 'raw');
+            mainFunc.decode = this.importGenerator(path, dependencies, exportName, 'decode');
+            mainFunc.batch = this.importGenerator(path, dependencies, exportName, 'batch', { raw: mainFunc.raw, decode: mainFunc.decode });
+        }
+        else if (subFunc === 'write') {
+            mainFunc.populateTransaction = this.importGenerator(path, dependencies, exportName, 'populateTransaction');
+        }
+        return mainFunc;
+    };
+    /**
+     * 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
+     */
+    generateFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName);
+    /**
+     * 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
+     */
+    generateWriteFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName, 'write');
+    /**
+     * 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
+     */
+    generateRawFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName, 'combine');
+    /**
+     * 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 = async (provider) => {
+        this.provider = provider;
+        const network = (await this.provider.getNetwork()).chainId;
+        if (this.options && this.options.graphURI) {
+            this.graphURI = this.options.graphURI;
+        }
+        else {
+            this.graphURI = graphURIEndpoints[network];
+        }
+        await this.gqlInstance.setUrl(this.graphURI);
+        this.contracts = new contracts_1.default(this.provider, this.getContractAddress(String(network)));
+        return;
+    };
+    /**
+     * 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) => {
+        const newENS = new ENS(this.options);
+        newENS.initialProvider = provider;
+        return newENS;
+    };
+    batch = this.generateRawFunction('initialGetters', ['multicallWrapper'], 'batch');
+    getProfile = this.generateFunction('initialGetters', [
+        'contracts',
+        'gqlInstance',
+        'getName',
+        'resolverMulticallWrapper',
+        'multicallWrapper',
+        '_getAddr',
+        '_getContentHash',
+        '_getText',
+    ], 'getProfile');
+    getRecords = this.generateFunction('initialGetters', ['getProfile'], 'getRecords');
+    getName = this.generateRawFunction('initialGetters', ['contracts'], 'getName');
+    getResolver = this.generateRawFunction('getResolver', ['contracts']);
+    getFuses = this.generateRawFunction('getFuses', [
+        'contracts',
+    ]);
+    getHistory = this.generateFunction('getHistory', ['gqlInstance'], 'getHistory');
+    getHistoryWithDetail = this.generateFunction('getHistory', ['contracts', 'gqlInstance', 'provider'], 'getHistoryWithDetail');
+    getHistoryDetailForTransactionHash = this.generateFunction('getHistory', ['contracts', 'provider'], 'getHistoryDetailForTransactionHash');
+    getContentHash = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getContentHash');
+    _getContentHash = this.generateRawFunction('initialGetters', ['contracts'], '_getContentHash');
+    getAddr = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getAddr');
+    _getAddr = this.generateRawFunction('initialGetters', ['contracts'], '_getAddr');
+    getText = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getText');
+    _getText = this.generateRawFunction('initialGetters', ['contracts'], '_getText');
+    getOwner = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getOwner');
+    getExpiry = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getExpiry');
+    getSubnames = this.generateFunction('initialGetters', ['gqlInstance'], 'getSubnames');
+    getNames = this.generateFunction('initialGetters', ['gqlInstance'], 'getNames');
+    getPrice = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getPrice');
+    universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
+    resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
+    multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
+    setName = this.generateWriteFunction('setName', [
+        'contracts',
+    ]);
+    setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
+    setRecord = this.generateWriteFunction('setRecord', [
+        'contracts',
+        'provider',
+        'getResolver',
+    ]);
+    setResolver = this.generateWriteFunction('setResolver', ['contracts']);
+    transferName = this.generateWriteFunction('transferName', ['contracts']);
+    wrapName = this.generateWriteFunction('wrapName', [
+        'contracts',
+    ]);
+    unwrapName = this.generateWriteFunction('unwrapName', ['contracts']);
+    burnFuses = this.generateWriteFunction('burnFuses', [
+        'contracts',
+    ]);
+    createSubname = this.generateWriteFunction('createSubname', ['contracts']);
+    deleteSubname = this.generateWriteFunction('deleteSubname', ['transferSubname']);
+    transferSubname = this.generateWriteFunction('transferSubname', ['contracts']);
+    getDNSOwner = this.generateFunction('getDNSOwner', []);
+}
+exports.ENS = ENS;

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

@@ -0,0 +1,28 @@
+export declare type DecodedContentHash = {
+    protocolType?: any;
+    decoded?: any;
+    error?: any;
+};
+export declare function decodeContenthash(encoded: any): {
+    protocolType?: undefined;
+    decoded?: undefined;
+    error?: undefined;
+} | {
+    protocolType: null;
+    decoded: any;
+    error?: undefined;
+} | {
+    protocolType: string | undefined;
+    decoded: any;
+    error: any;
+};
+export declare function validateContent(encoded: any): any;
+export declare function isValidContenthash(encoded: any): boolean | undefined;
+export declare function getProtocolType(encoded: any): {
+    protocolType: string | undefined;
+    decoded: string | undefined;
+} | undefined;
+export declare function encodeContenthash(text: string): {
+    encoded: string | boolean;
+    error: string | undefined;
+};

package/dist/cjs/utils/contentHash.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeContenthash = exports.getProtocolType = exports.isValidContenthash = exports.validateContent = exports.decodeContenthash = void 0;
+const content_hash_1 = __importDefault(require("@ensdomains/content-hash"));
+const ethers_1 = require("ethers");
+const supportedCodecs = [
+    'ipns-ns',
+    'ipfs-ns',
+    'swarm-ns',
+    'onion',
+    'onion3',
+    'skynet-ns',
+    'arweave-ns',
+];
+function matchProtocol(text) {
+    return (text.match(/^(ipfs|sia|ipns|bzz|onion|onion3|arweave):\/\/(.*)/) ||
+        text.match(/\/(ipfs)\/(.*)/) ||
+        text.match(/\/(ipns)\/(.*)/));
+}
+function decodeContenthash(encoded) {
+    let decoded, protocolType, error;
+    if (!encoded || encoded === '0x') {
+        return {};
+    }
+    if (encoded.error) {
+        return { protocolType: null, decoded: encoded.error };
+    }
+    else if (encoded === false) {
+        return { protocolType: null, decoded: 'invalid value' };
+    }
+    if (encoded) {
+        try {
+            decoded = content_hash_1.default.decode(encoded);
+            const codec = content_hash_1.default.getCodec(encoded);
+            if (codec === 'ipfs-ns') {
+                protocolType = 'ipfs';
+            }
+            else if (codec === 'ipns-ns') {
+                protocolType = 'ipns';
+            }
+            else if (codec === 'swarm-ns') {
+                protocolType = 'bzz';
+            }
+            else if (codec === 'onion') {
+                protocolType = 'onion';
+            }
+            else if (codec === 'onion3') {
+                protocolType = 'onion3';
+            }
+            else if (codec === 'skynet-ns') {
+                protocolType = 'sia';
+            }
+            else if (codec === 'arweave-ns') {
+                protocolType = 'arweave';
+            }
+            else {
+                decoded = encoded;
+            }
+        }
+        catch (e) {
+            error = e.message;
+        }
+    }
+    return { protocolType, decoded, error };
+}
+exports.decodeContenthash = decodeContenthash;
+function validateContent(encoded) {
+    return (content_hash_1.default.isHashOfType(encoded, content_hash_1.default.Types.ipfs) ||
+        content_hash_1.default.isHashOfType(encoded, content_hash_1.default.Types.swarm));
+}
+exports.validateContent = validateContent;
+function isValidContenthash(encoded) {
+    try {
+        const codec = content_hash_1.default.getCodec(encoded);
+        return ethers_1.utils.isHexString(encoded) && supportedCodecs.includes(codec);
+    }
+    catch (e) {
+        console.log(e);
+    }
+}
+exports.isValidContenthash = isValidContenthash;
+function getProtocolType(encoded) {
+    let protocolType, decoded;
+    try {
+        let matched = matchProtocol(encoded);
+        if (matched) {
+            protocolType = matched[1];
+            decoded = matched[2];
+        }
+        return {
+            protocolType,
+            decoded,
+        };
+    }
+    catch (e) {
+        console.log(e);
+    }
+}
+exports.getProtocolType = getProtocolType;
+function encodeContenthash(text) {
+    let content = text;
+    let contentType;
+    let encoded = false;
+    let error;
+    if (!!text) {
+        let matched = matchProtocol(text);
+        if (matched) {
+            contentType = matched[1];
+            content = matched[2];
+        }
+        try {
+            if (contentType === 'ipfs') {
+                if (content.length >= 4) {
+                    encoded = '0x' + content_hash_1.default.encode('ipfs-ns', content);
+                }
+            }
+            else if (contentType === 'ipns') {
+                encoded = '0x' + content_hash_1.default.encode('ipns-ns', content);
+            }
+            else if (contentType === 'bzz') {
+                if (content.length >= 4) {
+                    encoded = '0x' + content_hash_1.default.fromSwarm(content);
+                }
+            }
+            else if (contentType === 'onion') {
+                if (content.length == 16) {
+                    encoded = '0x' + content_hash_1.default.encode('onion', content);
+                }
+            }
+            else if (contentType === 'onion3') {
+                if (content.length == 56) {
+                    encoded = '0x' + content_hash_1.default.encode('onion3', content);
+                }
+            }
+            else if (contentType === 'sia') {
+                if (content.length == 46) {
+                    encoded = '0x' + content_hash_1.default.encode('skynet-ns', content);
+                }
+            }
+            else if (contentType === 'arweave') {
+                if (content.length == 43) {
+                    encoded = '0x' + content_hash_1.default.encode('arweave-ns', content);
+                }
+            }
+            else {
+                console.warn('Unsupported protocol or invalid value', {
+                    contentType,
+                    text,
+                });
+            }
+        }
+        catch (err) {
+            const errorMessage = 'Error encoding content hash';
+            console.warn(errorMessage, { text, encoded });
+            error = errorMessage;
+            //throw 'Error encoding content hash'
+        }
+    }
+    return { encoded, error };
+}
+exports.encodeContenthash = encodeContenthash;

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

@@ -0,0 +1,2 @@
+declare const _default: (address: string) => string;
+export default _default;

package/dist/cjs/utils/createReverseNode.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (address) => address.toLowerCase().substring(2) + '.addr.reverse';

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

@@ -0,0 +1,3 @@
+export declare const formatHashed: (name: string) => string;
+export declare const truncateFormat: (name: string) => string;
+export declare const bracketFormat: (name: string) => string;

package/dist/cjs/utils/format.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bracketFormat = exports.truncateFormat = exports.formatHashed = void 0;
+const formatHashed = (name) => name.replace(/(\[)(.{64})(\])/g, '0x$2');
+exports.formatHashed = formatHashed;
+const truncateFormat = (name) => name.replace(/(\[.{3})(.{58})(.{3}\])/g, '$1...$3');
+exports.truncateFormat = truncateFormat;
+const bracketFormat = (name) => name.replace(/(0x)(.{64})(?=\.)/g, '[$2]');
+exports.bracketFormat = bracketFormat;

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

@@ -0,0 +1,20 @@
+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/fuses.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testable = void 0;
+const CANNOT_UNWRAP = 1;
+const CANNOT_BURN_FUSES = 2;
+const CANNOT_TRANSFER = 4;
+const CANNOT_SET_RESOLVER = 8;
+const CANNOT_SET_TTL = 16;
+const CANNOT_CREATE_SUBDOMAIN = 32;
+const PARENT_CANNOT_CONTROL = 64;
+const CAN_DO_EVERYTHING = 0;
+exports.testable = {
+    CANNOT_UNWRAP,
+    CANNOT_BURN_FUSES,
+    CANNOT_TRANSFER,
+    CANNOT_SET_RESOLVER,
+    CANNOT_SET_TTL,
+    CANNOT_CREATE_SUBDOMAIN,
+    PARENT_CANNOT_CONTROL,
+};
+exports.default = {
+    ...exports.testable,
+    CAN_DO_EVERYTHING,
+};

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

@@ -0,0 +1,3 @@
+import { FuseOptions } from '../@types/FuseOptions';
+declare const _default: (fuseOptions: FuseOptions) => string;
+export default _default;

package/dist/cjs/utils/generateFuseInput.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const fuses_1 = __importDefault(require("./fuses"));
+exports.default = (fuseOptions) => {
+    const fuseKeys = Object.keys(fuseOptions)
+        .filter((opt) => fuseOptions[opt] === true)
+        .map((opt) => opt
+        .split(/(?=[A-Z])/)
+        .join('_')
+        .toUpperCase());
+    const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
+        return prev.or(fuses_1.default[curr]);
+    }, ethers_1.ethers.BigNumber.from(0));
+    return bigNumberFuses.toHexString();
+};

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

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

package/dist/cjs/utils/hexEncodedName.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexEncodeName = void 0;
+const dns_packet_1 = __importDefault(require("dns-packet"));
+const hexEncodeName = (name) => `0x${dns_packet_1.default.name.encode(name).toString('hex')}`;
+exports.hexEncodeName = hexEncodeName;

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

@@ -0,0 +1,14 @@
+export declare const labelhash: (input: string) => string;
+export declare const keccakFromString: (input: string) => string;
+export declare function decodeLabelhash(hash: string): string;
+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 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;