multichain-address-validator 0.0.1

package/src/crypto/segwit_addr.js

@@ -0,0 +1,112 @@
+// 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/src/crypto/utils.ts

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

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

package/src/multichain-address-validator.ts

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

package/src/types.ts

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

package/src/validators/algorand_validator.ts

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

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

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

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

@@ -0,0 +1,94 @@
+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;
+}
+
+
+interface BTCValidatorOpts {
+    addressTypes: string[],
+    expectedLength?: number,
+    bech32Hrp?: [string],
+    hashFunction?: 'blake256' | 'blake256keccak256' | 'keccak256' | 'sha256',
+    regex?: RegExp,
+}
+
+// const DefaultBTCValidatorOpts: BTCValidatorOpts = {
+//     addressTypes: {mainnet: ['00', '05'], testnet: ['6f', 'c4', '3c', '26']},
+//     bech32Hrp: {mainnet: ['bc'], testnet: ['tb']},
+// }
+
+export default (opts: BTCValidatorOpts) => ({
+    isValidAddress(address: Address): boolean {
+        const addr = getAddress(address)
+        // const _opts = {...DefaultBTCValidatorOpts, ...opts}
+        return isValidP2PKHandP2SHAddress(addr, opts) || segwit.isValidAddress(addr, opts);
+    }
+})

package/src/validators/cardano_validator.ts

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

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

@@ -0,0 +1,37 @@
+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/index.ts

@@ -0,0 +1,16 @@
+export {default as AlgorandValidator} from "./algorand_validator.js"
+export {default as BCHValidator} from "./bch_validator.js"
+export {default as BTCValidator} from "./bitcoin_validator.js"
+export {default as CardanoValidator} from "./cardano_validator.js"
+export {default as EOSValidator} from "./eos_validator.js"
+export {default as ETHValidator} from "./ethereum_validator.js"
+export {default as MoneroValidator} from "./monero_validator.js"
+export {default as NemValidator} from "./nem_validator.js"
+export {default as NanoValidator} from "./nano_validator.js"
+export {default as PolkadotValidator} from "./polkadot_validator.js"
+export {default as RippleValidator} from "./ripple_validator.js"
+export {default as SiaValidator} from "./sia_validator.js"
+export {default as SolanaValidator} from "./solana_validator.js"
+export {default as TezosValidator} from "./tezos_validator.js"
+export {default as TronValidator} from "./tron_validator.js"
+export {default as XLMValidator} from "./xlm_validator.js"