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

package/dist/esm/index.js

@@ -1,203 +0,0 @@
-import ContractManager from './contracts';
-import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
-import GqlManager from './GqlManager';
-import singleCall from './utils/singleCall';
-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',
-};
-export class ENS {
-    constructor(options) {
-        this.getContractAddress = _getContractAddress;
-        this.gqlInstance = new GqlManager();
-        /**
-         * 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
-         */
-        this.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
-         */
-        this.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
-         */
-        this.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 import(
-                /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true */
-                `./functions/${path}`);
-                // if combine isn't specified, run normally
-                // otherwise, create a function from the raw and decode functions
-                if (subFunc !== 'combine') {
-                    // get the function to call
-                    const func = subFunc && subFunc !== 'write'
-                        ? 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 (subFunc === 'write') {
-                        const options = (args[1] || {});
-                        const signer = options.signer ||
-                            thisRef.provider?.getSigner(options.addressOrIndex);
-                        if (!signer) {
-                            throw new Error('No signer specified');
-                        }
-                        delete options.addressOrIndex;
-                        delete options.signer;
-                        dependenciesToForward = { ...dependenciesToForward, signer };
-                        return func(dependenciesToForward, args[0], options);
-                    }
-                    // 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 singleCall(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 });
-            }
-            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
-         */
-        this.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
-         */
-        this.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
-         */
-        this.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
-         */
-        this.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 ContractManager(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
-         */
-        this.withProvider = (provider) => {
-            const newENS = new ENS(this.options);
-            newENS.initialProvider = provider;
-            return newENS;
-        };
-        this.batch = this.generateRawFunction('initialGetters', ['multicallWrapper'], 'batch');
-        this.getProfile = this.generateFunction('initialGetters', [
-            'contracts',
-            'gqlInstance',
-            'getName',
-            'resolverMulticallWrapper',
-            'multicallWrapper',
-            '_getAddr',
-            '_getContentHash',
-            '_getText',
-        ], 'getProfile');
-        this.getRecords = this.generateFunction('initialGetters', ['getProfile'], 'getRecords');
-        this.getName = this.generateRawFunction('initialGetters', ['contracts'], 'getName');
-        this.getResolver = this.generateRawFunction('getResolver', ['contracts']);
-        this.getFuses = this.generateRawFunction('getFuses', [
-            'contracts',
-        ]);
-        this.getHistory = this.generateFunction('getHistory', ['gqlInstance'], 'getHistory');
-        this.getHistoryWithDetail = this.generateFunction('getHistory', ['contracts', 'gqlInstance', 'provider'], 'getHistoryWithDetail');
-        this.getHistoryDetailForTransactionHash = this.generateFunction('getHistory', ['contracts', 'provider'], 'getHistoryDetailForTransactionHash');
-        this.getContentHash = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getContentHash');
-        this._getContentHash = this.generateRawFunction('initialGetters', ['contracts'], '_getContentHash');
-        this.getAddr = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getAddr');
-        this._getAddr = this.generateRawFunction('initialGetters', ['contracts'], '_getAddr');
-        this.getText = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getText');
-        this._getText = this.generateRawFunction('initialGetters', ['contracts'], '_getText');
-        this.getOwner = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getOwner');
-        this.getExpiry = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getExpiry');
-        this.getSubnames = this.generateFunction('initialGetters', ['gqlInstance'], 'getSubnames');
-        this.getNames = this.generateFunction('initialGetters', ['gqlInstance'], 'getNames');
-        this.getPrice = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getPrice');
-        this.universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
-        this.resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
-        this.multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
-        this.setName = this.generateWriteFunction('setName', [
-            'contracts',
-        ]);
-        this.setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
-        this.setResolver = this.generateWriteFunction('setResolver', ['contracts']);
-        this.transferName = this.generateWriteFunction('transferName', ['contracts']);
-        this.wrapName = this.generateWriteFunction('wrapName', [
-            'contracts',
-        ]);
-        this.unwrapName = this.generateWriteFunction('unwrapName', ['contracts']);
-        this.burnFuses = this.generateWriteFunction('burnFuses', [
-            'contracts',
-        ]);
-        this.createSubname = this.generateWriteFunction('createSubname', ['contracts']);
-        this.deleteSubname = this.generateWriteFunction('deleteSubname', ['transferSubname']);
-        this.transferSubname = this.generateWriteFunction('transferSubname', ['contracts']);
-        this.getDNSOwner = this.generateFunction('getDNSOwner', []);
-        this.options = options;
-        this.getContractAddress = options?.getContractAddress || _getContractAddress;
-    }
-}

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

@@ -1,28 +0,0 @@
-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/esm/utils/contentHash.js

@@ -1,153 +0,0 @@
-import contentHash from '@ensdomains/content-hash';
-import { utils } from '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)\/(.*)/));
-}
-export 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 = contentHash.decode(encoded);
-            const codec = contentHash.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 };
-}
-export function validateContent(encoded) {
-    return (contentHash.isHashOfType(encoded, contentHash.Types.ipfs) ||
-        contentHash.isHashOfType(encoded, contentHash.Types.swarm));
-}
-export function isValidContenthash(encoded) {
-    try {
-        const codec = contentHash.getCodec(encoded);
-        return utils.isHexString(encoded) && supportedCodecs.includes(codec);
-    }
-    catch (e) {
-        console.log(e);
-    }
-}
-export 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);
-    }
-}
-export 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' + contentHash.encode('ipfs-ns', content);
-                }
-            }
-            else if (contentType === 'ipns') {
-                encoded = '0x' + contentHash.encode('ipns-ns', content);
-            }
-            else if (contentType === 'bzz') {
-                if (content.length >= 4) {
-                    encoded = '0x' + contentHash.fromSwarm(content);
-                }
-            }
-            else if (contentType === 'onion') {
-                if (content.length == 16) {
-                    encoded = '0x' + contentHash.encode('onion', content);
-                }
-            }
-            else if (contentType === 'onion3') {
-                if (content.length == 56) {
-                    encoded = '0x' + contentHash.encode('onion3', content);
-                }
-            }
-            else if (contentType === 'sia') {
-                if (content.length == 46) {
-                    encoded = '0x' + contentHash.encode('skynet-ns', content);
-                }
-            }
-            else if (contentType === 'arweave') {
-                if (content.length == 43) {
-                    encoded = '0x' + contentHash.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 };
-}

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

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

