multichain-address-validator 0.7.8 → 0.8.0

package/dist/esm/validators/polkadot_validator.js

@@ -1,49 +1,5 @@
-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));
-    },
-};
+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/dist/esm/validators/ss58_validator.d.ts

@@ -0,0 +1,11 @@
+import { Validator } from '../types.js';
+interface SS58ValidatorOptions {
+    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;
+export {};

package/dist/esm/validators/ss58_validator.js

@@ -0,0 +1,64 @@
+import cryptoUtils from '../crypto/utils.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 },
+];
+/**
+ * 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 = {}) {
+    function verifyChecksum(address) {
+        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) {
+            return verifyChecksum(getAddress(address));
+        },
+    };
+}

package/dist/esm/validators/zcash_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/esm/validators/zcash_validator.js

@@ -0,0 +1,47 @@
+import base58 from '../crypto/base58.js';
+import cryptoUtils from '../crypto/utils.js';
+import { NetworkType } from '../types.js';
+import { getAddress } from '../helpers.js';
+function getDecoded(address) {
+    try {
+        return base58.decode(address);
+    }
+    catch (e) {
+        // if decoding fails, assume invalid address
+        return null;
+    }
+}
+function getChecksum(payload) {
+    return cryptoUtils.sha256Checksum(payload);
+}
+function isValidTransparentAddress(address, 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) => ({
+    isValidAddress(address) {
+        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);
+    }
+});