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

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,21 +0,0 @@
-export declare const fuseEnum: {
-    readonly CANNOT_UNWRAP: 1;
-    readonly CANNOT_BURN_FUSES: 2;
-    readonly CANNOT_TRANSFER: 4;
-    readonly CANNOT_SET_RESOLVER: 8;
-    readonly CANNOT_SET_TTL: 16;
-    readonly CANNOT_CREATE_SUBDOMAIN: 32;
-    readonly PARENT_CANNOT_CONTROL: 64;
-};
-export declare const unnamedFuses: readonly [128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296];
-declare const fullFuseEnum: {
-    CAN_DO_EVERYTHING: number;
-    CANNOT_UNWRAP: 1;
-    CANNOT_BURN_FUSES: 2;
-    CANNOT_TRANSFER: 4;
-    CANNOT_SET_RESOLVER: 8;
-    CANNOT_SET_TTL: 16;
-    CANNOT_CREATE_SUBDOMAIN: 32;
-    PARENT_CANNOT_CONTROL: 64;
-};
-export default fullFuseEnum;

package/dist/esm/utils/fuses.js

@@ -1,27 +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 fuseEnum = {
-    CANNOT_UNWRAP,
-    CANNOT_BURN_FUSES,
-    CANNOT_TRANSFER,
-    CANNOT_SET_RESOLVER,
-    CANNOT_SET_TTL,
-    CANNOT_CREATE_SUBDOMAIN,
-    PARENT_CANNOT_CONTROL,
-};
-export const unnamedFuses = [
-    128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
-    524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864,
-    134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296,
-];
-const fullFuseEnum = {
-    ...fuseEnum,
-    CAN_DO_EVERYTHING,
-};
-export default fullFuseEnum;

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

@@ -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: (name: string) => string;

package/dist/esm/utils/normalise.js

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

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

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

@@ -1,54 +0,0 @@
-import type { FuseOptions } from '../@types/FuseOptions';
-import type { PublicResolver } from '../generated';
-import { RecordOptions } from './recordHelpers';
-export declare type RegistrationParams = {
-    name: string;
-    owner: string;
-    duration: number;
-    secret: string;
-    resolver: PublicResolver;
-    records?: RecordOptions;
-    reverseRecord?: boolean;
-    fuses?: FuseOptions;
-    wrapperExpiry: number;
-};
-export declare type CommitmentParams = Omit<RegistrationParams, 'secret' | 'wrapperExpiry'> & {
-    secret?: string;
-    wrapperExpiry?: number;
-};
-export declare type RegistrationTuple = [
-    name: string,
-    owner: string,
-    duration: number,
-    secret: string,
-    resolver: string,
-    data: string[],
-    reverseRecord: boolean,
-    fuses: string,
-    wrapperExpiry: number
-];
-export declare type CommitmentTuple = [
-    labelhash: string,
-    owner: string,
-    duration: number,
-    resolver: string,
-    data: string[],
-    secret: string,
-    reverseRecord: boolean,
-    fuses: string,
-    wrapperExpiry: number
-];
-export declare const randomSecret: () => string;
-export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }: Omit<RegistrationParams, "secret" | "wrapperExpiry"> & {
-    secret?: string | undefined;
-    wrapperExpiry?: number | undefined;
-} & {
-    secret: string;
-}) => CommitmentTuple;
-export declare const makeRegistrationData: (params: RegistrationParams) => RegistrationTuple;
-export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
-    secret: string;
-    commitment: string;
-    wrapperExpiry: number;
-};
-export declare const _makeCommitment: (params: CommitmentTuple) => string;

package/dist/esm/utils/registerHelpers.js

@@ -1,69 +0,0 @@
-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 makeCommitmentData = ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }) => {
-    const label = labelhash(name.split('.')[0]);
-    const hash = namehash(name);
-    const resolverAddress = resolver.address;
-    const fuseData = fuses ? generateFuseInput(fuses) : '0';
-    if (reverseRecord) {
-        if (!records) {
-            records = { coinTypes: [{ key: 'ETH', value: owner }] };
-        }
-        else if (!records.coinTypes?.find((c) => c.key === 'ETH')) {
-            if (!records.coinTypes)
-                records.coinTypes = [];
-            records.coinTypes.push({ key: 'ETH', value: owner });
-        }
-    }
-    const data = records ? generateRecordCallArray(hash, records, resolver) : [];
-    return [
-        label,
-        owner,
-        duration,
-        resolverAddress,
-        data,
-        secret,
-        !!reverseRecord,
-        fuseData,
-        wrapperExpiry || Math.floor(Date.now() / 1000) + duration,
-    ];
-};
-export const makeRegistrationData = (params) => {
-    const commitmentData = makeCommitmentData(params);
-    commitmentData[0] = params.name.split('.')[0];
-    const secret = commitmentData.splice(5, 1)[0];
-    commitmentData.splice(3, 0, secret);
-    return commitmentData;
-};
-export const makeCommitment = ({ secret = randomSecret(), ...inputParams }) => {
-    const generatedParams = makeCommitmentData({
-        ...inputParams,
-        secret,
-    });
-    const commitment = _makeCommitment(generatedParams);
-    return {
-        secret,
-        commitment,
-        wrapperExpiry: generatedParams[8],
-    };
-};
-export const _makeCommitment = (params) => {
-    return utils.keccak256(utils.defaultAbiCoder.encode([
-        'bytes32',
-        'address',
-        'uint256',
-        'address',
-        'bytes[]',
-        'bytes32',
-        'bool',
-        'uint32',
-        'uint64',
-    ], params));
-};

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

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

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

@@ -1,8 +0,0 @@
-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 {};