multichain-address-validator 0.7.2 → 0.7.4

package/dist/crypto/segwit_addr.js

@@ -1,102 +0,0 @@
-// Copyright (c) 2017, 2021 Pieter Wuille
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-import bech32 from './bech32';
-function convertbits(data, frombits, tobits, pad) {
-    var acc = 0;
-    var bits = 0;
-    var ret = [];
-    var maxv = (1 << tobits) - 1;
-    for (var p = 0; p < data.length; ++p) {
-        var value = data[p];
-        if (value < 0 || (value >> frombits) !== 0) {
-            return null;
-        }
-        acc = (acc << frombits) | value;
-        bits += frombits;
-        while (bits >= tobits) {
-            bits -= tobits;
-            ret.push((acc >> bits) & maxv);
-        }
-    }
-    if (pad) {
-        if (bits > 0) {
-            ret.push((acc << (tobits - bits)) & maxv);
-        }
-    }
-    else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
-        return null;
-    }
-    return ret;
-}
-function decode(hrp, addr) {
-    var bech32m = false;
-    var dec = bech32.decode(addr, bech32.encodings.BECH32);
-    if (dec === null) {
-        dec = bech32.decode(addr, bech32.encodings.BECH32M);
-        bech32m = true;
-    }
-    if (dec === null || dec.hrp !== hrp || dec.data.length < 1 || dec.data[0] > 16) {
-        return null;
-    }
-    var res = convertbits(dec.data.slice(1), 5, 8, false);
-    if (res === null || res.length < 2 || res.length > 40) {
-        return null;
-    }
-    if (dec.data[0] === 0 && res.length !== 20 && res.length !== 32) {
-        return null;
-    }
-    if (dec.data[0] === 0 && bech32m) {
-        return null;
-    }
-    if (dec.data[0] !== 0 && !bech32m) {
-        return null;
-    }
-    return { version: dec.data[0], program: res };
-}
-function encode(hrp, version, program) {
-    var enc = bech32.encodings.BECH32;
-    if (version > 0) {
-        enc = bech32.encodings.BECH32M;
-    }
-    var ret = bech32.encode(hrp, [version].concat(convertbits(program, 8, 5, true)), enc);
-    if (decode(hrp, ret, enc) === null) {
-        return null;
-    }
-    return ret;
-}
-/////////////////////////////////////////////////////
-function isValidAddress(address, opts = {}) {
-    if (!opts.bech32Hrp || opts.bech32Hrp.length === 0) {
-        return false;
-    }
-    const correctBech32Hrps = opts.bech32Hrp;
-    for (var chrp of correctBech32Hrps) {
-        var ret = decode(chrp, address);
-        if (ret) {
-            return encode(chrp, ret.version, ret.program) === address.toLowerCase();
-        }
-    }
-    return false;
-}
-export default {
-    encode: encode,
-    decode: decode,
-    isValidAddress: isValidAddress,
-};

package/dist/crypto/utils.d.ts

@@ -1,26 +0,0 @@
-declare function numberToHex(number: number, length: number): string;
-declare function byteArray2hexStr(byteArray: number[]): string;
-declare function hexStr2byteArray(str: string): Uint8Array;
-declare const _default: {
-    numberToHex: typeof numberToHex;
-    toHex: (arrayOfBytes: any) => string;
-    sha256: (payload: any, format?: string) => string;
-    sha256x2: (buffer: any, format?: string) => any;
-    sha256Checksum: (payload: any) => any;
-    sha512: (payload: any, format?: string) => string;
-    sha512_256: (payload: any, format?: string) => string;
-    blake256: (hexString: string) => any;
-    blake256Checksum: (payload: any) => any;
-    blake2b: (hexString: string, outlen: number) => any;
-    keccak256: (hexString: string) => string;
-    keccak256Checksum: (payload: any) => any;
-    blake2b256: (hexString: string) => any;
-    base58: (string: string) => number[];
-    byteArray2hexStr: typeof byteArray2hexStr;
-    hexStr2byteArray: typeof hexStr2byteArray;
-    base32: {
-        b32decode: (s: string) => Uint8Array;
-        b32encode: (s: string) => string;
-    };
-};
-export default _default;

