multichain-address-validator 0.8.0 → 0.8.2

package/src/crypto/segwit_addr.js

@@ -1,118 +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.js'
-
-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;
-    }
-
-    if (!opts.allowedSegwitVersions?.length) {
-        return false;
-    }
-
-    const correctBech32Hrps = opts.bech32Hrp;
-
-    for(const chrp of correctBech32Hrps) {
-        const ret = decode(chrp, address);
-        if(ret) {
-            if (opts.allowedSegwitVersions.includes(ret.version)) {
-                return encode(chrp, ret.version, ret.program) === address.toLowerCase();
-            }
-        }
-    }
-
-    return false;
-}
-
-export default {
-    encode: encode,
-    decode: decode,
-    isValidAddress: isValidAddress,
-}

package/src/crypto/utils.ts

@@ -1,133 +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: number, length: number) {
-    let hex = number.toString(16);
-    if (hex.length % 2 === 1) {
-        hex = '0' + hex;
-    }
-    return hex.padStart(length, '0');
-}
-
-function isHexChar(c: string) {
-    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: string) {
-    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: number) {
-    const hexByteMap = "0123456789ABCDEF";
-    let str = "";
-    str += hexByteMap.charAt(byte >> 4);
-    str += hexByteMap.charAt(byte & 0x0f);
-    return str;
-}
-
-function byteArray2hexStr(byteArray: number[]) {
-    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: string) {
-    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: any) {
-        let hex = '';
-        for (let i = 0; i < arrayOfBytes.length; i++) {
-            // @ts-expect-error
-            hex += numberToHex(arrayOfBytes[i]);
-        }
-        return hex;
-    },
-    sha256: function (payload: any, format = 'HEX') {
-        return bytesToHex(sha256(hexStr2byteArray(payload) as any))
-    },
-    sha256x2: function (buffer: any, format = 'HEX') {
-        return this.sha256(this.sha256(buffer, format), format);
-    },
-    sha256Checksum: function (payload: any) {
-        return this.sha256(this.sha256(payload)).slice(0, 8);
-    },
-    sha512: function(payload: any, format = 'HEX') {
-        return bytesToHex(sha512(payload))
-    },
-    sha512_256: function (payload: any, format = 'HEX') {
-        return bytesToHex(sha512_256(hexStr2byteArray(payload)))
-    },
-    blake256: function (hexString: string) {
-        return new Blake256().update(hexString, 'hex').digest('hex');
-    },
-    blake256Checksum: function (payload: any) {
-        return this.blake256(this.blake256(payload)).substr(0, 8);
-    },
-    blake2b: function (hexString: string, outlen: number) {
-        return new Blake2B(outlen).update(Buffer.from(hexString, 'hex')).digest('hex');
-    },
-    keccak256: function (hexString: string) {
-        return bytesToHex(keccak_256(hexString));
-    },
-    keccak256Checksum: function (payload: any) {
-        return this.keccak256(payload).toString().substr(0, 8);
-    },
-    blake2b256: function (hexString: string) {
-        return new Blake2B(32).update(Buffer.from(hexString, 'hex')).digest('hex');
-    },
-    base58: base58.decode,
-    byteArray2hexStr: byteArray2hexStr,
-    hexStr2byteArray: hexStr2byteArray,
-    base32: base32
-}

package/src/helpers.ts

@@ -1,13 +0,0 @@
-import {Address} from './types.js'
-
-export function getAddress(address: Address): string {
-    return typeof address === 'string'
-        ? address
-        : address.address
-}
-
-export function getMemo(address: Address): string | undefined {
-    return typeof address === 'string'
-        ? undefined
-        : address.memo
-}

package/src/index.ts

@@ -1,28 +0,0 @@
-import {Address, Chain, NetworkType} from './types.js'
-import {getValidatorForChain} from './chain-validators.js'
-
-export function validate(address: Address, chain: Chain): boolean {
-    const validator = getValidatorForChain(chain)
-    if (!validator) {
-        throw new Error(`Missing validator for chain: ${chain}`);
-    }
-
-    return validator.isValidAddress(address);
-}
-
-export function validateMemo(memo: string, chain: Chain): boolean {
-    const validator = getValidatorForChain(chain)
-    if (!validator) {
-        throw new Error(`Missing validator for chain: ${chain}`);
-    }
-
-    return validator.isValidMemo?.(memo) ?? true
-}
-
-export type { Address, Chain }
-export { NetworkType }
-
-export default {
-    validate,
-    validateMemo
-}

package/src/types.ts

@@ -1,19 +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
-    isValidMemo?(memo: string): boolean
-}
-
-export enum NetworkType {
-    MainNet = 'mainnet',
-    TestNet = 'testnet',
-}

package/src/validators/algorand_validator.ts

@@ -1,28 +0,0 @@
-import cryptoUtils from '../crypto/utils.js'
-import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-const ALGORAND_CHECKSUM_BYTE_LENGTH = 4;
-const ALGORAND_ADDRESS_LENGTH = 58;
-
-function verifyChecksum(address: string) {
-    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) as any)
-
-        // Hash Address - Checksum
-        const code = cryptoUtils.sha512_256(cryptoUtils.byteArray2hexStr(addr as any)).substr(-ALGORAND_CHECKSUM_BYTE_LENGTH * 2);
-
-        return code.toUpperCase() === checksum
-    }
-}
-
-export default {
-    isValidAddress: function (address: Address) {
-        return verifyChecksum(getAddress(address))
-    }
-}

