multichain-address-validator 0.0.1

package/dist/validators/algorand_validator.js

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

package/dist/validators/base58_validator.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    isValidAddress: (address: any, opts: any) => boolean;
+};
+export default _default;

package/dist/validators/base58_validator.js

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

@@ -0,0 +1,13 @@
+import { Address, NetworkType } from '../types.js';
+interface BCHValidatorOpts {
+    addressTypes: string[];
+    expectedLength?: number;
+    bech32Hrp?: [string];
+    hashFunction?: 'blake256' | 'blake256keccak256' | 'keccak256' | 'sha256';
+    regexp?: RegExp;
+    networkType: NetworkType;
+}
+declare const _default: (opts: BCHValidatorOpts) => {
+    isValidAddress: (address: Address) => boolean;
+};
+export default _default;

package/dist/validators/bch_validator.js

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

package/dist/validators/bip173_validator.d.ts

@@ -0,0 +1,7 @@
+interface Bip173Options {
+    bech32Hrp: string[];
+}
+declare const _default: {
+    isValidAddress: (address: string, opts: Bip173Options) => boolean;
+};
+export default _default;

package/dist/validators/bip173_validator.js

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

package/dist/validators/bitcoin_validator.d.ts

@@ -0,0 +1,12 @@
+import { Address } from '../types.js';
+interface BTCValidatorOpts {
+    addressTypes: string[];
+    expectedLength?: number;
+    bech32Hrp?: [string];
+    hashFunction?: 'blake256' | 'blake256keccak256' | 'keccak256' | 'sha256';
+    regex?: RegExp;
+}
+declare const _default: (opts: BTCValidatorOpts) => {
+    isValidAddress(address: Address): boolean;
+};
+export default _default;

package/dist/validators/bitcoin_validator.js

@@ -0,0 +1,68 @@
+import base58 from '../crypto/base58.js';
+import segwit from '../crypto/segwit_addr.js';
+import cryptoUtils from '../crypto/utils.js';
+import { getAddress } from '../helpers.js';
+import { Buffer } from 'buffer';
+function getDecoded(address) {
+    try {
+        return base58.decode(address);
+    }
+    catch (e) {
+        // if decoding fails, assume invalid address
+        return null;
+    }
+}
+function getChecksum(hashFunction, payload) {
+    // 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, opts) {
+    // 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, opts) {
+    const addressType = getAddressType(address, opts);
+    if (addressType) {
+        return opts.addressTypes.indexOf(addressType) >= 0;
+    }
+    return false;
+}
+// const DefaultBTCValidatorOpts: BTCValidatorOpts = {
+//     addressTypes: {mainnet: ['00', '05'], testnet: ['6f', 'c4', '3c', '26']},
+//     bech32Hrp: {mainnet: ['bc'], testnet: ['tb']},
+// }
+export default (opts) => ({
+    isValidAddress(address) {
+        const addr = getAddress(address);
+        // const _opts = {...DefaultBTCValidatorOpts, ...opts}
+        return isValidP2PKHandP2SHAddress(addr, opts) || segwit.isValidAddress(addr, opts);
+    }
+});

package/dist/validators/cardano_validator.d.ts

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

package/dist/validators/cardano_validator.js

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

package/dist/validators/eos_validator.d.ts

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

package/dist/validators/eos_validator.js

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

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

@@ -0,0 +1,30 @@
+import cryptoUtils from '../crypto/utils.js';
+import { getAddress } from '../helpers.js';
+export default {
+    isValidAddress: function (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) {
+        // 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/dist/validators/index.d.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";

package/dist/validators/index.js

@@ -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";

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

@@ -0,0 +1,58 @@
+import cryptoUtils from '../crypto/utils.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, 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;
+}
+export default (networkType) => ({
+    isValidAddress(address) {
+        const addr = getAddress(address);
+        let addressType = '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/dist/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/validators/nano_validator.js

@@ -0,0 +1,23 @@
+import baseX from 'base-x';
+import cryptoUtils from '../crypto/utils.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) {
+        const addr = 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 = cryptoUtils.blake2b(cryptoUtils.toHex(bytes.slice(0, -5)), 5);
+        const checksum = cryptoUtils.toHex(bytes.slice(-5).reverse());
+        return computedChecksum === checksum;
+    }
+};

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

@@ -0,0 +1,14 @@
+import { Buffer } from 'buffer';
+import cryptoUtils from '../crypto/utils.js';
+import { getAddress } from '../helpers.js';
+export default {
+    isValidAddress(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/dist/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/validators/polkadot_validator.js

@@ -0,0 +1,49 @@
+import cryptoUtils from '../crypto/utils.js';
+import { getAddress } from '../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 = cryptoUtils.base58(address);
+        const addressType = cryptoUtils.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 = 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;
+    }
+}
+export default {
+    isValidAddress(address) {
+        return verifyChecksum(getAddress(address));
+    },
+};

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

@@ -0,0 +1,26 @@
+import baseX from 'base-x';
+import cryptoUtils from '../crypto/utils.js';
+import { getAddress } 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) {
+        const addr = getAddress(address);
+        const destinationTag = address.destinationTag;
+        const validAddress = regexp.test(addr) && this.verifyChecksum(addr);
+        return validAddress && this.verifyMemo(destinationTag);
+    },
+    verifyMemo(destinationTag) {
+        return !destinationTag || /[0-9]+/.test(destinationTag);
+    },
+    verifyChecksum: function (address) {
+        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/dist/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/validators/sia_validator.js

@@ -0,0 +1,27 @@
+import isEqual from 'lodash.isequal';
+import cryptoUtils from '../crypto/utils.js';
+import { getAddress } from '../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 = cryptoUtils.blake2b(checksumBytes, 32).slice(0, 6 * 2);
+    return !!isEqual(blakeHash, check);
+}
+export default {
+    isValidAddress: function (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/dist/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/validators/solana_validator.js

@@ -0,0 +1,10 @@
+import base58Validator from './base58_validator.js';
+import { getAddress } from '../helpers.js';
+export default {
+    isValidAddress: function (address) {
+        return base58Validator.isValidAddress(getAddress(address), {
+            maxLength: 44,
+            minLength: 43,
+        });
+    }
+};

package/dist/validators/tezos_validator.d.ts

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