package/dist/crypto/utils.js

@@ -1,123 +0,0 @@
-import { Buffer } from 'buffer';
-import { sha256 } from '@noble/hashes/sha256';
-import { sha512, sha512_256 } from '@noble/hashes/sha512';
-import { bytesToHex } from '@noble/hashes/utils';
-import { keccak_256 } from '@noble/hashes/sha3';
-import base32 from './base32.js';
-import base58 from './base58.js';
-import Blake256 from './blake256.js';
-import Blake2B from './blake2b.js';
-function numberToHex(number, length) {
-    let hex = number.toString(16);
-    if (hex.length % 2 === 1) {
-        hex = '0' + hex;
-    }
-    return hex.padStart(length, '0');
-}
-function isHexChar(c) {
-    if ((c >= 'A' && c <= 'F') ||
-        (c >= 'a' && c <= 'f') ||
-        (c >= '0' && c <= '9')) {
-        return 1;
-    }
-    return 0;
-}
-/* Convert a hex char to value */
-function hexChar2byte(c) {
-    let d = 0;
-    if (c >= 'A' && c <= 'F') {
-        d = c.charCodeAt(0) - 'A'.charCodeAt(0) + 10;
-    }
-    else if (c >= 'a' && c <= 'f') {
-        d = c.charCodeAt(0) - 'a'.charCodeAt(0) + 10;
-    }
-    else if (c >= '0' && c <= '9') {
-        d = c.charCodeAt(0) - '0'.charCodeAt(0);
-    }
-    return d;
-}
-/* Convert a byte to string */
-function byte2hexStr(byte) {
-    const hexByteMap = "0123456789ABCDEF";
-    let str = "";
-    str += hexByteMap.charAt(byte >> 4);
-    str += hexByteMap.charAt(byte & 0x0f);
-    return str;
-}
-function byteArray2hexStr(byteArray) {
-    let str = "";
-    let i = 0;
-    for (i = 0; i < (byteArray.length - 1); i++) {
-        str += byte2hexStr(byteArray[i]);
-    }
-    str += byte2hexStr(byteArray[i]);
-    return str;
-}
-function hexStr2byteArray(str) {
-    const byteArray = new Uint8Array(str.length / 2);
-    let d = 0;
-    let i = 0;
-    let j = 0;
-    let k = 0;
-    for (i = 0; i < str.length; i++) {
-        const c = str.charAt(i);
-        if (isHexChar(c)) {
-            d <<= 4;
-            d += hexChar2byte(c);
-            j++;
-            if (0 === (j % 2)) {
-                byteArray[k++] = d;
-                d = 0;
-            }
-        }
-    }
-    return byteArray;
-}
-export default {
-    numberToHex: numberToHex,
-    toHex: function (arrayOfBytes) {
-        let hex = '';
-        for (let i = 0; i < arrayOfBytes.length; i++) {
-            // @ts-expect-error
-            hex += numberToHex(arrayOfBytes[i]);
-        }
-        return hex;
-    },
-    sha256: function (payload, format = 'HEX') {
-        return bytesToHex(sha256(hexStr2byteArray(payload)));
-    },
-    sha256x2: function (buffer, format = 'HEX') {
-        return this.sha256(this.sha256(buffer, format), format);
-    },
-    sha256Checksum: function (payload) {
-        return this.sha256(this.sha256(payload)).slice(0, 8);
-    },
-    sha512: function (payload, format = 'HEX') {
-        return bytesToHex(sha512(payload));
-    },
-    sha512_256: function (payload, format = 'HEX') {
-        return bytesToHex(sha512_256(hexStr2byteArray(payload)));
-    },
-    blake256: function (hexString) {
-        return new Blake256().update(hexString, 'hex').digest('hex');
-    },
-    blake256Checksum: function (payload) {
-        return this.blake256(this.blake256(payload)).substr(0, 8);
-    },
-    blake2b: function (hexString, outlen) {
-        return new Blake2B(outlen).update(Buffer.from(hexString, 'hex')).digest('hex');
-    },
-    keccak256: function (hexString) {
-        return bytesToHex(keccak_256(hexString));
-    },
-    keccak256Checksum: function (payload) {
-        return this.keccak256(payload).toString().substr(0, 8);
-    },
-    blake2b256: function (hexString) {
-        return new Blake2B(32).update(Buffer.from(hexString, 'hex')).digest('hex');
-    },
-    base58: base58.decode,
-    byteArray2hexStr: byteArray2hexStr,
-    hexStr2byteArray: hexStr2byteArray,
-    base32: base32
-};