package/src/validators/base58_validator.ts

@@ -1,32 +0,0 @@
-import base58 from '../crypto/base58.js'
-
-// simple base58 validator.  Just checks if it can be decoded.
-export default {
-    isValidAddress: function (address, opts: any) {
-        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/src/validators/bch_validator.ts

@@ -1,66 +0,0 @@
-import cryptoUtils from '../crypto/utils.js'
-import bech32 from '../crypto/bech32.js'
-import {Address, NetworkType} from '../types.js'
-import BTCValidator from './bitcoin_validator.js'
-import {getAddress} from '../helpers.js'
-
-function validateAddress(address: string, opts: BCHValidatorOpts) {
-    const regexp = new RegExp(opts.regexp);
-    let raw_address: string;
-
-    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;
-}
-
-interface BCHValidatorOpts {
-    addressTypes: string[]
-    expectedLength?: number
-    bech32Hrp?: [string],
-    hashFunction?: 'blake256' | 'blake256keccak256' | 'keccak256' | 'sha256',
-    regexp?: RegExp,
-    networkType: NetworkType,
-}
-
-const DefaultBCHValidatorOpts: Partial<BCHValidatorOpts> = {
-//     addressTypes: {mainnet: ['00', '05'], testnet: ['6f', 'c4', '3c', '26']},
-//     bech32Hrp: {mainnet: ['bc'], testnet: ['tb']},
-    regexp: /^[qQpP][0-9a-zA-Z]{41}$/,
-}
-
-export default (opts: BCHValidatorOpts) => ({
-    isValidAddress: function (address: Address) {
-        const addr = getAddress(address)
-        const _opts = {...DefaultBCHValidatorOpts, ...opts}
-        return validateAddress(addr, _opts) || BTCValidator(opts).isValidAddress(address);
-    }
-})

package/src/validators/bip173_validator.ts

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

package/src/validators/bitcoin_validator.ts

@@ -1,93 +0,0 @@
-import base58 from '../crypto/base58.js'
-import segwit from '../crypto/segwit_addr.js'
-import cryptoUtils from '../crypto/utils.js'
-
-import {Address, NetworkType} from '../types.js'
-import {getAddress} from '../helpers.js'
-import {Buffer} from 'buffer'
-
-function getDecoded(address: string) {
-    try {
-        return base58.decode(address);
-    } catch (e) {
-        // if decoding fails, assume invalid address
-        return null;
-    }
-}
-
-function getChecksum(hashFunction: BTCValidatorOpts['hashFunction'], payload: any) {
-    // 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: string, opts: BTCValidatorOpts) {
-    // 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: string, opts: BTCValidatorOpts) {
-    const addressType = getAddressType(address, opts);
-
-    if (addressType) {
-        return opts.addressTypes.indexOf(addressType) >= 0;
-    }
-
-    return false;
-}
-
-export enum SegwitVersion {
-    NativeSegwit = 0,
-    TapRoot = 1,
-}
-
-interface BTCValidatorOpts {
-    addressTypes: string[],
-    expectedLength?: number,
-    bech32Hrp?: [string],
-    allowedSegwitVersions?: [number],
-    hashFunction?: 'blake256' | 'blake256keccak256' | 'keccak256' | 'sha256',
-    regex?: RegExp,
-}
-
-export default (opts: BTCValidatorOpts) => ({
-    isValidAddress(address: Address): boolean {
-        const addr = getAddress(address)
-        return isValidP2PKHandP2SHAddress(addr, opts) || segwit.isValidAddress(addr, opts);
-    }
-})

package/src/validators/bittensor_validator.ts

@@ -1,8 +0,0 @@
-import createSS58Validator from './ss58_validator.js'
-
-// Bittensor uses SS58 address format (Substrate-based) with network prefix 42
-// Reference: https://docs.learnbittensor.org/evm-tutorials/convert-h160-to-ss58
-// SS58 Registry: https://github.com/paritytech/ss58-registry
-
-// Network prefix 42 (0x2A in hex) is used by Bittensor
-export default createSS58Validator({ networkPrefix: 42 })

package/src/validators/cardano_validator.ts

@@ -1,50 +0,0 @@
-import cbor from 'cbor-js'
-import CRC from 'crc'
-
-import base58 from '../crypto/base58.js'
-import BIP173Validator from './bip173_validator.js'
-import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-function getDecoded(address: string) {
-    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: string) {
-    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: string, opts: { bech32Hrp: string [] }) {
-    // shelley address are just bip 173 - bech32 addresses (https://cips.cardano.org/cips/cip4/)
-    return BIP173Validator.isValidAddress(address, opts);
-}
-
-export default {
-    isValidAddress(address: Address) {
-        const addr = getAddress(address)
-        return isValidAddressV1(getAddress(addr)) || isValidAddressShelley(addr, {
-            bech32Hrp: ['addr']
-        });
-    }
-}

package/src/validators/eos_validator.ts

@@ -1,13 +0,0 @@
-import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-function isValidEOSAddress(address: string) {
-    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: Address) {
-        return isValidEOSAddress(getAddress(address))
-    }
-}

package/src/validators/ethereum_validator.ts

@@ -1,37 +0,0 @@
-import cryptoUtils from '../crypto/utils.js'
-import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-export default {
-    isValidAddress: function (address: 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: string) {
-        // 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/src/validators/hedera_validator.ts

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