@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.10

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

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

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

package/dist/esm/utils/createReverseNode.js

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

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

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

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

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

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

package/dist/esm/utils/generateFuseInput.js

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

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

package/dist/esm/utils/hexEncodedName.js

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

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

package/dist/esm/utils/labels.js

@@ -0,0 +1,96 @@
+import { solidityKeccak256 } from 'ethers/lib/utils';
+import { truncateFormat } from './format';
+const hasLocalStorage = typeof localStorage !== 'undefined';
+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 `0x${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 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;
+}
+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 (!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)';
+}

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

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

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

package/dist/esm/utils/normalise.js

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

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

@@ -0,0 +1,65 @@
+import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder';
+import { encodeContenthash } from './contentHash';
+export const generateSetAddr = (namehash, coinType, address, resolver) => {
+    let coinTypeInstance;
+    if (!isNaN(parseInt(coinType))) {
+        coinTypeInstance = formatsByCoinType[parseInt(coinType)];
+    }
+    else {
+        coinTypeInstance = formatsByName[coinType.toUpperCase()];
+    }
+    const inputCoinType = coinTypeInstance.coinType;
+    const encodedAddress = coinTypeInstance.decoder(address);
+    return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
+};
+export function generateSingleRecordCall(namehash, resolver, type) {
+    if (type === 'contentHash') {
+        return (_r) => {
+            const record = _r;
+            let _contentHash = '';
+            if (record !== _contentHash) {
+                const encoded = 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 generateSetAddr(namehash, record.key, record.value, resolver);
+            }
+        };
+    }
+}
+export 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;
+};

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

@@ -0,0 +1,43 @@
+import { utils } from 'ethers';
+import generateFuseInput from './generateFuseInput';
+import { labelhash } from './labels';
+import { namehash } from './normalise';
+import { generateRecordCallArray } from './recordHelpers';
+export const randomSecret = () => {
+    const bytes = Buffer.allocUnsafe(32);
+    return '0x' + crypto.getRandomValues(bytes).toString('hex');
+};
+export const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
+    const label = labelhash(name.split('.')[0]);
+    const hash = namehash(name);
+    const resolverAddress = resolver.address;
+    const data = records ? generateRecordCallArray(hash, records, resolver) : [];
+    const secret = randomSecret();
+    const fuseData = fuses ? generateFuseInput(fuses) : '0';
+    const commitment = _makeCommitment({
+        labelhash: label,
+        owner,
+        duration,
+        secret,
+        resolver: resolverAddress,
+        data,
+        reverseRecord: !!reverseRecord,
+        fuses: fuseData,
+    });
+    return {
+        secret,
+        commitment,
+    };
+};
+export const _makeCommitment = ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }) => {
+    return utils.solidityKeccak256([
+        'bytes32',
+        'address',
+        'uint256',
+        'bytes32',
+        'address',
+        'bytes[]',
+        'bool',
+        'uint96',
+    ], [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses]);
+};

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

@@ -0,0 +1,5 @@
+export 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/esm/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/esm/utils/validation.js

@@ -0,0 +1,67 @@
+import { isAddress } from 'ethers/lib/utils';
+import { isEncodedLabelhash, saveName } from './labels';
+import { normalise } from './normalise';
+export 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 isEncodedLabelhash(label) ? label : normalise(label);
+        }
+    });
+    const normalizedName = normalizedArray.join('.');
+    saveName(normalizedName);
+    return normalizedName;
+};
+export const validateTLD = (name) => {
+    const labels = name.split('.');
+    return validateName(labels[labels.length - 1]);
+};
+export const parseInputType = (input) => {
+    const validTLD = validateTLD(input);
+    let regex = /[^.]+$/;
+    try {
+        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 (isAddress(input)) {
+        return {
+            type: 'address',
+        };
+    }
+    else {
+        return {
+            type: 'label',
+        };
+    }
+};