package/dist/helpers.d.ts

@@ -1,2 +0,0 @@
-import { Address } from './types.js';
-export declare function getAddress(address: Address): string;

package/dist/helpers.js

@@ -1,5 +0,0 @@
-export function getAddress(address) {
-    return typeof address === 'string'
-        ? address
-        : address.address;
-}

package/dist/multichain-address-validator.d.ts

@@ -1,3 +0,0 @@
-import { Address, Chain, NetworkType } from './types.js';
-export declare function validate(address: Address, chain: Chain): boolean;
-export type { Address, Chain, NetworkType };

package/dist/multichain-address-validator.js

@@ -1,8 +0,0 @@
-import { getValidatorForChain } from './chain-validators.js';
-export function validate(address, chain) {
-    const validator = getValidatorForChain(chain);
-    if (!validator) {
-        throw new Error(`Missing validator for chain: ${chain}`);
-    }
-    return validator.isValidAddress(address);
-}

package/dist/types.d.ts

@@ -1,15 +0,0 @@
-export type Address = string | {
-    address: string;
-    memo?: string;
-};
-export type Chain = string | {
-    chain: string;
-    networkType?: NetworkType;
-};
-export interface Validator {
-    isValidAddress(address: Address): boolean;
-}
-export declare enum NetworkType {
-    MainNet = "mainnet",
-    TestNet = "testnet"
-}

package/dist/types.js

@@ -1,5 +0,0 @@
-export var NetworkType;
-(function (NetworkType) {
-    NetworkType["MainNet"] = "mainnet";
-    NetworkType["TestNet"] = "testnet";
-})(NetworkType || (NetworkType = {}));

package/dist/validators/algorand_validator.d.ts

@@ -1,5 +0,0 @@
-import { Address } from '../types.js';
-declare const _default: {
-    isValidAddress: (address: Address) => boolean;
-};
-export default _default;

package/dist/validators/algorand_validator.js

@@ -1,23 +0,0 @@
-import cryptoUtils from '../crypto/utils.js';
-import { getAddress } from '../helpers.js';
-const ALGORAND_CHECKSUM_BYTE_LENGTH = 4;
-const ALGORAND_ADDRESS_LENGTH = 58;
-function verifyChecksum(address) {
-    if (address.length !== ALGORAND_ADDRESS_LENGTH) {
-        return false;
-    }
-    else {
-        // Decode base32 Address
-        const decoded = cryptoUtils.base32.b32decode(address);
-        const addr = decoded.slice(0, decoded.length - ALGORAND_CHECKSUM_BYTE_LENGTH);
-        const checksum = cryptoUtils.byteArray2hexStr(decoded.slice(-4));
-        // Hash Address - Checksum
-        const code = cryptoUtils.sha512_256(cryptoUtils.byteArray2hexStr(addr)).substr(-ALGORAND_CHECKSUM_BYTE_LENGTH * 2);
-        return code.toUpperCase() === checksum;
-    }
-}
-export default {
-    isValidAddress: function (address) {
-        return verifyChecksum(getAddress(address));
-    }
-};

package/dist/validators/base58_validator.d.ts

