multichain-address-validator 0.8.0 → 0.8.2

package/src/validators/index.ts

@@ -1,20 +0,0 @@
-export {default as AlgorandValidator} from "./algorand_validator.js"
-export {default as BCHValidator} from "./bch_validator.js"
-export {default as BittensorValidator} from "./bittensor_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 HederaValidator} from "./hedera_validator.js"
-export {default as MoneroValidator} from "./monero_validator.js"
-export {default as MoveValidator} from "./move_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"
-export {default as ZcashValidator} from "./zcash_validator.js"

package/src/validators/monero_validator.ts

@@ -1,72 +0,0 @@
-import cryptoUtils from '../crypto/utils.js'
-import {Address, NetworkType} from '../types.js'
-import {getAddress} from '../helpers.js'
-import cnBase58 from '../crypto/cnBase58.js'
-
-
-const addressRegTest = new RegExp(
-    '^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{95}$'
-)
-const integratedAddressRegTest = new RegExp(
-    '^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{106}$'
-)
-
-const types = {
-    addressTypes: {mainnet: ['18', '42'], testnet: ['53', '63'], stagenet: ['24']},
-    iAddressTypes: {mainnet: ['19'], testnet: ['54'], stagenet: ['25']},
-}
-
-function validateNetwork(decoded: string, networkType: NetworkType, addressType: 'standard' | 'integrated') {
-    const addressTypes = addressType === 'integrated'
-        ? types.iAddressTypes[networkType]
-        : types.addressTypes[networkType]
-
-    const at = parseInt(decoded.substr(0, 2), 16).toString()
-
-    switch (networkType) {
-        case 'mainnet':
-            return addressTypes.indexOf(at) >= 0
-        case 'testnet':
-            return addressTypes.indexOf(at) >= 0
-        // case 'stagenet':
-        //     return network.stagenet.indexOf(at) >= 0
-        // case 'both':
-        //     return network.prod.indexOf(at) >= 0 || network.testnet.indexOf(at) >= 0 || network.stagenet.indexOf(at) >= 0
-        default:
-            return false
-    }
-}
-
-function hextobin(hex: string) {
-    if (hex.length % 2 !== 0) return null
-    const res = new Uint8Array(hex.length / 2)
-    for (let i = 0; i < hex.length / 2; ++i) {
-        res[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16)
-    }
-    return res
-}
-
-
-export default (networkType: NetworkType) => ({
-    isValidAddress(address: Address) {
-        const addr = getAddress(address)
-        let addressType: 'standard' | 'integrated' = 'standard'
-        if (!addressRegTest.test(addr)) {
-            if (integratedAddressRegTest.test(addr)) {
-                addressType = 'integrated'
-            } else {
-                return false
-            }
-        }
-
-        const decodedAddrStr = cnBase58.decode(addr)
-        if (!decodedAddrStr) return false
-
-        if (!validateNetwork(decodedAddrStr, networkType, addressType)) return false
-
-        const addrChecksum = decodedAddrStr.slice(-8)
-        const hashChecksum = cryptoUtils.keccak256Checksum(hextobin(decodedAddrStr.slice(0, -8)))
-
-        return addrChecksum === hashChecksum
-    }
-})

package/src/validators/move_validator.ts

@@ -1,11 +0,0 @@
-import type { Address} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-const regexp = new RegExp('^0x[0-9a-fA-F]{64}$');
-
-export default {
-    isValidAddress(address: Address) {
-        const addr = getAddress(address)
-        return regexp.test(addr)
-    },
-};

package/src/validators/nano_validator.ts

@@ -1,32 +0,0 @@
-import baseX from 'base-x'
-
-import cryptoUtils from '../crypto/utils.js'
-import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-
-const ALLOWED_CHARS = '13456789abcdefghijkmnopqrstuwxyz';
-
-const codec = baseX(ALLOWED_CHARS);
-// https://github.com/nanocurrency/raiblocks/wiki/Accounts,-Keys,-Seeds,-and-Wallet-Identifiers
-const regexp = new RegExp('^(xrb|nano)_([' + ALLOWED_CHARS + ']{60})$');
-
-export default {
-    isValidAddress(address: Address) {
-        const addr = getAddress(address)
-        if (regexp.test(addr)) {
-            return this.verifyChecksum(addr);
-        }
-
-        return false;
-    },
-
-    verifyChecksum: function (address: string) {
-        const bytes = codec.decode(regexp.exec(address)[2]).slice(-37);
-        // https://github.com/nanocurrency/raiblocks/blob/master/rai/lib/numbers.cpp#L73
-        const computedChecksum = cryptoUtils.blake2b(cryptoUtils.toHex(bytes.slice(0, -5)), 5);
-        const checksum = cryptoUtils.toHex(bytes.slice(-5).reverse());
-
-        return computedChecksum === checksum
-    }
-};

