multichain-address-validator 0.7.4 → 0.7.5

package/dist/cjs/validators/ethereum_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/cjs/validators/ethereum_validator.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = __importDefault(require("../crypto/utils.js"));
+const helpers_js_1 = require("../helpers.js");
+exports.default = {
+    isValidAddress: function (address) {
+        const addr = (0, helpers_js_1.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 = utils_js_1.default.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/cjs/validators/hedera_validator.d.ts

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

package/dist/cjs/validators/hedera_validator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_js_1 = require("../helpers.js");
+exports.default = {
+    isValidAddress(address) {
+        // Regex to validate the format "shard.realm.account"
+        const regex = /^\d+\.\d+\.\d+$/;
+        return regex.test((0, helpers_js_1.getAddress)(address));
+    }
+};

package/dist/cjs/validators/index.d.ts

@@ -0,0 +1,18 @@
+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 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";

package/dist/cjs/validators/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XLMValidator = exports.TronValidator = exports.TezosValidator = exports.SolanaValidator = exports.SiaValidator = exports.RippleValidator = exports.PolkadotValidator = exports.NanoValidator = exports.NemValidator = exports.MoveValidator = exports.MoneroValidator = exports.HederaValidator = exports.ETHValidator = exports.EOSValidator = exports.CardanoValidator = exports.BTCValidator = exports.BCHValidator = exports.AlgorandValidator = void 0;
+var algorand_validator_js_1 = require("./algorand_validator.js");
+Object.defineProperty(exports, "AlgorandValidator", { enumerable: true, get: function () { return __importDefault(algorand_validator_js_1).default; } });
+var bch_validator_js_1 = require("./bch_validator.js");
+Object.defineProperty(exports, "BCHValidator", { enumerable: true, get: function () { return __importDefault(bch_validator_js_1).default; } });
+var bitcoin_validator_js_1 = require("./bitcoin_validator.js");
+Object.defineProperty(exports, "BTCValidator", { enumerable: true, get: function () { return __importDefault(bitcoin_validator_js_1).default; } });
+var cardano_validator_js_1 = require("./cardano_validator.js");
+Object.defineProperty(exports, "CardanoValidator", { enumerable: true, get: function () { return __importDefault(cardano_validator_js_1).default; } });
+var eos_validator_js_1 = require("./eos_validator.js");
+Object.defineProperty(exports, "EOSValidator", { enumerable: true, get: function () { return __importDefault(eos_validator_js_1).default; } });
+var ethereum_validator_js_1 = require("./ethereum_validator.js");
+Object.defineProperty(exports, "ETHValidator", { enumerable: true, get: function () { return __importDefault(ethereum_validator_js_1).default; } });
+var hedera_validator_js_1 = require("./hedera_validator.js");
+Object.defineProperty(exports, "HederaValidator", { enumerable: true, get: function () { return __importDefault(hedera_validator_js_1).default; } });
+var monero_validator_js_1 = require("./monero_validator.js");
+Object.defineProperty(exports, "MoneroValidator", { enumerable: true, get: function () { return __importDefault(monero_validator_js_1).default; } });
+var move_validator_js_1 = require("./move_validator.js");
+Object.defineProperty(exports, "MoveValidator", { enumerable: true, get: function () { return __importDefault(move_validator_js_1).default; } });
+var nem_validator_js_1 = require("./nem_validator.js");
+Object.defineProperty(exports, "NemValidator", { enumerable: true, get: function () { return __importDefault(nem_validator_js_1).default; } });
+var nano_validator_js_1 = require("./nano_validator.js");
+Object.defineProperty(exports, "NanoValidator", { enumerable: true, get: function () { return __importDefault(nano_validator_js_1).default; } });
+var polkadot_validator_js_1 = require("./polkadot_validator.js");
+Object.defineProperty(exports, "PolkadotValidator", { enumerable: true, get: function () { return __importDefault(polkadot_validator_js_1).default; } });
+var ripple_validator_js_1 = require("./ripple_validator.js");
+Object.defineProperty(exports, "RippleValidator", { enumerable: true, get: function () { return __importDefault(ripple_validator_js_1).default; } });
+var sia_validator_js_1 = require("./sia_validator.js");
+Object.defineProperty(exports, "SiaValidator", { enumerable: true, get: function () { return __importDefault(sia_validator_js_1).default; } });
+var solana_validator_js_1 = require("./solana_validator.js");
+Object.defineProperty(exports, "SolanaValidator", { enumerable: true, get: function () { return __importDefault(solana_validator_js_1).default; } });
+var tezos_validator_js_1 = require("./tezos_validator.js");
+Object.defineProperty(exports, "TezosValidator", { enumerable: true, get: function () { return __importDefault(tezos_validator_js_1).default; } });
+var tron_validator_js_1 = require("./tron_validator.js");
+Object.defineProperty(exports, "TronValidator", { enumerable: true, get: function () { return __importDefault(tron_validator_js_1).default; } });
+var xlm_validator_js_1 = require("./xlm_validator.js");
+Object.defineProperty(exports, "XLMValidator", { enumerable: true, get: function () { return __importDefault(xlm_validator_js_1).default; } });

package/dist/cjs/validators/monero_validator.d.ts

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

package/dist/cjs/validators/monero_validator.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = __importDefault(require("../crypto/utils.js"));
+const helpers_js_1 = require("../helpers.js");
+const cnBase58_js_1 = __importDefault(require("../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, networkType, addressType) {
+    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) {
+    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;
+}
+exports.default = (networkType) => ({
+    isValidAddress(address) {
+        const addr = (0, helpers_js_1.getAddress)(address);
+        let addressType = 'standard';
+        if (!addressRegTest.test(addr)) {
+            if (integratedAddressRegTest.test(addr)) {
+                addressType = 'integrated';
+            }
+            else {
+                return false;
+            }
+        }
+        const decodedAddrStr = cnBase58_js_1.default.decode(addr);
+        if (!decodedAddrStr)
+            return false;
+        if (!validateNetwork(decodedAddrStr, networkType, addressType))
+            return false;
+        const addrChecksum = decodedAddrStr.slice(-8);
+        const hashChecksum = utils_js_1.default.keccak256Checksum(hextobin(decodedAddrStr.slice(0, -8)));
+        return addrChecksum === hashChecksum;
+    }
+});

package/dist/cjs/validators/move_validator.d.ts

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

package/dist/cjs/validators/move_validator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_js_1 = require("../helpers.js");
+const regexp = new RegExp('^0x[0-9a-fA-F]{64}$');
+exports.default = {
+    isValidAddress(address) {
+        const addr = (0, helpers_js_1.getAddress)(address);
+        return regexp.test(addr);
+    },
+};

package/dist/cjs/validators/nano_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/cjs/validators/nano_validator.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_x_1 = __importDefault(require("base-x"));
+const utils_js_1 = __importDefault(require("../crypto/utils.js"));
+const helpers_js_1 = require("../helpers.js");
+const ALLOWED_CHARS = '13456789abcdefghijkmnopqrstuwxyz';
+const codec = (0, base_x_1.default)(ALLOWED_CHARS);
+// https://github.com/nanocurrency/raiblocks/wiki/Accounts,-Keys,-Seeds,-and-Wallet-Identifiers
+const regexp = new RegExp('^(xrb|nano)_([' + ALLOWED_CHARS + ']{60})$');
+exports.default = {
+    isValidAddress(address) {
+        const addr = (0, helpers_js_1.getAddress)(address);
+        if (regexp.test(addr)) {
+            return this.verifyChecksum(addr);
+        }
+        return false;
+    },
+    verifyChecksum: function (address) {
+        const bytes = codec.decode(regexp.exec(address)[2]).slice(-37);
+        // https://github.com/nanocurrency/raiblocks/blob/master/rai/lib/numbers.cpp#L73
+        const computedChecksum = utils_js_1.default.blake2b(utils_js_1.default.toHex(bytes.slice(0, -5)), 5);
+        const checksum = utils_js_1.default.toHex(bytes.slice(-5).reverse());
+        return computedChecksum === checksum;
+    }
+};

package/dist/cjs/validators/nem_validator.d.ts

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

package/dist/cjs/validators/nem_validator.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const buffer_1 = require("buffer");
+const utils_js_1 = __importDefault(require("../crypto/utils.js"));
+const helpers_js_1 = require("../helpers.js");
+exports.default = {
+    isValidAddress(address) {
+        const addr = (0, helpers_js_1.getAddress)(address).toString().toUpperCase().replace(/-/g, '');
+        if (!address || addr.length !== 40) {
+            return false;
+        }
+        const decoded = utils_js_1.default.toHex(utils_js_1.default.base32.b32decode(addr));
+        const stepThreeChecksum = utils_js_1.default.keccak256Checksum(buffer_1.Buffer.from(decoded.slice(0, 42), 'hex'));
+        return stepThreeChecksum === decoded.slice(42);
+    }
+};

package/dist/cjs/validators/polkadot_validator.d.ts

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

package/dist/cjs/validators/polkadot_validator.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = __importDefault(require("../crypto/utils.js"));
+const helpers_js_1 = require("../helpers.js");
+// from https://github.com/paritytech/substrate/wiki/External-Address-Format-(SS58)
+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 },
+];
+function verifyChecksum(address) {
+    try {
+        const preImage = '53533538505245';
+        const decoded = utils_js_1.default.base58(address);
+        const addressType = utils_js_1.default.byteArray2hexStr(decoded.slice(0, 1));
+        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 = utils_js_1.default.byteArray2hexStr(addressAndChecksum.slice(0, addressFormat.accountIndexLength));
+        const checksum = utils_js_1.default.byteArray2hexStr(addressAndChecksum.slice(-addressFormat.checkSumLength));
+        const calculatedHash = utils_js_1.default
+            .blake2b(preImage + addressType + decodedAddress, 64)
+            .substr(0, addressFormat.checkSumLength * 2)
+            .toUpperCase();
+        return calculatedHash == checksum;
+    }
+    catch (err) {
+        return false;
+    }
+}
+exports.default = {
+    isValidAddress(address) {
+        return verifyChecksum((0, helpers_js_1.getAddress)(address));
+    },
+};

package/dist/cjs/validators/ripple_validator.d.ts

@@ -0,0 +1,10 @@
+import { Address } from '../types.js';
+declare const _default: {
+    /**
+     * ripple address validation
+     */
+    isValidAddress: (address: Address) => any;
+    verifyMemo(destinationTag: string | null): boolean;
+    verifyChecksum: (address: string) => boolean;
+};
+export default _default;

package/dist/cjs/validators/ripple_validator.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_x_1 = __importDefault(require("base-x"));
+const utils_js_1 = __importDefault(require("../crypto/utils.js"));
+const helpers_js_1 = require("../helpers.js");
+const ALLOWED_CHARS = 'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz';
+const codec = (0, base_x_1.default)(ALLOWED_CHARS);
+const regexp = new RegExp('^r[' + ALLOWED_CHARS + ']{27,35}$');
+exports.default = {
+    /**
+     * ripple address validation
+     */
+    isValidAddress: function (address) {
+        const addr = (0, helpers_js_1.getAddress)(address);
+        const destinationTag = address.destinationTag;
+        const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
+        return validAddress && this.verifyMemo(destinationTag);
+    },
+    verifyMemo(destinationTag) {
+        if (!destinationTag)
+            return true; // Optional
+        const tagNumber = Number(destinationTag);
+        // A destination tag is a 32-bit unsigned integer.
+        return /^[0-9]+$/.test(destinationTag) && tagNumber >= 0 && tagNumber <= 4294967295;
+    },
+    verifyChecksum: function (address) {
+        const bytes = codec.decode(address);
+        const computedChecksum = utils_js_1.default.sha256Checksum(utils_js_1.default.toHex(bytes.slice(0, -4)));
+        const checksum = utils_js_1.default.toHex(bytes.slice(-4));
+        return computedChecksum === checksum;
+    }
+};

package/dist/cjs/validators/sia_validator.d.ts

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

package/dist/cjs/validators/sia_validator.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+const utils_js_1 = __importDefault(require("../crypto/utils.js"));
+const helpers_js_1 = require("../helpers.js");
+function hexToBytes(hex) {
+    const bytes = [];
+    for (let c = 0; c < hex.length; c += 2) {
+        bytes.push(parseInt(hex.substr(c, 2), 16));
+    }
+    return bytes;
+}
+function verifyChecksum(address) {
+    const checksumBytes = address.slice(0, 32 * 2);
+    const check = address.slice(32 * 2, 38 * 2);
+    const blakeHash = utils_js_1.default.blake2b(checksumBytes, 32).slice(0, 6 * 2);
+    return !!(0, lodash_isequal_1.default)(blakeHash, check);
+}
+exports.default = {
+    isValidAddress: function (address) {
+        const addr = (0, helpers_js_1.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/dist/cjs/validators/solana_validator.d.ts

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

package/dist/cjs/validators/solana_validator.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base58_validator_js_1 = __importDefault(require("./base58_validator.js"));
+const helpers_js_1 = require("../helpers.js");
+exports.default = {
+    isValidAddress: function (address) {
+        return base58_validator_js_1.default.isValidAddress((0, helpers_js_1.getAddress)(address), {
+            maxLength: 44,
+            minLength: 43,
+        });
+    }
+};

package/dist/cjs/validators/tezos_validator.d.ts

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

package/dist/cjs/validators/tezos_validator.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base58_js_1 = __importDefault(require("../crypto/base58.js"));
+const utils_js_1 = __importDefault(require("../crypto/utils.js"));
+const helpers_js_1 = require("../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 = utils_js_1.default.hexStr2byteArray(utils_js_1.default.sha256x2(utils_js_1.default.byteArray2hexStr(payload)));
+    if (checksum[0] ^ newChecksum[0] |
+        checksum[1] ^ newChecksum[1] |
+        checksum[2] ^ newChecksum[2] |
+        checksum[3] ^ newChecksum[3])
+        return;
+    return payload;
+}
+exports.default = {
+    isValidAddress(address) {
+        try {
+            let buffer = base58_js_1.default.decode((0, helpers_js_1.getAddress)(address));
+            let payload = decodeRaw(buffer);
+            if (!payload)
+                return false;
+            payload.slice(prefix.length);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+};

package/dist/cjs/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/cjs/validators/tron_validator.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = __importDefault(require("../crypto/utils.js"));
+const helpers_js_1 = require("../helpers.js");
+function decodeBase58Address(base58String) {
+    if (typeof (base58String) !== 'string') {
+        return false;
+    }
+    if (base58String.length !== 34) {
+        return false;
+    }
+    let address;
+    try {
+        address = utils_js_1.default.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 = utils_js_1.default.sha256(utils_js_1.default.byteArray2hexStr(address));
+    const hash1 = utils_js_1.default.hexStr2byteArray(utils_js_1.default.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']
+};
+exports.default = (opts) => ({
+    isValidAddress: function (address) {
+        const _opts = { ...DefaultTronValidatorOpts, ...opts };
+        const addr = decodeBase58Address((0, helpers_js_1.getAddress)(address));
+        if (!addr) {
+            return false;
+        }
+        if (addr.length !== 21) {
+            return false;
+        }
+        return _opts.addressTypes.includes(addr[0].toString());
+    }
+});

package/dist/cjs/validators/xlm_validator.d.ts

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

package/dist/cjs/validators/xlm_validator.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_x_1 = __importDefault(require("base-x"));
+const crc_1 = __importDefault(require("crc"));
+const utils_js_1 = __importDefault(require("../crypto/utils.js"));
+const helpers_js_1 = require("../helpers.js");
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+const base32 = (0, base_x_1.default)(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;
+}
+exports.default = {
+    isValidAddress: function (address) {
+        const addr = (0, helpers_js_1.getAddress)(address);
+        const destinationTag = address.destinationTag;
+        const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
+        return validAddress && this.verifyMemo(destinationTag);
+    },
+    verifyMemo(memo) {
+        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) {
+        // 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 = utils_js_1.default.numberToHex(swap16(crc_1.default.crc16xmodem(bytes.slice(0, -2))), 4);
+        const checksum = utils_js_1.default.toHex(bytes.slice(-2));
+        return computedChecksum === checksum;
+    }
+};

package/dist/esm/chain-validators.d.ts

@@ -0,0 +1,2 @@
+import type { Chain, Validator } from './types.js';
+export declare function getValidatorForChain(chain: Chain): Validator | undefined;