@@ -1,4 +0,0 @@
-declare const _default: {
-    isValidAddress: (address: any, opts: any) => boolean;
-};
-export default _default;

package/dist/validators/base58_validator.js

@@ -1,31 +0,0 @@
-import base58 from '../crypto/base58.js';
-// simple base58 validator.  Just checks if it can be decoded.
-export default {
-    isValidAddress: function (address, opts) {
-        try {
-            if (!address || address.length == 0) {
-                return false;
-            }
-            if (opts.minLength && (address.length < opts.minLength)) {
-                return false;
-            }
-            if (opts.maxLength && (address.length > opts.maxLength)) {
-                return false;
-            }
-            try {
-                const decoded = base58.decode(address);
-                if (!decoded || !decoded.length) {
-                    return false;
-                }
-            }
-            catch (e) {
-                // if decoding fails, assume invalid address
-                return false;
-            }
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-};

package/dist/validators/bch_validator.d.ts

@@ -1,13 +0,0 @@
-import { Address, NetworkType } from '../types.js';
-interface BCHValidatorOpts {
-    addressTypes: string[];
-    expectedLength?: number;
-    bech32Hrp?: [string];
-    hashFunction?: 'blake256' | 'blake256keccak256' | 'keccak256' | 'sha256';
-    regexp?: RegExp;
-    networkType: NetworkType;
-}
-declare const _default: (opts: BCHValidatorOpts) => {
-    isValidAddress: (address: Address) => boolean;
-};
-export default _default;

package/dist/validators/bch_validator.js

@@ -1,50 +0,0 @@
-import cryptoUtils from '../crypto/utils.js';
-import bech32 from '../crypto/bech32.js';
-import { NetworkType } from '../types.js';
-import BTCValidator from './bitcoin_validator.js';
-import { getAddress } from '../helpers.js';
-function validateAddress(address, opts) {
-    const regexp = new RegExp(opts.regexp);
-    let raw_address;
-    const res = address.split(':');
-    if (res.length === 1) {
-        raw_address = address;
-    }
-    else {
-        if (res[0] !== 'bitcoincash') {
-            return false;
-        }
-        raw_address = res[1];
-    }
-    if (!regexp.test(raw_address)) {
-        return false;
-    }
-    if (raw_address.toLowerCase() != raw_address && raw_address.toUpperCase() != raw_address) {
-        return false;
-    }
-    const decoded = cryptoUtils.base32.b32decode(raw_address);
-    const prefix = opts.networkType === NetworkType.MainNet
-        ? 'bitcoincash'
-        : 'bchtest';
-    try {
-        if (bech32.verifyChecksum(prefix, decoded, bech32.encodings.BECH32)) {
-            return false;
-        }
-    }
-    catch (e) {
-        return false;
-    }
-    return true;
-}
-const DefaultBCHValidatorOpts = {
-    //     addressTypes: {mainnet: ['00', '05'], testnet: ['6f', 'c4', '3c', '26']},
-    //     bech32Hrp: {mainnet: ['bc'], testnet: ['tb']},
-    regexp: /^[qQpP][0-9a-zA-Z]{41}$/,
-};
-export default (opts) => ({
-    isValidAddress: function (address) {
-        const addr = getAddress(address);
-        const _opts = { ...DefaultBCHValidatorOpts, ...opts };
-        return validateAddress(addr, _opts) || BTCValidator(opts).isValidAddress(address);
-    }
-});

package/dist/validators/bip173_validator.d.ts

@@ -1,7 +0,0 @@
-interface Bip173Options {
-    bech32Hrp: string[];
-}
-declare const _default: {
-    isValidAddress: (address: string, opts: Bip173Options) => boolean;
-};
-export default _default;

package/dist/validators/bip173_validator.js

@@ -1,12 +0,0 @@
-import bech32 from '../crypto/bech32.js';
-// bip 173 bech 32 addresses (https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki)
-export default {
-    isValidAddress: function (address, opts) {
-        const decoded = bech32.decode(address, bech32.encodings.BECH32);
-        if (!decoded) {
-            return false;
-        }
-        const bech32Hrp = decoded.hrp;
-        return opts.bech32Hrp.indexOf(bech32Hrp) !== -1;
-    }
-};

package/dist/validators/bitcoin_validator.d.ts

@@ -1,12 +0,0 @@
-import { Address } from '../types.js';
-interface BTCValidatorOpts {
-    addressTypes: string[];
-    expectedLength?: number;
-    bech32Hrp?: [string];
-    hashFunction?: 'blake256' | 'blake256keccak256' | 'keccak256' | 'sha256';
-    regex?: RegExp;
-}
-declare const _default: (opts: BTCValidatorOpts) => {
-    isValidAddress(address: Address): boolean;
-};
-export default _default;

package/dist/validators/bitcoin_validator.js

@@ -1,68 +0,0 @@
-import base58 from '../crypto/base58.js';
-import segwit from '../crypto/segwit_addr.js';
-import cryptoUtils from '../crypto/utils.js';
-import { getAddress } from '../helpers.js';
-import { Buffer } from 'buffer';
-function getDecoded(address) {
-    try {
-        return base58.decode(address);
-    }
-    catch (e) {
-        // if decoding fails, assume invalid address
-        return null;
-    }
-}
-function getChecksum(hashFunction, payload) {
-    // Each currency may implement different hashing algorithm
-    switch (hashFunction) {
-        // blake then keccak hash chain
-        case 'blake256keccak256':
-            const blake = cryptoUtils.blake2b256(payload);
-            return cryptoUtils.keccak256Checksum(Buffer.from(blake, 'hex'));
-        case 'blake256':
-            return cryptoUtils.blake256Checksum(payload);
-        case 'keccak256':
-            return cryptoUtils.keccak256Checksum(payload);
-        case 'sha256':
-        default:
-            return cryptoUtils.sha256Checksum(payload);
-    }
-}
-function getAddressType(address, opts) {
-    // should be 25 bytes per btc address spec and 26 decred
-    const expectedLength = opts.expectedLength || 25;
-    const hashFunction = opts.hashFunction || 'sha256';
-    const decoded = getDecoded(address);
-    if (decoded) {
-        const length = decoded.length;
-        if (length !== expectedLength) {
-            return null;
-        }
-        if (opts.regex) {
-            if (!opts.regex.test(address)) {
-                return false;
-            }
-        }
-        const checksum = cryptoUtils.toHex(decoded.slice(length - 4, length)), body = cryptoUtils.toHex(decoded.slice(0, length - 4)), goodChecksum = getChecksum(hashFunction, body);
-        return checksum === goodChecksum ? cryptoUtils.toHex(decoded.slice(0, expectedLength - 24)) : null;
-    }
-    return null;
-}
-function isValidP2PKHandP2SHAddress(address, opts) {
-    const addressType = getAddressType(address, opts);
-    if (addressType) {
-        return opts.addressTypes.indexOf(addressType) >= 0;
-    }
-    return false;
-}
-// const DefaultBTCValidatorOpts: BTCValidatorOpts = {
-//     addressTypes: {mainnet: ['00', '05'], testnet: ['6f', 'c4', '3c', '26']},
-//     bech32Hrp: {mainnet: ['bc'], testnet: ['tb']},
-// }
-export default (opts) => ({
-    isValidAddress(address) {
-        const addr = getAddress(address);
-        // const _opts = {...DefaultBTCValidatorOpts, ...opts}
-        return isValidP2PKHandP2SHAddress(addr, opts) || segwit.isValidAddress(addr, opts);
-    }
-});

package/dist/validators/cardano_validator.d.ts

@@ -1,5 +0,0 @@
-import { Address } from '../types.js';
-declare const _default: {
-    isValidAddress(address: Address): boolean;
-};
-export default _default;

package/dist/validators/cardano_validator.js

@@ -1,41 +0,0 @@
-import cbor from 'cbor-js';
-import CRC from 'crc';
-import base58 from '../crypto/base58.js';
-import BIP173Validator from './bip173_validator.js';
-import { getAddress } from '../helpers.js';
-function getDecoded(address) {
-    try {
-        const decoded = base58.decode(address);
-        return cbor.decode(new Uint8Array(decoded).buffer);
-    }
-    catch (e) {
-        // if decoding fails, assume invalid address
-        return null;
-    }
-}
-function isValidAddressV1(address) {
-    const decoded = getDecoded(address);
-    if (!decoded || (!Array.isArray(decoded) && decoded.length != 2)) {
-        return false;
-    }
-    const tagged = decoded[0];
-    const validCrc = decoded[1];
-    if (typeof (validCrc) != 'number') {
-        return false;
-    }
-    // get crc of the payload
-    const crc = CRC.crc32(tagged);
-    return crc == validCrc;
-}
-function isValidAddressShelley(address, opts) {
-    // shelley address are just bip 173 - bech32 addresses (https://cips.cardano.org/cips/cip4/)
-    return BIP173Validator.isValidAddress(address, opts);
-}
-export default {
-    isValidAddress(address) {
-        const addr = getAddress(address);
-        return isValidAddressV1(getAddress(addr)) || isValidAddressShelley(addr, {
-            bech32Hrp: ['addr']
-        });
-    }
-};

package/dist/validators/eos_validator.d.ts

@@ -1,5 +0,0 @@
-import { Address } from '../types.js';
-declare const _default: {
-    isValidAddress: (address: Address) => boolean;
-};
-export default _default;

package/dist/validators/eos_validator.js

@@ -1,10 +0,0 @@
-import { getAddress } from '../helpers.js';
-function isValidEOSAddress(address) {
-    const regex = /^[a-z0-9.]+$/g; // Must be numbers, lowercase letters and decimal points only
-    return address.search(regex) !== -1 && address.length === 12;
-}
-export default {
-    isValidAddress: function (address) {
-        return isValidEOSAddress(getAddress(address));
-    }
-};

package/dist/validators/ethereum_validator.d.ts

@@ -1,6 +0,0 @@
-import { Address } from '../types.js';
-declare const _default: {
-    isValidAddress: (address: Address) => any;
-    verifyChecksum: (address: string) => boolean;
-};
-export default _default;

package/dist/validators/ethereum_validator.js

@@ -1,30 +0,0 @@
-import cryptoUtils from '../crypto/utils.js';
-import { getAddress } from '../helpers.js';
-export default {
-    isValidAddress: function (address) {
-        const addr = getAddress(address);
-        if (!/^0x[0-9a-fA-F]{40}$/.test(addr)) {
-            // Check if it has the basic requirements of an address
-            return false;
-        }
-        if (/^0x[0-9a-f]{40}$/.test(addr) || /^0x?[0-9A-F]{40}$/.test(addr)) {
-            // If it's all small caps or all caps, return true
-            return true;
-        }
-        // Otherwise check each case
-        return this.verifyChecksum(addr);
-    },
-    verifyChecksum: function (address) {
-        // Check each case
-        address = address.replace('0x', '');
-        const addressHash = cryptoUtils.keccak256(address.toLowerCase());
-        for (let i = 0; i < 40; i++) {
-            // The nth letter should be uppercase if the nth digit of casemap is 1
-            if ((parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i]) ||
-                (parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-};

package/dist/validators/hedera_validator.d.ts

@@ -1,5 +0,0 @@
-import type { Address } from '../types.js';
-declare const _default: {
-    isValidAddress(address: Address): boolean;
-};
-export default _default;

package/dist/validators/hedera_validator.js

@@ -1,8 +0,0 @@
-import { getAddress } from '../helpers.js';
-export default {
-    isValidAddress(address) {
-        // Regex to validate the format "shard.realm.account"
-        const regex = /^\d+\.\d+\.\d+$/;
-        return regex.test(getAddress(address));
-    }
-};