package/src/validators/nem_validator.ts

@@ -1,18 +0,0 @@
-import {Buffer} from 'buffer'
-
-import cryptoUtils from '../crypto/utils.js'
-import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-export default {
-    isValidAddress(address: Address) {
-        const addr = getAddress(address).toString().toUpperCase().replace(/-/g, '');
-        if (!address || addr.length !== 40) {
-            return false;
-        }
-        const decoded = cryptoUtils.toHex(cryptoUtils.base32.b32decode(addr));
-        const stepThreeChecksum = cryptoUtils.keccak256Checksum(Buffer.from(decoded.slice(0, 42), 'hex'));
-
-        return stepThreeChecksum === decoded.slice(42);
-    }
-}

package/src/validators/polkadot_validator.ts

@@ -1,7 +0,0 @@
-import createSS58Validator from './ss58_validator.js'
-
-// Polkadot uses SS58 address format (Substrate-based)
-// SS58 Registry: https://github.com/paritytech/ss58-registry
-// Accepts any valid SS58 address (no network prefix restriction)
-
-export default createSS58Validator()

package/src/validators/ripple_validator.ts

@@ -1,44 +0,0 @@
-import baseX from 'base-x'
-
-import cryptoUtils from '../crypto/utils.js'
-import {Address} from '../types.js'
-import {getAddress, getMemo} from '../helpers.js'
-
-const ALLOWED_CHARS = 'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz';
-
-const codec = baseX(ALLOWED_CHARS);
-const regexp = new RegExp('^r[' + ALLOWED_CHARS + ']{27,35}$');
-
-export default {
-    /**
-     * ripple address validation
-     */
-    isValidAddress: function (address: Address) {
-        const addr = getAddress(address)
-        const memo = getMemo(address)
-
-        const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
-
-        return validAddress && this.verifyMemo(memo)
-    },
-
-    isValidMemo(memo: string): boolean {
-        return this.verifyMemo(memo)
-    },
-
-    verifyMemo(memo?: string): boolean {
-        if (!memo) return true; // Optional
-
-        const memoNumber = Number(memo);
-        // A memo is a 32-bit unsigned integer.
-        return /^[0-9]+$/.test(memo) && memoNumber >= 0 && memoNumber <= 4294967295;
-    },
-
-    verifyChecksum(address: string): boolean {
-        const bytes = codec.decode(address);
-        const computedChecksum = cryptoUtils.sha256Checksum(cryptoUtils.toHex(bytes.slice(0, -4)));
-        const checksum = cryptoUtils.toHex(bytes.slice(-4));
-
-        return computedChecksum === checksum
-    }
-};

package/src/validators/sia_validator.ts

@@ -1,33 +0,0 @@
-import isEqual from 'lodash.isequal'
-
-import cryptoUtils from '../crypto/utils.js'
-import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-function hexToBytes(hex: string) {
-    const bytes = []
-    for (let c = 0; c < hex.length; c += 2) {
-        bytes.push(parseInt(hex.substr(c, 2), 16))
-    }
-    return bytes
-}
-
-function verifyChecksum(address: string) {
-    const checksumBytes = address.slice(0, 32 * 2)
-    const check = address.slice(32 * 2, 38 * 2)
-    const blakeHash = cryptoUtils.blake2b(checksumBytes, 32).slice(0, 6 * 2)
-    return !!isEqual(blakeHash, check)
-}
-
-export default {
-    isValidAddress: function (address: Address) {
-        const addr = getAddress(address)
-        if (addr.length !== 76) {
-            // Check if it has the basic requirements of an address
-            return false
-        }
-
-        // Otherwise check each case
-        return verifyChecksum(addr)
-    },
-}

package/src/validators/solana_validator.ts

