multichain-address-validator 0.7.3 → 0.7.5

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.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.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.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.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.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.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.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.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.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.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;

package/dist/{chain-validators.js → esm/chain-validators.js}

@@ -72,7 +72,7 @@ const chainValidators = {
         alternatives: ['ltc'],
         validator: {
             mainnet: BTCValidator({
-                addressTypes: ['30', '05', '32'],
+                addressTypes: ['30', '32'],
                 bech32Hrp: ['ltc'],
             }),
             testnet: BTCValidator({

package/dist/esm/crypto/base32.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    b32decode: (s: string) => Uint8Array;
+    b32encode: (s: string) => string;
+};
+export default _default;

package/dist/esm/crypto/base58.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    decode: (string: string) => number[];
+};
+export default _default;

package/dist/esm/crypto/bech32.d.ts

@@ -0,0 +1,17 @@
+declare namespace _default {
+    export { decode };
+    export { encode };
+    export { encodings };
+    export { verifyChecksum };
+}
+export default _default;
+declare function decode(bechString: any, enc: any): {
+    hrp: any;
+    data: number[];
+};
+declare function encode(hrp: any, data: any, enc: any): string;
+declare namespace encodings {
+    let BECH32: string;
+    let BECH32M: string;
+}
+declare function verifyChecksum(hrp: any, data: any, enc: any): boolean;

package/dist/esm/crypto/biginteger.d.ts

@@ -0,0 +1,57 @@
+export function BigInteger(n: any, s: any, token: any): BigInteger;
+export class BigInteger {
+    constructor(n: any, s: any, token: any);
+    _d: any;
+    _s: any;
+    toString(base: any): any;
+    add(n: any): any;
+    negate(): BigInteger;
+    abs(): BigInteger;
+    subtract(n: any): any;
+    compareAbs(n: any): any;
+    compare(n: any): any;
+    isUnit(): boolean;
+    multiply(n: any): any;
+    multiplySingleDigit(n: any): any;
+    square(): BigInteger;
+    quotient(n: any): BigInteger;
+    divide: any;
+    remainder(n: any): BigInteger;
+    divRem(n: any): BigInteger[];
+    divRemSmall(n: any): BigInteger[];
+    isEven(): boolean;
+    isOdd(): boolean;
+    sign(): any;
+    isPositive(): boolean;
+    isNegative(): boolean;
+    isZero(): boolean;
+    exp10(n: any): BigInteger;
+    pow(n: any): BigInteger;
+    modPow(exponent: any, modulus: any): BigInteger;
+    log(): number;
+    valueOf(): any;
+    toJSValue(): number;
+    lowVal(): any;
+}
+export namespace BigInteger {
+    export function _construct(n: any, s: any): BigInteger;
+    export { BigInteger_base as base };
+    export { BigInteger_base_log10 as base_log10 };
+    export { ZERO };
+    export { ONE };
+    export { M_ONE };
+    export { ZERO as _0 };
+    export { ONE as _1 };
+    export let small: BigInteger[];
+    export let digits: string[];
+    export let radixRegex: RegExp[];
+    export function parse(s: any, base: any): BigInteger;
+    export { MAX_EXP };
+}
+declare var BigInteger_base: number;
+declare var BigInteger_base_log10: number;
+declare var ZERO: BigInteger;
+declare var ONE: BigInteger;
+declare var M_ONE: BigInteger;
+declare var MAX_EXP: BigInteger;
+export {};

package/dist/esm/crypto/blake256.d.ts

@@ -0,0 +1,22 @@
+export default Blake256;
+declare function Blake256(): void;
+declare class Blake256 {
+    _h: number[];
+    _s: number[];
+    _block: any;
+    _blockOffset: number;
+    _length: number[];
+    _nullt: boolean;
+    _zo: any;
+    _oo: any;
+    _length_carry(arr: any): void;
+    update(data: any, encoding: any): this;
+    _compress(): void;
+    _padding(): void;
+    digest(encoding: any): any;
+}
+declare namespace Blake256 {
+    let sigma: number[][];
+    let u256: number[];
+    let padding: any;
+}

package/dist/esm/crypto/blake2b.d.ts

@@ -0,0 +1,13 @@
+export default Blake2b;
+declare function Blake2b(outlen: any, key: any, salt: any, personal: any): void;
+declare class Blake2b {
+    constructor(outlen: any, key: any, salt: any, personal: any);
+    b: Uint8Array;
+    h: Uint32Array;
+    t: number;
+    c: number;
+    outlen: any;
+    update(input: any): this;
+    digest(out: any): any;
+    final: any;
+}

package/dist/esm/crypto/cnBase58.d.ts

@@ -0,0 +1,7 @@
+export default cnBase58;
+declare namespace cnBase58 {
+    function encode_block(data: any, buf: any, index: any): any;
+    function encode(hex: any): string;
+    function decode_block(data: any, buf: any, index: any): any;
+    function decode(enc: any): string;
+}

package/dist/{crypto → esm/crypto}/cnBase58.js

@@ -1,4 +1,4 @@
-import { BigInteger as JSBigInt } from './biginteger';
+import { BigInteger as JSBigInt } from './biginteger.js';
 /**
 Copyright (c) 2017, moneroexamples
 

package/dist/esm/crypto/segwit_addr.d.ts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    export { encode };
+    export { decode };
+    export { isValidAddress };
+}
+export default _default;
+declare function encode(hrp: any, version: any, program: any): string;
+declare function decode(hrp: any, addr: any): {
+    version: number;
+    program: number[];
+};
+declare function isValidAddress(address: any, opts?: {}): boolean;

package/dist/{crypto → esm/crypto}/segwit_addr.js

@@ -17,7 +17,7 @@
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
-import bech32 from './bech32';
+import bech32 from './bech32.js';
 function convertbits(data, frombits, tobits, pad) {
     var acc = 0;
     var bits = 0;

package/dist/esm/crypto/utils.d.ts

@@ -0,0 +1,26 @@
+declare function numberToHex(number: number, length: number): string;
+declare function byteArray2hexStr(byteArray: number[]): string;
+declare function hexStr2byteArray(str: string): Uint8Array;
+declare const _default: {
+    numberToHex: typeof numberToHex;
+    toHex: (arrayOfBytes: any) => string;
+    sha256: (payload: any, format?: string) => string;
+    sha256x2: (buffer: any, format?: string) => any;
+    sha256Checksum: (payload: any) => any;
+    sha512: (payload: any, format?: string) => string;
+    sha512_256: (payload: any, format?: string) => string;
+    blake256: (hexString: string) => any;
+    blake256Checksum: (payload: any) => any;
+    blake2b: (hexString: string, outlen: number) => any;
+    keccak256: (hexString: string) => string;
+    keccak256Checksum: (payload: any) => any;
+    blake2b256: (hexString: string) => any;
+    base58: (string: string) => number[];
+    byteArray2hexStr: typeof byteArray2hexStr;
+    hexStr2byteArray: typeof hexStr2byteArray;
+    base32: {
+        b32decode: (s: string) => Uint8Array;
+        b32encode: (s: string) => string;
+    };
+};
+export default _default;

package/dist/esm/helpers.d.ts

@@ -0,0 +1,2 @@
+import { Address } from './types.js';
+export declare function getAddress(address: Address): string;

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+import { Address, Chain, NetworkType } from './types.js';
+export declare function validate(address: Address, chain: Chain): boolean;
+export type { Address, Chain };
+export { NetworkType };
+declare const _default: {
+    validate: typeof validate;
+};
+export default _default;

package/dist/{multichain-address-validator.js → esm/index.js}

@@ -1,3 +1,4 @@
+import { NetworkType } from './types.js';
 import { getValidatorForChain } from './chain-validators.js';
 export function validate(address, chain) {
     const validator = getValidatorForChain(chain);
@@ -6,3 +7,7 @@ export function validate(address, chain) {
     }
     return validator.isValidAddress(address);
 }
+export { NetworkType };
+export default {
+    validate
+};

package/dist/esm/types.d.ts

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

package/dist/esm/validators/algorand_validator.d.ts

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

package/dist/esm/validators/base58_validator.d.ts

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