multichain-address-validator 0.0.1

package/dist/validators/tezos_validator.js

@@ -0,0 +1,30 @@
+import base58 from '../crypto/base58.js';
+import cryptoUtils from '../crypto/utils.js';
+import { getAddress } from '../helpers.js';
+const prefix = new Uint8Array([6, 161, 159]);
+function decodeRaw(buffer) {
+    let payload = buffer.slice(0, -4);
+    let checksum = buffer.slice(-4);
+    let newChecksum = cryptoUtils.hexStr2byteArray(cryptoUtils.sha256x2(cryptoUtils.byteArray2hexStr(payload)));
+    if (checksum[0] ^ newChecksum[0] |
+        checksum[1] ^ newChecksum[1] |
+        checksum[2] ^ newChecksum[2] |
+        checksum[3] ^ newChecksum[3])
+        return;
+    return payload;
+}
+export default {
+    isValidAddress(address) {
+        try {
+            let buffer = base58.decode(getAddress(address));
+            let payload = decodeRaw(buffer);
+            if (!payload)
+                return false;
+            payload.slice(prefix.length);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+};

package/dist/validators/tron_validator.d.ts

@@ -0,0 +1,8 @@
+import { Address } from '../types.js';
+interface TronValidatorOpts {
+    addressTypes: string[];
+}
+declare const _default: (opts?: TronValidatorOpts) => {
+    isValidAddress: (address: Address) => boolean;
+};
+export default _default;

package/dist/validators/tron_validator.js

@@ -0,0 +1,45 @@
+import cryptoUtils from '../crypto/utils.js';
+import { getAddress } from '../helpers.js';
+function decodeBase58Address(base58String) {
+    if (typeof (base58String) !== 'string') {
+        return false;
+    }
+    if (base58String.length !== 34) {
+        return false;
+    }
+    let address;
+    try {
+        address = cryptoUtils.base58(base58String);
+    }
+    catch (e) {
+        return false;
+    }
+    const len = address.length;
+    const offset = len - 4;
+    const checkSum = address.slice(offset);
+    address = address.slice(0, offset);
+    const hash0 = cryptoUtils.sha256(cryptoUtils.byteArray2hexStr(address));
+    const hash1 = cryptoUtils.hexStr2byteArray(cryptoUtils.sha256(hash0));
+    const checkSum1 = hash1.slice(0, 4);
+    if (checkSum[0] === checkSum1[0] && checkSum[1] === checkSum1[1] && checkSum[2]
+        === checkSum1[2] && checkSum[3] === checkSum1[3]) {
+        return address;
+    }
+    return false;
+}
+const DefaultTronValidatorOpts = {
+    addressTypes: ['65']
+};
+export default (opts) => ({
+    isValidAddress: function (address) {
+        const _opts = { ...DefaultTronValidatorOpts, ...opts };
+        const addr = decodeBase58Address(getAddress(address));
+        if (!addr) {
+            return false;
+        }
+        if (addr.length !== 21) {
+            return false;
+        }
+        return _opts.addressTypes.includes(addr[0].toString());
+    }
+});

package/dist/validators/xlm_validator.d.ts

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

package/dist/validators/xlm_validator.js

@@ -0,0 +1,32 @@
+import baseX from 'base-x';
+import crc from 'crc';
+import cryptoUtils from '../crypto/utils.js';
+import { getAddress } from '../helpers.js';
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+const base32 = baseX(ALPHABET);
+const regexp = new RegExp('^[' + ALPHABET + ']{56}$');
+const ed25519PublicKeyVersionByte = (6 << 3);
+function swap16(number) {
+    const lower = number & 0xFF;
+    const upper = (number >> 8) & 0xFF;
+    return (lower << 8) | upper;
+}
+export default {
+    isValidAddress(address) {
+        const addr = getAddress(address);
+        if (regexp.test(addr)) {
+            return this.verifyChecksum(addr);
+        }
+        return false;
+    },
+    verifyChecksum: function (address) {
+        // based on https://github.com/stellar/js-stellar-base/blob/master/src/strkey.js#L126
+        var bytes = base32.decode(address);
+        if (bytes[0] !== ed25519PublicKeyVersionByte) {
+            return false;
+        }
+        const computedChecksum = cryptoUtils.numberToHex(swap16(crc.crc16xmodem(bytes.slice(0, -2))), 4);
+        const checksum = cryptoUtils.toHex(bytes.slice(-2));
+        return computedChecksum === checksum;
+    }
+};

package/index.html

@@ -0,0 +1,12 @@
+<html>
+    <body>
+        <script src="./dist/multichain-address-validator.bundle.min.js"></script>
+        <script type="module">
+            const valid = MCAV.validate('1KFzzGtDdnq5hrwxXGjwVnKzRbvf8WVxck', 'BTC');
+            if (valid)
+                console.log('This is a valid address');
+            else
+                console.log('Address INVALID');
+        </script>
+    </body>
+</html>

package/package.json

@@ -0,0 +1,353 @@
+{
+    "name": "multichain-address-validator",
+    "description": "Multichain address validator for Bitcoin and other blockchains.",
+    "keywords": [
+        "0x",
+        "zrx",
+        "Aave Coin",
+        "aave",
+        "Algorand",
+        "algo",
+        "Apecoin",
+        "ape",
+        "API3",
+        "api3",
+        "Aragon",
+        "ant",
+        "Arbitrum",
+        "arb",
+        "Augur",
+        "rep",
+        "AugurV2",
+        "repv2",
+        "AuroraCoin",
+        "aur",
+        "Avalanche",
+        "avax",
+        "Axie Infinity",
+        "axs",
+        "Bancor",
+        "bnt",
+        "Band Protocol",
+        "band",
+        "Bankex",
+        "bkx",
+        "Basic Attention Token",
+        "bat",
+        "BeaverCoin",
+        "bvc",
+        "Biconomy",
+        "bico",
+        "Binance",
+        "bnb",
+        "BioCoin",
+        "bio",
+        "Bitcoin",
+        "btc",
+        "Bitcoin SV",
+        "bsv",
+        "BitcoinCash",
+        "bch",
+        "BitcoinGold",
+        "btg",
+        "BitcoinPrivate",
+        "btcp",
+        "BitcoinZ",
+        "btcz",
+        "BlockTrade",
+        "btt",
+        "Blur",
+        "blur",
+        "Bonk",
+        "bonk",
+        "BTU Protocol",
+        "btu",
+        "Callisto",
+        "clo",
+        "Cardano",
+        "ada",
+        "Celo",
+        "celo",
+        "Chainlink",
+        "link",
+        "Chiliz",
+        "chz",
+        "Civic",
+        "cvc",
+        "Compound",
+        "comp",
+        "Cred",
+        "lba",
+        "Crypto.com Coin",
+        "cro",
+        "Curve DAO",
+        "crv",
+        "CUSD",
+        "cusd",
+        "Dash",
+        "dash",
+        "Decentraland",
+        "mana",
+        "Decred",
+        "dcr",
+        "DigiByte",
+        "dgb",
+        "District0x",
+        "dnt",
+        "DogeCoin",
+        "doge",
+        "Enjin Coin",
+        "enj",
+        "EOS",
+        "eos",
+        "Ethereum",
+        "eth",
+        "Ethereum Name Service",
+        "ens",
+        "EthereumClassic",
+        "etc",
+        "EthereumPow",
+        "ethw",
+        "EtherZero",
+        "etz",
+        "Expanse",
+        "exp",
+        "Fetch.ai",
+        "fet",
+        "FirmaChain",
+        "fct",
+        "Flare",
+        "flr",
+        "FreiCoin",
+        "frc",
+        "GameCredits",
+        "game",
+        "GarliCoin",
+        "grlc",
+        "Gnosis",
+        "gno",
+        "Golem",
+        "glm",
+        "Golem (GNT)",
+        "gnt",
+        "Hashflow",
+        "hft",
+        "HedgeTrade",
+        "hedg",
+        "Hush",
+        "hush",
+        "HyperSpace",
+        "xsc",
+        "iExec RLC",
+        "rlc",
+        "Illuvium",
+        "ilv",
+        "Immutable",
+        "imx",
+        "Injective",
+        "inj",
+        "Komodo",
+        "kmd",
+        "LBRY Credits",
+        "lbc",
+        "Lido DAO Token",
+        "ldo",
+        "LiteCoin",
+        "ltc",
+        "loki",
+        "loki",
+        "Loom Network",
+        "loom",
+        "Magic",
+        "magic",
+        "Maker",
+        "mkr",
+        "Marlin",
+        "pond",
+        "Mask Network",
+        "mask",
+        "Matchpool",
+        "gup",
+        "Matic",
+        "matic",
+        "MegaCoin",
+        "mec",
+        "Melon",
+        "mln",
+        "Metal",
+        "mtl",
+        "Monero",
+        "xmr",
+        "Multi-collateral DAI",
+        "dai",
+        "NameCoin",
+        "nmc",
+        "Nano",
+        "nano",
+        "Nem",
+        "xem",
+        "Neo",
+        "neo",
+        "NeoGas",
+        "gas",
+        "Numeraire",
+        "nmr",
+        "Ocean Protocol",
+        "ocean",
+        "Odyssey",
+        "ocn",
+        "OmiseGO",
+        "omg",
+        "Onyx Protocol",
+        "xcn",
+        "Optimism",
+        "op",
+        "Origin Protocol",
+        "ogn",
+        "Paxos",
+        "pax",
+        "PayPal USD",
+        "pyusd",
+        "PeerCoin",
+        "ppc",
+        "PIVX",
+        "pivx",
+        "Polkadot",
+        "dot",
+        "Polymath",
+        "poly",
+        "PrimeCoin",
+        "xpm",
+        "ProtoShares",
+        "pts",
+        "Qtum",
+        "qtum",
+        "Quant",
+        "qnt",
+        "Quantum Resistant Ledger",
+        "qrl",
+        "RaiBlocks",
+        "xrb",
+        "Ripio Credit Network",
+        "rcn",
+        "Ripple",
+        "xrp",
+        "Salt",
+        "salt",
+        "Serve",
+        "serv",
+        "Siacoin",
+        "sc",
+        "Skale",
+        "skl",
+        "SnowGem",
+        "sng",
+        "Solana",
+        "sol",
+        "SolarCoin",
+        "slr",
+        "SOLVE",
+        "solve",
+        "Spendcoin",
+        "spnd",
+        "Status",
+        "snt",
+        "Stellar",
+        "xlm",
+        "Storj",
+        "storj",
+        "Storm",
+        "storm",
+        "StormX",
+        "stmx",
+        "SuperVerse",
+        "super",
+        "Swarm City",
+        "swt",
+        "Synthetix Network",
+        "snx",
+        "Tap",
+        "xtp",
+        "Tellor",
+        "trb",
+        "TEMCO",
+        "temco",
+        "TenX",
+        "pay",
+        "Tether",
+        "usdt",
+        "Tezos",
+        "xtz",
+        "The Graph",
+        "grt",
+        "The Sandbox",
+        "sand",
+        "Tron",
+        "trx",
+        "TrueUSD",
+        "tusd",
+        "Unifi Protocol DAO",
+        "unfi",
+        "Uniswap Coin",
+        "uni",
+        "USD Coin",
+        "usdc",
+        "VeChain",
+        "vet",
+        "VertCoin",
+        "vtc",
+        "Viberate",
+        "vib",
+        "VoteCoin",
+        "vot",
+        "Vulcan Forged PYR",
+        "pyr",
+        "Waves",
+        "waves",
+        "Wings",
+        "wings",
+        "Yearn.finance",
+        "yfi",
+        "ZCash",
+        "zec",
+        "ZClassic",
+        "zcl",
+        "ZenCash",
+        "zen"
+    ],
+    "version": "0.0.1",
+    "author": "Chris <chris.tsim@gmail.com>",
+    "homepage": "https://github.com/christsim/multichain-address-validator",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/christsim/multichain-address-validator.git"
+    },
+    "main": "dist/multichain-address-validator.js",
+    "type": "module",
+    "engines": {
+        "node": ">=16.0.0"
+    },
+    "engineStrict": true,
+    "scripts": {
+        "build": "tsc",
+        "bundle": "tsx config/esbuild.ts",
+        "test": "mocha --import=tsx test/**.test.ts",
+        "start": "npm run build && npm run bundle && npm test"
+    },
+    "dependencies": {
+        "@noble/hashes": "^1.4.0",
+        "base-x": "^4.0.0",
+        "buffer": "^6.0.3",
+        "cbor-js": "^0.1.0",
+        "crc": "^4.3.2",
+        "lodash.isequal": "^4.5.0"
+    },
+    "devDependencies": {
+        "chai": "^4.4.1",
+        "esbuild": "^0.23.0",
+        "mocha": "^10.2.0",
+        "tsx": "^4.16.2",
+        "typescript": "^5.5.4"
+    }
+}

package/src/chain-validators.ts

@@ -0,0 +1,131 @@
+import {Chain, NetworkType, Validator} from './types.js'
+
+import {
+    AlgorandValidator,
+    BCHValidator,
+    BTCValidator,
+    CardanoValidator,
+    EOSValidator,
+    ETHValidator,
+    MoneroValidator,
+    NanoValidator,
+    NemValidator,
+    PolkadotValidator,
+    RippleValidator,
+    SiaValidator,
+    SolanaValidator,
+    TezosValidator,
+    TronValidator,
+    XLMValidator,
+} from './validators/index.js'
+
+
+type ChainValidators = Record<string, {
+    alternatives?: string[],
+    validator: Validator | {
+        mainnet: Validator,
+        testnet: Validator,
+    },
+}>
+
+const chainValidators: ChainValidators = {
+    algorand: {validator: AlgorandValidator},
+    bitcoin: {
+        alternatives: ['btc', 'omni'],
+        validator: {
+            mainnet: BTCValidator({
+                addressTypes: ['00', '05'],
+                bech32Hrp: ['bc'],
+            }),
+            testnet: BTCValidator({
+                addressTypes: ['6f', 'c4', '3c', '26'],
+                bech32Hrp: ['tb'],
+            }),
+        },
+    },
+    'bitcoincash': {
+        alternatives: ['bch', 'bitcoin-cash', 'bitcoin cash'],
+        validator: {
+            mainnet: BCHValidator({
+                addressTypes: ['00', '05'],
+                bech32Hrp: ['bc'],
+                networkType: NetworkType.MainNet,
+            }),
+            testnet: BCHValidator({
+                addressTypes: ['6f', 'c4', '3c', '26'],
+                bech32Hrp: ['tb'],
+                networkType: NetworkType.TestNet,
+            }),
+        }
+    },
+    cardano: {
+        alternatives: ['ada'],
+        validator: CardanoValidator,
+    },
+    doge: {
+        alternatives: ['dogecoin'],
+        validator: {
+            mainnet: BTCValidator({addressTypes: ['1e', '16']}),
+            testnet: BTCValidator({addressTypes: ['71', 'c4']}),
+        }
+    },
+    eos: {validator: EOSValidator},
+    ethereum: {
+        alternatives: ['eth', 'erc20', 'flare', 'avalanche', 'avalanche-c', 'bsc', 'bnb', 'binance'],
+        validator: ETHValidator
+    },
+    litecoin: {
+        alternatives: ['ltc'],
+        validator: {
+            mainnet: BTCValidator({
+                addressTypes: ['30', '05', '32'],
+                bech32Hrp: ['ltc'],
+            }),
+            testnet: BTCValidator({
+                addressTypes: ['6f', 'c4', '3a'],
+                bech32Hrp: ['tltc']
+            })
+        }
+    },
+    monero: {
+        validator: {
+            mainnet: MoneroValidator(NetworkType.MainNet),
+            testnet: MoneroValidator(NetworkType.TestNet),
+        }
+    },
+    nem: {validator: NemValidator},
+    nano: {validator: NanoValidator},
+    polkadot: {validator: PolkadotValidator},
+    ripple: {
+        alternatives: ['xrp'],
+        validator: RippleValidator,
+    },
+    sia: {validator: SiaValidator},
+    solana: {
+        alternatives: ['spl'],
+        validator: SolanaValidator,
+    },
+    tron: {
+        alternatives: ['trc20'],
+        validator: TronValidator(),
+    },
+    tezos: {validator: TezosValidator},
+    xlm: {
+        alternatives: ['stellar'],
+        validator: XLMValidator,
+    },
+}
+
+export function getValidatorForChain(chain: Chain): Validator | undefined {
+    const chainName = (chain as any).chain || chain
+    const networkType = (chain as any).networkType || NetworkType.MainNet
+
+    const key = Object.keys(chainValidators).find(key =>
+        key.toUpperCase() === chainName.toUpperCase() || chainValidators[key]
+            ?.alternatives
+            ?.map(alternative => alternative.toUpperCase())
+            ?.includes(chainName.toUpperCase())
+    )
+
+    return chainValidators[key]?.validator[networkType] || chainValidators[key]?.validator
+}

package/src/crypto/base32.ts

@@ -0,0 +1,66 @@
+const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+ /**
+* Encode a string to base32
+*/
+const b32encode = function(s: string) {
+    const parts = [];
+    let quanta = Math.floor((s.length / 5));
+    const leftover = s.length % 5;
+
+     if (leftover != 0) {
+        for (let i = 0; i < (5 - leftover); i++) {
+            s += '\x00';
+        }
+        quanta += 1;
+    }
+
+     for (let i = 0; i < quanta; i++) {
+        parts.push(alphabet.charAt(s.charCodeAt(i * 5) >> 3));
+        parts.push(alphabet.charAt(((s.charCodeAt(i * 5) & 0x07) << 2) | (s.charCodeAt(i * 5 + 1) >> 6)));
+        parts.push(alphabet.charAt(((s.charCodeAt(i * 5 + 1) & 0x3F) >> 1)));
+        parts.push(alphabet.charAt(((s.charCodeAt(i * 5 + 1) & 0x01) << 4) | (s.charCodeAt(i * 5 + 2) >> 4)));
+        parts.push(alphabet.charAt(((s.charCodeAt(i * 5 + 2) & 0x0F) << 1) | (s.charCodeAt(i * 5 + 3) >> 7)));
+        parts.push(alphabet.charAt(((s.charCodeAt(i * 5 + 3) & 0x7F) >> 2)));
+        parts.push(alphabet.charAt(((s.charCodeAt(i * 5 + 3) & 0x03) << 3) | (s.charCodeAt(i * 5 + 4) >> 5)));
+        parts.push(alphabet.charAt(((s.charCodeAt(i * 5 + 4) & 0x1F))));
+    }
+
+    let replace = 0;
+    if (leftover == 1) replace = 6;
+    else if (leftover == 2) replace = 4;
+    else if (leftover == 3) replace = 3;
+    else if (leftover == 4) replace = 1;
+
+    for (let i = 0; i < replace; i++) parts.pop();
+    for (let i = 0; i < replace; i++) parts.push("=");
+
+     return parts.join("");
+}
+
+/**
+* Decode a base32 string.
+* This is made specifically for our use, deals only with proper strings
+*/
+const b32decode = function(s: string) {
+    const r = new ArrayBuffer(s.length * 5 / 8);
+    const b = new Uint8Array(r);
+    for (let j = 0; j < s.length / 8; j++) {
+        const v = [0, 0, 0, 0, 0, 0, 0, 0];
+        for (let i = 0; i < 8; ++i) {
+            v[i] = alphabet.indexOf(s[j * 8 + i]);
+        }
+        const i = 0;
+        b[j * 5 + 0] = (v[i + 0] << 3) | (v[i + 1] >> 2);
+        b[j * 5 + 1] = ((v[i + 1] & 0x3) << 6) | (v[i + 2] << 1) | (v[i + 3] >> 4);
+        b[j * 5 + 2] = ((v[i + 3] & 0xf) << 4) | (v[i + 4] >> 1);
+        b[j * 5 + 3] = ((v[i + 4] & 0x1) << 7) | (v[i + 5] << 2) | (v[i + 6] >> 3);
+        b[j * 5 + 4] = ((v[i + 6] & 0x7) << 5) | (v[i + 7]);
+    }
+    return b;
+}
+
+export default {
+    b32decode,
+    b32encode
+};