@@ -1,21 +0,0 @@
-import base58Validator from './base58_validator.js';
-import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
-import {Buffer} from 'buffer'
-import base58 from '../crypto/base58.js'
-
-export default {
-    isValidAddress: function (address: Address) {
-        const validBase58 = base58Validator.isValidAddress(getAddress(address), {
-            maxLength: 44,
-            minLength: 43,
-        })
-
-        if (!validBase58) {
-            return false
-        }
-
-        // solana address must be 32 bytes
-        return base58.decode(getAddress(address)).length === 32
-    }
-};

package/src/validators/ss58_validator.ts

@@ -1,80 +0,0 @@
-import cryptoUtils from '../crypto/utils.js'
-import {Address, Validator} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-// SS58 address format (Substrate-based)
-// SS58 Registry: https://github.com/paritytech/ss58-registry
-const addressFormats = [
-    {addressLength: 3, accountIndexLength: 1, checkSumLength: 1},
-    {addressLength: 4, accountIndexLength: 2, checkSumLength: 1},
-    {addressLength: 5, accountIndexLength: 2, checkSumLength: 2},
-    {addressLength: 6, accountIndexLength: 4, checkSumLength: 1},
-    {addressLength: 7, accountIndexLength: 4, checkSumLength: 2},
-    {addressLength: 8, accountIndexLength: 4, checkSumLength: 3},
-    {addressLength: 9, accountIndexLength: 4, checkSumLength: 4},
-    {addressLength: 10, accountIndexLength: 8, checkSumLength: 1},
-    {addressLength: 11, accountIndexLength: 8, checkSumLength: 2},
-    {addressLength: 12, accountIndexLength: 8, checkSumLength: 3},
-    {addressLength: 13, accountIndexLength: 8, checkSumLength: 4},
-    {addressLength: 14, accountIndexLength: 8, checkSumLength: 5},
-    {addressLength: 15, accountIndexLength: 8, checkSumLength: 6},
-    {addressLength: 16, accountIndexLength: 8, checkSumLength: 7},
-    {addressLength: 17, accountIndexLength: 8, checkSumLength: 8},
-    {addressLength: 34, accountIndexLength: 32, checkSumLength: 2},
-];
-
-interface SS58ValidatorOptions {
-    // Network prefix to validate (in decimal). If provided, only addresses with this prefix are valid.
-    // Examples: 0 = Polkadot, 2 = Kusama, 42 = Substrate/Bittensor
-    networkPrefix?: number;
-}
-
-/**
- * Creates an SS58 validator with optional network prefix filtering
- * @param options Configuration options including optional network prefix
- * @returns Validator instance for SS58 addresses
- */
-export default function createSS58Validator(options: SS58ValidatorOptions = {}): Validator {
-    function verifyChecksum(address: string): boolean {
-        try {
-            const preImage = '53533538505245'
-            const decoded = cryptoUtils.base58(address);
-            const addressType = cryptoUtils.byteArray2hexStr(decoded.slice(0, 1));
-
-            // If a specific network prefix is required, validate it
-            if (options.networkPrefix !== undefined) {
-                const expectedPrefix = options.networkPrefix.toString(16).padStart(2, '0').toUpperCase();
-                if (addressType.toUpperCase() !== expectedPrefix) {
-                    return false;
-                }
-            }
-
-            const addressAndChecksum = decoded.slice(1)
-
-            // get the address format
-            const addressFormat = addressFormats.find(af => af.addressLength === addressAndChecksum.length);
-
-            if (!addressFormat) {
-                throw new Error('Invalid address length');
-            }
-
-            const decodedAddress = cryptoUtils.byteArray2hexStr(addressAndChecksum.slice(0, addressFormat.accountIndexLength));
-            const checksum = cryptoUtils.byteArray2hexStr(addressAndChecksum.slice(-addressFormat.checkSumLength));
-
-            const calculatedHash = cryptoUtils
-                .blake2b(preImage + addressType + decodedAddress, 64)
-                .substr(0, addressFormat.checkSumLength * 2)
-                .toUpperCase();
-
-            return calculatedHash == checksum;
-        } catch (err) {
-            return false;
-        }
-    }
-
-    return {
-        isValidAddress(address: Address) {
-            return verifyChecksum(getAddress(address))
-        },
-    }
-}

package/src/validators/tezos_validator.ts

