lampamazaza-new-intents-sdk 0.47.1

package/dist/src/lib/validateAddress.cjs

@@ -0,0 +1,271 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_caip2 = require('./caip2.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+let viem = require("viem");
+let _noble_hashes_sha2 = require("@noble/hashes/sha2");
+let _scure_base = require("@scure/base");
+let _solana_web3_js = require("@solana/web3.js");
+let ripple_address_codec = require("ripple-address-codec");
+
+//#region src/lib/validateAddress.ts
+/**
+* Validates that an address matches the expected format for a given blockchain.
+*
+* Note: This validates address FORMAT only. Specific bridges may have
+* additional requirements (e.g., supported address types, memo requirements).
+* A valid format does not guarantee a bridge will accept the address.
+*/
+function validateAddress(address, blockchain) {
+	switch (blockchain) {
+		case require_caip2.Chains.Near: return lampamazaza_internal_utils.utils.validateNearAddress(address);
+		case require_caip2.Chains.Bitcoin: return validateBtcAddress(address);
+		case require_caip2.Chains.BitcoinCash: return validateBchAddress(address);
+		case require_caip2.Chains.Solana: return validateSolAddress(address);
+		case require_caip2.Chains.Dogecoin: return validateDogeAddress(address);
+		case require_caip2.Chains.Litecoin: return validateLitecoinAddress(address);
+		case require_caip2.Chains.XRPL: return validateXrpAddress(address);
+		case require_caip2.Chains.Zcash: return validateZcashAddress(address);
+		case require_caip2.Chains.Tron: return validateTronAddress(address);
+		case require_caip2.Chains.TON: return validateTonAddress(address);
+		case require_caip2.Chains.Sui: return validateSuiAddress(address);
+		case require_caip2.Chains.Stellar: return validateStellarAddress(address);
+		case require_caip2.Chains.Aptos: return validateAptosAddress(address);
+		case require_caip2.Chains.Cardano: return validateCardanoAddress(address);
+		case require_caip2.Chains.Starknet: return validateStarknetAddress(address);
+		case require_caip2.Chains.Ethereum:
+		case require_caip2.Chains.Optimism:
+		case require_caip2.Chains.BNB:
+		case require_caip2.Chains.Gnosis:
+		case require_caip2.Chains.Polygon:
+		case require_caip2.Chains.Monad:
+		case require_caip2.Chains.LayerX:
+		case require_caip2.Chains.Adi:
+		case require_caip2.Chains.Base:
+		case require_caip2.Chains.Arbitrum:
+		case require_caip2.Chains.Avalanche:
+		case require_caip2.Chains.Berachain:
+		case require_caip2.Chains.Plasma:
+		case require_caip2.Chains.Scroll: return validateEthAddress(address);
+		default: return false;
+	}
+}
+function validateEthAddress(address) {
+	return (0, viem.isAddress)(address, { strict: true });
+}
+function validateBtcAddress(address) {
+	return /^1[1-9A-HJ-NP-Za-km-z]{25,34}$/.test(address) || /^3[1-9A-HJ-NP-Za-km-z]{25,34}$/.test(address) || /^bc1[02-9ac-hj-np-z]{11,87}$/.test(address) || /^bc1p[02-9ac-hj-np-z]{42,87}$/.test(address);
+}
+/**
+* Validates Bitcoin Cash addresses
+* Supports:
+* - Legacy addresses (1... for P2PKH, 3... for P2SH) - shared with Bitcoin
+* - CashAddr format (bitcoincash:q... or q... for P2PKH, bitcoincash:p... or p... for P2SH)
+*
+* CashAddr checksum implementation based on:
+* @see https://github.com/ealmansi/cashaddrjs (MIT License)
+* @see https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md
+*/
+function validateBchAddress(address) {
+	if (/^1[1-9A-HJ-NP-Za-km-z]{25,34}$/.test(address) || /^3[1-9A-HJ-NP-Za-km-z]{25,34}$/.test(address)) return true;
+	return validateBchCashAddr(address);
+}
+/**
+* Validates Bitcoin Cash CashAddr format
+* CashAddr uses a modified Bech32 encoding with polymod checksum
+*/
+function validateBchCashAddr(address) {
+	let normalized = address.toLowerCase();
+	if (!normalized.includes(":")) normalized = `bitcoincash:${normalized}`;
+	if (!normalized.startsWith("bitcoincash:")) return false;
+	const payload = normalized.slice(12);
+	if (!payload.startsWith("q") && !payload.startsWith("p")) return false;
+	const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+	for (const char of payload) if (!CHARSET.includes(char)) return false;
+	if (payload.length !== 42 && payload.length !== 61) return false;
+	return verifyBchChecksum(normalized);
+}
+function verifyBchChecksum(address) {
+	const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+	const colonIndex = address.indexOf(":");
+	const prefix = address.slice(0, colonIndex);
+	const payload = address.slice(colonIndex + 1);
+	const prefixData = [];
+	for (const char of prefix) prefixData.push(char.charCodeAt(0) & 31);
+	prefixData.push(0);
+	const payloadData = [];
+	for (const char of payload) {
+		const idx = CHARSET.indexOf(char);
+		if (idx === -1) return false;
+		payloadData.push(idx);
+	}
+	const values = [...prefixData, ...payloadData];
+	let c = 1n;
+	for (const d of values) {
+		const c0 = c >> 35n;
+		c = (c & 34359738367n) << 5n ^ BigInt(d);
+		if (c0 & 1n) c ^= 656907472481n;
+		if (c0 & 2n) c ^= 522768456162n;
+		if (c0 & 4n) c ^= 1044723512260n;
+		if (c0 & 8n) c ^= 748107326120n;
+		if (c0 & 16n) c ^= 130178868336n;
+	}
+	return (c ^ 1n) === 0n;
+}
+function validateSolAddress(address) {
+	try {
+		return _solana_web3_js.PublicKey.isOnCurve(address);
+	} catch {
+		return false;
+	}
+}
+function validateDogeAddress(address) {
+	return /^[DA][1-9A-HJ-NP-Za-km-z]{25,33}$/.test(address);
+}
+function validateXrpAddress(address) {
+	return (0, ripple_address_codec.isValidClassicAddress)(address) || (0, ripple_address_codec.isValidXAddress)(address);
+}
+/**
+* Validates Zcash addresses
+* Supports:
+* - Transparent addresses (t1, t3)
+* - TEX addresses (tex1)
+*/
+function validateZcashAddress(address) {
+	if (address.startsWith("t1") || address.startsWith("t3")) return /^t[13][a-km-zA-HJ-NP-Z1-9]{33}$/.test(address);
+	const expectedHrp = "tex";
+	if (address.startsWith(`${expectedHrp}1`)) try {
+		const decoded = _scure_base.bech32m.decodeToBytes(address);
+		if (decoded.prefix !== expectedHrp) return false;
+		return decoded.bytes.length === 20;
+	} catch {
+		return false;
+	}
+	const uaHrp = "u";
+	if (address.startsWith(`${uaHrp}1`)) try {
+		return _scure_base.bech32m.decodeToBytes(address).prefix === uaHrp;
+	} catch {
+		return false;
+	}
+	return false;
+}
+/**
+* Validates Tron addresses
+* Supports:
+* - hex addresses
+* - base58 addresses
+* https://developers.tron.network/docs/account
+*/
+function validateTronAddress(address) {
+	return validateTronBase58Address(address) || validateTronHexAddress(address);
+}
+function validateTronBase58Address(address) {
+	try {
+		const decoded = _scure_base.base58.decode(address);
+		if (decoded.length !== 25) return false;
+		const data = decoded.slice(0, 21);
+		const checksum = decoded.slice(21);
+		const expectedChecksum = (0, _noble_hashes_sha2.sha256)((0, _noble_hashes_sha2.sha256)(data)).slice(0, 4);
+		for (let i = 0; i < 4; i++) if (checksum[i] !== expectedChecksum[i]) return false;
+		return data[0] === 65;
+	} catch {
+		return false;
+	}
+}
+function validateTronHexAddress(address) {
+	try {
+		const decoded = _scure_base.hex.decode(address);
+		return decoded.length === 21 && decoded[0] === 65;
+	} catch {
+		return false;
+	}
+}
+function validateTonAddress(address) {
+	return /^[EU]Q[0-9A-Za-z_-]{46}$/.test(address);
+}
+function validateSuiAddress(address) {
+	return /^(?:0x)?[a-fA-F0-9]{64}$/.test(address);
+}
+function validateStellarAddress(address) {
+	return /^G[A-Z0-9]{55}$/.test(address);
+}
+function validateAptosAddress(address) {
+	return /^0x[a-fA-F0-9]{64}$/.test(address);
+}
+/**
+* Validates Cardano mainnet addresses (Base + Enterprise)
+* Returns true if valid, false if invalid
+*/
+function validateCardanoAddress(address) {
+	try {
+		const { prefix, words } = _scure_base.bech32.decode(address, 120);
+		if (prefix !== "addr") return false;
+		const addrType = _scure_base.bech32.fromWords(words)[0] >> 4;
+		return addrType >= 0 && addrType <= 7;
+	} catch {
+		return false;
+	}
+}
+/**
+* Validates Starknet addresses
+* Starknet addresses are felt252 (252-bit field elements) represented as
+* hex strings with 0x prefix (up to 64 hex characters)
+*/
+function validateStarknetAddress(address) {
+	return /^0x[a-fA-F0-9]{1,64}$/.test(address);
+}
+function validateLitecoinAddress(address) {
+	const first = address[0];
+	if (first === "L") return validateLitecoinBase58Address(address, 48);
+	if (first === "M") return validateLitecoinBase58Address(address, 50);
+	if (first === "3") return validateLitecoinBase58Address(address, 5);
+	if (!address.toLowerCase().startsWith("ltc1")) return false;
+	return validateLitecoinBech32Address(address);
+}
+function validateLitecoinBase58Address(address, expectedVersion) {
+	let decoded;
+	try {
+		decoded = _scure_base.base58.decode(address);
+	} catch {
+		return false;
+	}
+	if (decoded.length !== 25) return false;
+	if (decoded[0] !== expectedVersion) return false;
+	const payload = decoded.subarray(0, 21);
+	const checksum = decoded.subarray(21, 25);
+	const expectedChecksum = (0, _noble_hashes_sha2.sha256)((0, _noble_hashes_sha2.sha256)(payload)).subarray(0, 4);
+	for (let i = 0; i < 4; i++) if (checksum[i] !== expectedChecksum[i]) return false;
+	return true;
+}
+function validateLitecoinBech32Address(address) {
+	let decoded;
+	let isBech32m = false;
+	try {
+		decoded = _scure_base.bech32.decode(address);
+	} catch {
+		try {
+			decoded = _scure_base.bech32m.decode(address);
+			isBech32m = true;
+		} catch {
+			return false;
+		}
+	}
+	if (decoded.prefix.toLowerCase() !== "ltc") return false;
+	const { words } = decoded;
+	if (!words || words.length < 1) return false;
+	const version = words[0];
+	if (version == null || version < 0 || version > 16) return false;
+	const progLen = _scure_base.bech32.fromWords(words.slice(1)).length;
+	if (progLen < 2 || progLen > 40) return false;
+	if (version === 0) {
+		if (isBech32m) return false;
+		return progLen === 20 || progLen === 32;
+	}
+	if (version === 1) {
+		if (!isBech32m) return false;
+		return progLen === 32;
+	}
+	return false;
+}
+
+//#endregion
+exports.validateAddress = validateAddress;

package/dist/src/lib/validateAddress.d.cts

@@ -0,0 +1,14 @@
+import { Chain } from "./caip2.cjs";
+
+//#region src/lib/validateAddress.d.ts
+
+/**
+ * Validates that an address matches the expected format for a given blockchain.
+ *
+ * Note: This validates address FORMAT only. Specific bridges may have
+ * additional requirements (e.g., supported address types, memo requirements).
+ * A valid format does not guarantee a bridge will accept the address.
+ */
+declare function validateAddress(address: string, blockchain: Chain): boolean;
+//#endregion
+export { validateAddress };

package/dist/src/lib/validateAddress.d.ts

@@ -0,0 +1,14 @@
+import { Chain } from "./caip2.js";
+
+//#region src/lib/validateAddress.d.ts
+
+/**
+ * Validates that an address matches the expected format for a given blockchain.
+ *
+ * Note: This validates address FORMAT only. Specific bridges may have
+ * additional requirements (e.g., supported address types, memo requirements).
+ * A valid format does not guarantee a bridge will accept the address.
+ */
+declare function validateAddress(address: string, blockchain: Chain): boolean;
+//#endregion
+export { validateAddress };

package/dist/src/lib/validateAddress.js

@@ -0,0 +1,270 @@
+import { Chains } from "./caip2.js";
+import { utils } from "lampamazaza-internal-utils";
+import { isAddress } from "viem";
+import { sha256 } from "@noble/hashes/sha2";
+import { base58, bech32, bech32m, hex } from "@scure/base";
+import { PublicKey } from "@solana/web3.js";
+import { isValidClassicAddress, isValidXAddress } from "ripple-address-codec";
+
+//#region src/lib/validateAddress.ts
+/**
+* Validates that an address matches the expected format for a given blockchain.
+*
+* Note: This validates address FORMAT only. Specific bridges may have
+* additional requirements (e.g., supported address types, memo requirements).
+* A valid format does not guarantee a bridge will accept the address.
+*/
+function validateAddress(address, blockchain) {
+	switch (blockchain) {
+		case Chains.Near: return utils.validateNearAddress(address);
+		case Chains.Bitcoin: return validateBtcAddress(address);
+		case Chains.BitcoinCash: return validateBchAddress(address);
+		case Chains.Solana: return validateSolAddress(address);
+		case Chains.Dogecoin: return validateDogeAddress(address);
+		case Chains.Litecoin: return validateLitecoinAddress(address);
+		case Chains.XRPL: return validateXrpAddress(address);
+		case Chains.Zcash: return validateZcashAddress(address);
+		case Chains.Tron: return validateTronAddress(address);
+		case Chains.TON: return validateTonAddress(address);
+		case Chains.Sui: return validateSuiAddress(address);
+		case Chains.Stellar: return validateStellarAddress(address);
+		case Chains.Aptos: return validateAptosAddress(address);
+		case Chains.Cardano: return validateCardanoAddress(address);
+		case Chains.Starknet: return validateStarknetAddress(address);
+		case Chains.Ethereum:
+		case Chains.Optimism:
+		case Chains.BNB:
+		case Chains.Gnosis:
+		case Chains.Polygon:
+		case Chains.Monad:
+		case Chains.LayerX:
+		case Chains.Adi:
+		case Chains.Base:
+		case Chains.Arbitrum:
+		case Chains.Avalanche:
+		case Chains.Berachain:
+		case Chains.Plasma:
+		case Chains.Scroll: return validateEthAddress(address);
+		default: return false;
+	}
+}
+function validateEthAddress(address) {
+	return isAddress(address, { strict: true });
+}
+function validateBtcAddress(address) {
+	return /^1[1-9A-HJ-NP-Za-km-z]{25,34}$/.test(address) || /^3[1-9A-HJ-NP-Za-km-z]{25,34}$/.test(address) || /^bc1[02-9ac-hj-np-z]{11,87}$/.test(address) || /^bc1p[02-9ac-hj-np-z]{42,87}$/.test(address);
+}
+/**
+* Validates Bitcoin Cash addresses
+* Supports:
+* - Legacy addresses (1... for P2PKH, 3... for P2SH) - shared with Bitcoin
+* - CashAddr format (bitcoincash:q... or q... for P2PKH, bitcoincash:p... or p... for P2SH)
+*
+* CashAddr checksum implementation based on:
+* @see https://github.com/ealmansi/cashaddrjs (MIT License)
+* @see https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md
+*/
+function validateBchAddress(address) {
+	if (/^1[1-9A-HJ-NP-Za-km-z]{25,34}$/.test(address) || /^3[1-9A-HJ-NP-Za-km-z]{25,34}$/.test(address)) return true;
+	return validateBchCashAddr(address);
+}
+/**
+* Validates Bitcoin Cash CashAddr format
+* CashAddr uses a modified Bech32 encoding with polymod checksum
+*/
+function validateBchCashAddr(address) {
+	let normalized = address.toLowerCase();
+	if (!normalized.includes(":")) normalized = `bitcoincash:${normalized}`;
+	if (!normalized.startsWith("bitcoincash:")) return false;
+	const payload = normalized.slice(12);
+	if (!payload.startsWith("q") && !payload.startsWith("p")) return false;
+	const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+	for (const char of payload) if (!CHARSET.includes(char)) return false;
+	if (payload.length !== 42 && payload.length !== 61) return false;
+	return verifyBchChecksum(normalized);
+}
+function verifyBchChecksum(address) {
+	const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+	const colonIndex = address.indexOf(":");
+	const prefix = address.slice(0, colonIndex);
+	const payload = address.slice(colonIndex + 1);
+	const prefixData = [];
+	for (const char of prefix) prefixData.push(char.charCodeAt(0) & 31);
+	prefixData.push(0);
+	const payloadData = [];
+	for (const char of payload) {
+		const idx = CHARSET.indexOf(char);
+		if (idx === -1) return false;
+		payloadData.push(idx);
+	}
+	const values = [...prefixData, ...payloadData];
+	let c = 1n;
+	for (const d of values) {
+		const c0 = c >> 35n;
+		c = (c & 34359738367n) << 5n ^ BigInt(d);
+		if (c0 & 1n) c ^= 656907472481n;
+		if (c0 & 2n) c ^= 522768456162n;
+		if (c0 & 4n) c ^= 1044723512260n;
+		if (c0 & 8n) c ^= 748107326120n;
+		if (c0 & 16n) c ^= 130178868336n;
+	}
+	return (c ^ 1n) === 0n;
+}
+function validateSolAddress(address) {
+	try {
+		return PublicKey.isOnCurve(address);
+	} catch {
+		return false;
+	}
+}
+function validateDogeAddress(address) {
+	return /^[DA][1-9A-HJ-NP-Za-km-z]{25,33}$/.test(address);
+}
+function validateXrpAddress(address) {
+	return isValidClassicAddress(address) || isValidXAddress(address);
+}
+/**
+* Validates Zcash addresses
+* Supports:
+* - Transparent addresses (t1, t3)
+* - TEX addresses (tex1)
+*/
+function validateZcashAddress(address) {
+	if (address.startsWith("t1") || address.startsWith("t3")) return /^t[13][a-km-zA-HJ-NP-Z1-9]{33}$/.test(address);
+	const expectedHrp = "tex";
+	if (address.startsWith(`${expectedHrp}1`)) try {
+		const decoded = bech32m.decodeToBytes(address);
+		if (decoded.prefix !== expectedHrp) return false;
+		return decoded.bytes.length === 20;
+	} catch {
+		return false;
+	}
+	const uaHrp = "u";
+	if (address.startsWith(`${uaHrp}1`)) try {
+		return bech32m.decodeToBytes(address).prefix === uaHrp;
+	} catch {
+		return false;
+	}
+	return false;
+}
+/**
+* Validates Tron addresses
+* Supports:
+* - hex addresses
+* - base58 addresses
+* https://developers.tron.network/docs/account
+*/
+function validateTronAddress(address) {
+	return validateTronBase58Address(address) || validateTronHexAddress(address);
+}
+function validateTronBase58Address(address) {
+	try {
+		const decoded = base58.decode(address);
+		if (decoded.length !== 25) return false;
+		const data = decoded.slice(0, 21);
+		const checksum = decoded.slice(21);
+		const expectedChecksum = sha256(sha256(data)).slice(0, 4);
+		for (let i = 0; i < 4; i++) if (checksum[i] !== expectedChecksum[i]) return false;
+		return data[0] === 65;
+	} catch {
+		return false;
+	}
+}
+function validateTronHexAddress(address) {
+	try {
+		const decoded = hex.decode(address);
+		return decoded.length === 21 && decoded[0] === 65;
+	} catch {
+		return false;
+	}
+}
+function validateTonAddress(address) {
+	return /^[EU]Q[0-9A-Za-z_-]{46}$/.test(address);
+}
+function validateSuiAddress(address) {
+	return /^(?:0x)?[a-fA-F0-9]{64}$/.test(address);
+}
+function validateStellarAddress(address) {
+	return /^G[A-Z0-9]{55}$/.test(address);
+}
+function validateAptosAddress(address) {
+	return /^0x[a-fA-F0-9]{64}$/.test(address);
+}
+/**
+* Validates Cardano mainnet addresses (Base + Enterprise)
+* Returns true if valid, false if invalid
+*/
+function validateCardanoAddress(address) {
+	try {
+		const { prefix, words } = bech32.decode(address, 120);
+		if (prefix !== "addr") return false;
+		const addrType = bech32.fromWords(words)[0] >> 4;
+		return addrType >= 0 && addrType <= 7;
+	} catch {
+		return false;
+	}
+}
+/**
+* Validates Starknet addresses
+* Starknet addresses are felt252 (252-bit field elements) represented as
+* hex strings with 0x prefix (up to 64 hex characters)
+*/
+function validateStarknetAddress(address) {
+	return /^0x[a-fA-F0-9]{1,64}$/.test(address);
+}
+function validateLitecoinAddress(address) {
+	const first = address[0];
+	if (first === "L") return validateLitecoinBase58Address(address, 48);
+	if (first === "M") return validateLitecoinBase58Address(address, 50);
+	if (first === "3") return validateLitecoinBase58Address(address, 5);
+	if (!address.toLowerCase().startsWith("ltc1")) return false;
+	return validateLitecoinBech32Address(address);
+}
+function validateLitecoinBase58Address(address, expectedVersion) {
+	let decoded;
+	try {
+		decoded = base58.decode(address);
+	} catch {
+		return false;
+	}
+	if (decoded.length !== 25) return false;
+	if (decoded[0] !== expectedVersion) return false;
+	const payload = decoded.subarray(0, 21);
+	const checksum = decoded.subarray(21, 25);
+	const expectedChecksum = sha256(sha256(payload)).subarray(0, 4);
+	for (let i = 0; i < 4; i++) if (checksum[i] !== expectedChecksum[i]) return false;
+	return true;
+}
+function validateLitecoinBech32Address(address) {
+	let decoded;
+	let isBech32m = false;
+	try {
+		decoded = bech32.decode(address);
+	} catch {
+		try {
+			decoded = bech32m.decode(address);
+			isBech32m = true;
+		} catch {
+			return false;
+		}
+	}
+	if (decoded.prefix.toLowerCase() !== "ltc") return false;
+	const { words } = decoded;
+	if (!words || words.length < 1) return false;
+	const version = words[0];
+	if (version == null || version < 0 || version > 16) return false;
+	const progLen = bech32.fromWords(words.slice(1)).length;
+	if (progLen < 2 || progLen > 40) return false;
+	if (version === 0) {
+		if (isBech32m) return false;
+		return progLen === 20 || progLen === 32;
+	}
+	if (version === 1) {
+		if (!isBech32m) return false;
+		return progLen === 32;
+	}
+	return false;
+}
+
+//#endregion
+export { validateAddress };