package/dist/esm/utils/createReverseNode.js

@@ -1 +0,0 @@
-export default (address) => address.toLowerCase().substring(2) + '.addr.reverse';

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

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

package/dist/esm/utils/format.js

@@ -1,3 +0,0 @@
-export const formatHashed = (name) => name.replace(/(\[)(.{64})(\])/g, '0x$2');
-export const truncateFormat = (name) => name.replace(/(\[.{3})(.{58})(.{3}\])/g, '$1...$3');
-export const bracketFormat = (name) => name.replace(/(0x)(.{64})(?=\.)/g, '[$2]');

package/dist/esm/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/esm/utils/fuses.js

@@ -1,21 +0,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;
-export const testable = {
-    CANNOT_UNWRAP,
-    CANNOT_BURN_FUSES,
-    CANNOT_TRANSFER,
-    CANNOT_SET_RESOLVER,
-    CANNOT_SET_TTL,
-    CANNOT_CREATE_SUBDOMAIN,
-    PARENT_CANNOT_CONTROL,
-};
-export default {
-    ...testable,
-    CAN_DO_EVERYTHING,
-};

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

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

package/dist/esm/utils/generateFuseInput.js

@@ -1,14 +0,0 @@
-import { ethers } from 'ethers';
-import fuses from './fuses';
-export 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[curr]);
-    }, ethers.BigNumber.from(0));
-    return bigNumberFuses.toHexString();
-};

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

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

package/dist/esm/utils/hexEncodedName.js

@@ -1,2 +0,0 @@
-import packet from 'dns-packet';
-export const hexEncodeName = (name) => `0x${packet.name.encode(name).toString('hex')}`;

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

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

package/dist/esm/utils/labels.js

@@ -1,95 +0,0 @@
-import { solidityKeccak256 } from 'ethers/lib/utils';
-import { truncateFormat } from './format';
-export const labelhash = (input) => solidityKeccak256(['string'], [input]);
-export const keccakFromString = (input) => labelhash(input);
-export 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 `${hash.slice(1, -1)}`;
-}
-export 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)}]`;
-}
-export function isEncodedLabelhash(hash) {
-    return hash.startsWith('[') && hash.endsWith(']') && hash.length === 66;
-}
-function getLabels() {
-    return localStorage
-        ? JSON.parse(localStorage.getItem('ensjs:labels')) || {}
-        : {};
-}
-function _saveLabel(hash, label) {
-    if (!localStorage)
-        return hash;
-    const labels = getLabels();
-    localStorage.setItem('ensjs:labels', JSON.stringify({
-        ...labels,
-        [hash]: label,
-    }));
-    return hash;
-}
-export function saveLabel(label) {
-    const hash = `${labelhash(label.toLowerCase())}`;
-    return _saveLabel(hash, label);
-}
-export function saveName(name) {
-    const nameArray = name.split('.');
-    nameArray.forEach((label) => {
-        saveLabel(label);
-    });
-}
-// eslint-disable-next-line consistent-return
-export function checkLabel(hash) {
-    const labels = getLabels();
-    if (isEncodedLabelhash(hash)) {
-        return labels[decodeLabelhash(hash)];
-    }
-    if (hash.startsWith('0x')) {
-        return labels[`${hash.slice(2)}`];
-    }
-}
-export function encodeLabel(label) {
-    try {
-        return encodeLabelhash(label);
-    }
-    catch {
-        return label;
-    }
-}
-export function parseName(name) {
-    const nameArray = name.split('.');
-    return nameArray.map((label) => encodeLabel(label)).join('.');
-}
-export function checkIsDecrypted(string) {
-    return !string?.includes('[');
-}
-export function decryptName(name) {
-    return name
-        .split('.')
-        .map((label) => checkLabel(label) || label)
-        .join('.');
-}
-export const truncateUndecryptedName = (name) => truncateFormat(name);
-export function checkLocalStorageSize() {
-    if (!localStorage)
-        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)';
-}

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

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

package/dist/esm/utils/makeHashIndexes.js

@@ -1,3 +0,0 @@
-import { namehash } from './normalise';
-export const makeOtherIndexes = (data, findStr) => Array.from(data.matchAll(findStr)).map((x) => x.index / 2 - 1);
-export const makeNamehashIndexes = (data, name) => Array.from(data.matchAll(namehash(name).substring(2))).map((x) => x.index / 2 - 1);

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

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

package/dist/esm/utils/normalise.js

@@ -1,20 +0,0 @@
-import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils';
-import uts46 from 'idna-uts46-hx/uts46bundle.js';
-const zeros = new Uint8Array(32);
-zeros.fill(0);
-export const normalise = (name) => name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name;
-export const namehash = (inputName) => {
-    let result = zeros;
-    const name = normalise(inputName);
-    if (name) {
-        const labels = name.split('.');
-        for (var i = labels.length - 1; i >= 0; i--) {
-            const labelSha = keccak256(toUtf8Bytes(labels[i]));
-            result = keccak256(concat([result, labelSha]));
-        }
-    }
-    else {
-        result = hexlify(zeros);
-    }
-    return result;
-};

package/dist/esm/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 {};