@@ -1,36 +0,0 @@
-import base58 from '../crypto/base58.js'
-import cryptoUtils from '../crypto/utils.js'
-import {Address} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-const prefix = new Uint8Array([6, 161, 159]);
-
-function decodeRaw(buffer: any) {
-    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: 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/src/validators/tron_validator.ts

@@ -1,59 +0,0 @@
-import {Address} from '../types.js'
-import cryptoUtils from '../crypto/utils.js'
-import {getAddress} from '../helpers.js'
-
-function decodeBase58Address(base58String: string) {
-    if (typeof (base58String) !== 'string') {
-        return false;
-    }
-    if (base58String.length !== 34) {
-        return false;
-    }
-
-    let address: number[]
-    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;
-}
-
-interface TronValidatorOpts {
-    addressTypes: string[],
-}
-
-const DefaultTronValidatorOpts: TronValidatorOpts = {
-    addressTypes: ['65']
-}
-
-export default (opts?: TronValidatorOpts) => ({
-    isValidAddress: function (address: 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/src/validators/xlm_validator.ts

@@ -1,54 +0,0 @@
-import baseX from 'base-x'
-import crc from 'crc'
-
-import cryptoUtils from '../crypto/utils.js'
-import {Address} from '../types.js'
-import {getAddress, getMemo} from '../helpers.js'
-
-const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
-
-const base32 = baseX(ALPHABET);
-const regexp = new RegExp('^[' + ALPHABET + ']{56}$');
-const ed25519PublicKeyVersionByte = (6 << 3);
-
-function swap16(number: number) {
-    const lower = number & 0xFF;
-    const upper = (number >> 8) & 0xFF;
-    return (lower << 8) | upper;
-}
-
-export default {
-    isValidAddress: function (address: Address) {
-        const addr = getAddress(address)
-        const memo = getMemo(address)
-
-        const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
-
-        return validAddress && this.verifyMemo(memo)
-    },
-
-    isValidMemo(memo: string): boolean {
-        return this.verifyMemo(memo)
-    },
-
-    verifyMemo(memo?: string): boolean {
-        if (!memo) return true; // Optional
-
-        // Ensure it's a valid UTF-8 string and does not exceed 28 bytes
-        const encoder = new TextEncoder();
-        return encoder.encode(memo).length <= 28;
-    },
-
-    verifyChecksum: function (address: string) {
-        // 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/src/validators/zcash_validator.ts

@@ -1,57 +0,0 @@
-import base58 from '../crypto/base58.js'
-import cryptoUtils from '../crypto/utils.js'
-import {Address, NetworkType} from '../types.js'
-import {getAddress} from '../helpers.js'
-
-function getDecoded(address: string) {
-    try {
-        return base58.decode(address);
-    } catch (e) {
-        // if decoding fails, assume invalid address
-        return null;
-    }
-}
-
-function getChecksum(payload: any) {
-    return cryptoUtils.sha256Checksum(payload);
-}
-
-function isValidTransparentAddress(address: string, networkType: NetworkType) {
-    // Zcash transparent addresses use 2-byte version prefixes
-    // Expected length: 26 bytes (2 bytes version + 20 bytes payload + 4 bytes checksum)
-    const expectedLength = 26;
-    const decoded = getDecoded(address);
-
-    if (!decoded || decoded.length !== expectedLength) {
-        return false;
-    }
-
-    const checksum = cryptoUtils.toHex(decoded.slice(expectedLength - 4, expectedLength));
-    const body = cryptoUtils.toHex(decoded.slice(0, expectedLength - 4));
-    const goodChecksum = getChecksum(body);
-
-    if (checksum !== goodChecksum) {
-        return false;
-    }
-
-    // Get the 2-byte version prefix
-    const versionPrefix = cryptoUtils.toHex(decoded.slice(0, 2));
-
-    // Define valid version prefixes for each network
-    // Only supporting transparent addresses (t1/t3 for mainnet, tm/t2 for testnet)
-    const validPrefixes = networkType === NetworkType.MainNet
-        ? ['1cb8', '1cbd'] // t1 (P2PKH) and t3 (P2SH) for mainnet
-        : ['1d25', '1cba']; // tm (P2PKH) and t2 (P2SH) for testnet
-
-    return validPrefixes.includes(versionPrefix);
-}
-
-export default (networkType: NetworkType) => ({
-    isValidAddress(address: Address): boolean {
-        const addr = getAddress(address);
-
-        // Only validate transparent addresses (t1/t3 for mainnet, tm/t2 for testnet)
-        // Sapling (zs) and Unified (u) addresses are NOT supported
-        return isValidTransparentAddress(addr, networkType);
-    }
-})

package/test/addresses/addresses.ts

@@ -1,63 +0,0 @@
-import algorand from './algorand.json'
-import aptos from './aptos.json'
-import bch from './bch.json'
-import bchTestnet from './bch-testnet.json'
-import bittensor from './bittensor.json'
-import btc from './btc.json'
-import btcTestnet from './btc-testnet.json'
-import cardano from './cardano.json'
-import doge from './doge.json'
-import dogeTestnet from './doge-testnet.json'
-import eos from './eos.json'
-import evm from './evm.json'
-import hbar from './hbar.json'
-import ltc from './ltc.json'
-import ltcTestnet from './ltc-testnet.json'
-import monero from './monero.json'
-import moneroTestnet from './monero-testnet.json'
-import nem from './nem.json'
-import nano from './nano.json'
-import polkadot from './polkadot.json'
-import ripple from './ripple.json'
-import sia from './sia.json'
-import solana from './solana.json'
-import sui from './sui.json'
-import tezos from './tezos.json'
-import tron from './tron.json'
-import xlm from './xlm.json'
-import zcash from './zcash.json'
-
-export type TestAddress = string | { address: string, memo?: string } & { invalid?: boolean, invalidMemo?: boolean }
-
-const testAddresses: Record<string, TestAddress[]> = {
-    aptos,
-    algorand,
-    bch,
-    'bch-testnet': bchTestnet,
-    bittensor,
-    btc,
-    'btc-testnet': btcTestnet,
-    cardano,
-    doge,
-    'doge-testnet': dogeTestnet,
-    eos,
-    evm,
-    hbar,
-    ltc,
-    'ltc-testnet': ltcTestnet,
-    monero,
-    'monero-testnet': moneroTestnet,
-    nem,
-    nano,
-    polkadot,
-    ripple,
-    sia,
-    sui,
-    solana,
-    tezos,
-    tron,
-    xlm,
-    zcash,
-} as const;
-
-export default testAddresses

package/test/addresses/algorand.json

@@ -1,6 +0,0 @@
-[
-    "GONISIUAYDOMHM7VURRAAAP5H6OAWRRBCPXEIOZO3QI7TZKR5GTAQ7WK7Y",
-    "LCRDY3LYAANTVS3XRHEHWHGXRTKZYVTX55P5IA2AT5ZDJ4CWZFFZIKVHLI",
-    "SP745JJR4KPRQEXJZHVIEN736LYTL2T2DFMG3OIIFJBV66K73PHNMDCZVM",
-    "AKHSHWO2TUWE53RMVG6ZUBNAEX6MTYPT76TCIDCDWYUUTK6HCJTZS2HDQU"
-]

package/test/addresses/aptos.json

@@ -1,6 +0,0 @@
-[
-    "0xaabf25b0c115130a4ad88bfa08627c5a103b7851e90869c23fadaf0512dd5133",
-    "0xdce6ab89a1d26c99491a70fd4a2536d065925114deee916a1ae7d35007f4dedf",
-    "0xd05448f15a03f25b2816c4538b72bd54752ba7522d4831a4c9ea5a613becb47a",
-    "0x39f521d22f611a4dec2f790fef2e4f8d1f96550509e85beccf8acec52c1a7219"
-]

package/test/addresses/bch-testnet.json

@@ -1,4 +0,0 @@
-[
-    "mzBc4XEFSdzCDcTxAgf6EZXgsZWpztRhef",
-    "2MxKEf2su6FGAUfCEAHreGFQvEYrfYNHvL7"
-]

package/test/addresses/bch.json

@@ -1,7 +0,0 @@
-[
-    "12KYrjTdVGjFMtaxERSk3gphreJ5US8aUP",
-    "12QeMLzSrB8XH8FvEzPMVoRxVAzTr5XM2y",
-    "1oNLrsHnBcR6dpaBpwz3LSwutbUNkNSjs",
-    "3NJZLcZEEYBpxYEUGewU4knsQRn1WM5Fkt",
-    "bitcoincash:qq4v32mtagxac29my6gwj6fd4tmqg8rysu23dax807"
-]