@proton/wrap-constants 0.2.193 → 0.3.1

package/dist/index.cjs

@@ -0,0 +1,2718 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+let zod = require("zod");
+zod = __toESM(zod, 1);
+let lodash_clonedeep = require("lodash.clonedeep");
+lodash_clonedeep = __toESM(lodash_clonedeep, 1);
+let bignumber_js = require("bignumber.js");
+bignumber_js = __toESM(bignumber_js, 1);
+let _scure_base = require("@scure/base");
+let _noble_hashes_sha2 = require("@noble/hashes/sha2");
+let _noble_hashes_sha3 = require("@noble/hashes/sha3");
+// src/coins.ts
+let Chains = /* @__PURE__ */ function(Chains) {
+	Chains["BitcoinMainnet"] = "Bitcoin";
+	Chains["BitcoinTestnet"] = "Bitcoin (Testnet)";
+	Chains["EthereumMainnet"] = "Ethereum";
+	Chains["EthereumSepolia"] = "Ethereum (Sepolia)";
+	Chains["LitecoinMainnet"] = "Litecoin";
+	Chains["LitecoinTestnet"] = "Litecoin (Testnet)";
+	Chains["BitcoinCashMainnet"] = "Bitcoin Cash";
+	Chains["BitcoinCashTestnet"] = "Bitcoin Cash (Testnet)";
+	Chains["StellarMainnet"] = "Stellar";
+	Chains["StellarTestnet"] = "Stellar (Testnet)";
+	Chains["ProtonMainnet"] = "Proton";
+	Chains["ProtonTestnet"] = "Proton (Testnet)";
+	Chains["PolkadotMainnet"] = "Polkadot";
+	Chains["BinanceBEP2"] = "Binance (BEP2)";
+	Chains["BinanceBEP20"] = "Binance (BEP20)";
+	Chains["EosMainnet"] = "EOS";
+	Chains["EosTestnet"] = "EOS (Jungle Testnet)";
+	Chains["HederaMainnet"] = "Hedera (Mainnet)";
+	Chains["HederaTestnet"] = "Hedera (Testnet)";
+	Chains["DogeMainnet"] = "Dogecoin";
+	Chains["CardanoMainnet"] = "Cardano";
+	Chains["AvalancheXChain"] = "Avalanche X-Chain";
+	Chains["AvalancheCChain"] = "Avalanche C-Chain";
+	Chains["PolygonMainnet"] = "Polygon";
+	Chains["TerraMainnet"] = "Terra";
+	Chains["RippleMainnet"] = "Ripple";
+	Chains["SolanaMainnet"] = "Solana";
+	Chains["XDCMainnet"] = "XDC Network";
+	Chains["MetalXTestnet"] = "Metal X-Chain (Testnet)";
+	Chains["MetalCTestnet"] = "Metal C-Chain (Testnet)";
+	Chains["MetalCMainnet"] = "Metal C-Chain";
+	Chains["MetalL2Mainnet"] = "Metal L2";
+	Chains["MetalL2Testnet"] = "Metal L2 (Testnet)";
+	return Chains;
+}({});
+let Networks = /* @__PURE__ */ function(Networks) {
+	Networks["Mainnet"] = "mainnet";
+	Networks["Testnet"] = "testnet";
+	Networks["ERC20"] = "erc20";
+	Networks["BEP20"] = "bep20";
+	Networks["XLM"] = "xlm";
+	Networks["AVM"] = "avm";
+	Networks["EVM"] = "evm";
+	Networks["METALL2"] = "metall2";
+	Networks["Sepolia"] = "sepolia";
+	return Networks;
+}({});
+const similarChains = {
+	["Ethereum"]: ["Binance (BEP20)"],
+	["Binance (BEP20)"]: ["Ethereum"]
+};
+let Providers = /* @__PURE__ */ function(Providers) {
+	Providers["FIREBLOCKS"] = "fireblocks";
+	Providers["METAL"] = "metal";
+	Providers["METALL2"] = "metall2";
+	return Providers;
+}({});
+const explorerLinkByChain = {
+	["Bitcoin"]: (txid) => `https://blockchain.com/btc/tx/${txid}`,
+	["Bitcoin (Testnet)"]: (txid) => `https://blockstream.info/testnet/tx/${txid}`,
+	["Ethereum"]: (txid) => `https://etherscan.io/tx/${txid}`,
+	["Ethereum (Sepolia)"]: (txid) => `https://sepolia.etherscan.io/tx/${txid}`,
+	["Litecoin"]: (txid) => `https://blockchair.com/litecoin/transaction/${txid}`,
+	["Litecoin (Testnet)"]: (txid) => `https://blockexplorer.one/litecoin/testnet/blockHash/${txid}`,
+	["Bitcoin Cash"]: (txid) => `https://blockchair.com/bitcoin-cash/transaction/${txid}`,
+	["Bitcoin Cash (Testnet)"]: (txid) => `https://blockexplorer.one/bitcoin-cash/testnet/blockHash/${txid}`,
+	["Stellar"]: (txid) => `https://blockchair.com/stellar/transaction/${txid}`,
+	["Stellar (Testnet)"]: (txid) => `https://testnet.steexp.com/tx/${txid}`,
+	["Proton"]: (txid, traces) => `https://explorer.xprnetwork.org/transaction/${txid}${traces ? "?tab=traces" : ""}`,
+	["Proton (Testnet)"]: (txid, traces) => `https://testnet.explorer.xprnetwork.org/transaction/${txid}${traces ? "?tab=traces" : ""}`,
+	["Polkadot"]: (txid) => `https://polkadot.subscan.io/extrinsic/${txid}`,
+	["Binance (BEP2)"]: (txid) => `https://binance.mintscan.io/txs/${txid}`,
+	["Binance (BEP20)"]: (txid) => `https://bscscan.com/tx/${txid}`,
+	["EOS"]: (txid) => `https://bloks.io/transaction/${txid}`,
+	["EOS (Jungle Testnet)"]: (txid) => `https://jungle.bloks.io/transaction/${txid}`,
+	["Hedera (Mainnet)"]: (txid) => `https://app.dragonglass.me/transactions/${txid}`,
+	["Hedera (Testnet)"]: (txid) => `https://testnet.dragonglass.me/transactions/${txid}`,
+	["Dogecoin"]: (txid) => `https://blockchair.com/dogecoin/transaction/${txid}`,
+	["Cardano"]: (txid) => `https://explorer.cardano.org/en/transaction?id=${txid}`,
+	["Avalanche X-Chain"]: (txid) => `https://avascan.info/blockchain/x/tx/${txid}`,
+	["Avalanche C-Chain"]: (txid) => `https://snowtrace.io/tx/${txid}`,
+	["Polygon"]: (txid) => `https://polygonscan.com/tx/${txid}`,
+	["Terra"]: (txid) => `https://terra.stake.id/?#/tx/${txid}`,
+	["Ripple"]: (txid) => `https://xrpscan.com/tx/${txid}`,
+	["Solana"]: (txid) => `https://explorer.solana.com/tx/${txid}`,
+	["Metal X-Chain (Testnet)"]: (txid) => `https://metalscan.io/tx/${txid}`,
+	["Metal C-Chain (Testnet)"]: (txid) => `https://tahoe.metaltrace.io/tx/${txid}`,
+	["Metal C-Chain"]: (txid) => `https://metalscan.io/tx/${txid}`,
+	["XDC Network"]: (txid) => `https://xdc.blocksscan.io/txs/${txid}`,
+	["Metal L2 (Testnet)"]: (txid) => `https://testnet.explorer.metall2.com/tx/${txid}`,
+	["Metal L2"]: (txid) => `https://explorer.metall2.com/tx/${txid}`
+};
+const protonExplorerTxUrl = (chain, txId, traces) => chain === "proton" ? explorerLinkByChain["Proton"](txId, traces) : explorerLinkByChain["Proton (Testnet)"](txId, traces);
+const initializeCoins = (protonChain) => {
+	const IS_MAINNET = protonChain === "proton";
+	const IS_TESTNET = protonChain === "proton-test";
+	const coins = [
+		{
+			allowSwap: true,
+			allowBridge: IS_MAINNET,
+			allowLend: true,
+			allowBorrow: true,
+			name: "XPR Network",
+			coin: "XPR",
+			xtokenSymbol: "XPR",
+			xtokenPrecision: 4,
+			xtokenContract: "eosio.token",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "XPR-ERC20",
+				symbol: "XPR",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 4,
+				contract: "0xD7EFB00D12C2C13131FD319336FDF952525DA2AF",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}, {
+				wallet: "XPR-BEP20",
+				symbol: "XPR",
+				chain: "Binance (BEP20)",
+				network: "bep20",
+				precision: 4,
+				contract: "0x5DE3939B2F811A61D830E6F52D13B066881412AB",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/XPR.png",
+			coingeckoId: "proton",
+			unifiedCryptoassetId: "5350"
+		},
+		{
+			allowSwap: true,
+			allowBridge: true,
+			allowLend: true,
+			allowBorrow: true,
+			name: "USD Coin",
+			coin: "USDC",
+			xtokenSymbol: "XUSDC",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "USDC",
+				symbol: "USDC",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 6,
+				contract: "0xA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}, {
+				wallet: "USDC-XLM",
+				symbol: "USDC",
+				chain: "Stellar",
+				network: "xlm",
+				precision: 7,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: true
+			}] : [], ...IS_TESTNET ? [{
+				wallet: "USDC",
+				symbol: "USDC",
+				chain: "Ethereum (Sepolia)",
+				network: "sepolia",
+				precision: 6,
+				contract: "0xA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}, {
+				wallet: "USDC-XLM",
+				symbol: "USDC",
+				chain: "Stellar (Testnet)",
+				network: "xlm",
+				precision: 7,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: true
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/usdc.png",
+			coingeckoId: "usd-coin",
+			unifiedCryptoassetId: "3408"
+		},
+		{
+			allowSwap: true,
+			allowBridge: true,
+			allowLend: true,
+			allowBorrow: true,
+			name: "Metal DAO",
+			coin: "MTL",
+			xtokenSymbol: "XMT",
+			xtokenPrecision: 8,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "MTL-METALL2",
+				symbol: "MTL",
+				chain: "Metal L2",
+				network: "metall2",
+				precision: 8,
+				contract: "0xBCFc435d8F276585f6431Fc1b9EE9A850B5C00A9",
+				provider: "metall2",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/mtl.png",
+			coingeckoId: "metal",
+			unifiedCryptoassetId: "1788"
+		},
+		{
+			allowSwap: true,
+			allowBridge: true,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Metal Blockchain",
+			coin: "METAL",
+			xtokenSymbol: "METAL",
+			xtokenPrecision: 8,
+			xtokenContract: "xtokens",
+			wallets: [...IS_TESTNET ? [{
+				wallet: "METAL",
+				symbol: "METAL",
+				chain: "Metal C-Chain (Testnet)",
+				network: "evm",
+				precision: 18,
+				contract: "",
+				provider: "metal",
+				hasWithdrawMemo: false
+			}] : [], ...IS_MAINNET ? [{
+				wallet: "METAL",
+				symbol: "METAL",
+				chain: "Metal C-Chain",
+				network: "evm",
+				precision: 18,
+				contract: "",
+				provider: "metal",
+				hasWithdrawMemo: false
+			}, {
+				wallet: "METAL-ERC20",
+				symbol: "METAL",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 18,
+				contract: "",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/metal.png",
+			coingeckoId: "metal-blockchain",
+			unifiedCryptoassetId: "21769"
+		},
+		{
+			allowSwap: true,
+			allowBridge: true,
+			allowLend: true,
+			allowBorrow: true,
+			name: "Bitcoin",
+			coin: "BTC",
+			xtokenSymbol: "XBTC",
+			xtokenPrecision: 8,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "BTC",
+				symbol: "BTC",
+				chain: "Bitcoin",
+				network: "mainnet",
+				precision: 8,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : [], ...IS_TESTNET ? [{
+				wallet: "BTC",
+				symbol: "BTC",
+				chain: "Bitcoin (Testnet)",
+				network: "testnet",
+				precision: 8,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/btc.png",
+			coingeckoId: "bitcoin",
+			unifiedCryptoassetId: "1"
+		},
+		{
+			allowSwap: true,
+			allowBridge: true,
+			allowLend: true,
+			allowBorrow: true,
+			name: "Ethereum",
+			coin: "ETH",
+			xtokenSymbol: "XETH",
+			xtokenPrecision: 8,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "ETH",
+				symbol: "ETH",
+				chain: "Ethereum",
+				network: "mainnet",
+				precision: 18,
+				contract: "0x0000000000000000000000000000000000000000",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : [], ...IS_TESTNET ? [{
+				wallet: "ETH",
+				symbol: "ETH",
+				chain: "Ethereum (Sepolia)",
+				network: "sepolia",
+				precision: 18,
+				contract: "0x0000000000000000000000000000000000000000",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/eth.png",
+			coingeckoId: "ethereum",
+			unifiedCryptoassetId: "1027"
+		},
+		{
+			allowSwap: true,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "LOAN Protocol",
+			coin: "LOAN",
+			xtokenSymbol: "LOAN",
+			xtokenPrecision: 4,
+			xtokenContract: "loan.token",
+			wallets: [],
+			image: "https://app.metalx.com/img/tokens/loan.png",
+			coingeckoId: "proton-loan",
+			unifiedCryptoassetId: "22071"
+		},
+		{
+			allowSwap: true,
+			allowBridge: true,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Tether",
+			coin: "USDT",
+			xtokenSymbol: "XUSDT",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "USDT",
+				symbol: "USDT",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 6,
+				contract: "0xDAC17F958D2EE523A2206206994597C13D831EC7",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : [{
+				wallet: "USDT",
+				symbol: "USDT",
+				chain: "Ethereum (Sepolia)",
+				network: "sepolia",
+				precision: 6,
+				contract: "0xDAC17F958D2EE523A2206206994597C13D831EC7",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}]],
+			image: "https://app.metalx.com/img/tokens/usdt.png",
+			coingeckoId: "tether",
+			unifiedCryptoassetId: "825"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "TrueUSD",
+			coin: "TUSD",
+			xtokenSymbol: "XTUSD",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [] : []],
+			image: "https://app.metalx.com/img/tokens/tusd.png",
+			coingeckoId: "true-usd",
+			unifiedCryptoassetId: "2563"
+		},
+		{
+			allowSwap: false,
+			allowBridge: IS_MAINNET,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Euro Coin",
+			coin: "EUROC",
+			xtokenSymbol: "XEUROC",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "EUROC-ERC20",
+				symbol: "EUROC",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 6,
+				contract: "0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://assets.coingecko.com/coins/images/26045/small/euro-coin.png?1655394420",
+			coingeckoId: "euro-coin",
+			unifiedCryptoassetId: "20641"
+		},
+		{
+			allowSwap: false,
+			allowBridge: IS_MAINNET,
+			allowLend: false,
+			allowBorrow: false,
+			name: "XDC Network",
+			coin: "XDC",
+			xtokenSymbol: "XDC",
+			xtokenPrecision: 4,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "XDC",
+				symbol: "XDC",
+				chain: "XDC Network",
+				network: "mainnet",
+				precision: 18,
+				contract: "",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/xdc.png",
+			coingeckoId: "xdce-crowd-sale",
+			unifiedCryptoassetId: "2634"
+		},
+		{
+			allowSwap: false,
+			allowBridge: IS_MAINNET,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Paxos Dollar",
+			coin: "PAX",
+			xtokenSymbol: "XPAX",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "PAX",
+				symbol: "PAX",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 18,
+				contract: "0x8E870D67F660D95D5BE530380D0EC0BD388289E1",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/pax.png",
+			coingeckoId: "paxos-standard",
+			unifiedCryptoassetId: "3330"
+		},
+		{
+			allowSwap: false,
+			allowBridge: true,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Paxos Gold",
+			coin: "PAXG",
+			xtokenSymbol: "XPAXG",
+			xtokenPrecision: 8,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "PAXG",
+				symbol: "PAXG",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 18,
+				contract: "0x45804880DE22913DAFE09F4980848ECE6ECBAF78",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : [], ...IS_TESTNET ? [{
+				wallet: "PAXG",
+				symbol: "PAXG",
+				chain: "Ethereum (Sepolia)",
+				network: "sepolia",
+				precision: 18,
+				contract: "0x45804880DE22913DAFE09F4980848ECE6ECBAF78",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/paxg.png",
+			coingeckoId: "pax-gold",
+			unifiedCryptoassetId: "4705"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Storex",
+			coin: "STRX",
+			xtokenSymbol: "STRX",
+			xtokenPrecision: 4,
+			xtokenContract: "storex",
+			wallets: [],
+			image: "https://app.metalx.com/img/tokens/strx.png",
+			coingeckoId: "storex",
+			unifiedCryptoassetId: ""
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Mint",
+			coin: "MINT",
+			xtokenSymbol: "MINT",
+			xtokenPrecision: 4,
+			xtokenContract: "protonmint",
+			wallets: [],
+			image: "https://app.metalx.com/img/tokens/mint.png",
+			coingeckoId: "",
+			unifiedCryptoassetId: ""
+		},
+		{
+			allowSwap: IS_MAINNET,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Snipcoins",
+			coin: "SNIPS",
+			xtokenSymbol: "SNIPS",
+			xtokenPrecision: 4,
+			xtokenContract: "snipcoins",
+			wallets: [],
+			image: "https://app.metalx.com/img/tokens/snips.png",
+			coingeckoId: "",
+			unifiedCryptoassetId: ""
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Uniswap",
+			coin: "UNI",
+			xtokenSymbol: "XUNI",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [] : [], ...IS_TESTNET ? [] : []],
+			image: "https://app.metalx.com/img/tokens/uni.png",
+			coingeckoId: "uniswap",
+			unifiedCryptoassetId: "7083"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "1INCH",
+			coin: "1INCH",
+			xtokenSymbol: "XINCH",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "1INCH",
+				symbol: "1INCH",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 18,
+				contract: "0x111111111117DC0AA78B770FA6A738034120C302",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://www.proton.org/images/tokens/xtokensXINCH.png",
+			coingeckoId: "1inch",
+			unifiedCryptoassetId: "8104"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Chainlink",
+			coin: "LINK",
+			xtokenSymbol: "XLINK",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "LINK",
+				symbol: "LINK",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 18,
+				contract: "0x514910771AF9CA656AF840DFF83E8264ECF986CA",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/link.png",
+			coingeckoId: "chainlink",
+			unifiedCryptoassetId: "1975"
+		},
+		{
+			allowSwap: IS_MAINNET,
+			allowBridge: true,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Litecoin",
+			coin: "LTC",
+			xtokenSymbol: "XLTC",
+			xtokenPrecision: 8,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "LTC",
+				symbol: "LTC",
+				chain: "Litecoin",
+				network: "mainnet",
+				precision: 8,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : [], ...IS_TESTNET ? [{
+				wallet: "LTC",
+				symbol: "LTC",
+				chain: "Litecoin (Testnet)",
+				network: "testnet",
+				precision: 8,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/ltc.png",
+			coingeckoId: "litecoin",
+			unifiedCryptoassetId: "2"
+		},
+		{
+			allowSwap: false,
+			allowBridge: IS_MAINNET,
+			allowLend: false,
+			allowBorrow: false,
+			name: "PayPal USD",
+			coin: "PYUSD",
+			xtokenSymbol: "XPYUSD",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "PYUSD",
+				symbol: "PYUSD",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 6,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/pyusd.png",
+			coingeckoId: "paypal-usd",
+			unifiedCryptoassetId: "27772"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Bitcoin Cash",
+			coin: "BCH",
+			xtokenSymbol: "XBCH",
+			xtokenPrecision: 8,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [] : [], ...IS_TESTNET ? [] : []],
+			image: "https://app.metalx.com/img/tokens/bch.png",
+			coingeckoId: "bitcoin-cash",
+			unifiedCryptoassetId: "1831"
+		},
+		{
+			allowSwap: true,
+			allowBridge: true,
+			allowLend: false,
+			allowBorrow: false,
+			name: "LunarCrush",
+			coin: "LUNR",
+			xtokenSymbol: "XLUNR",
+			xtokenPrecision: 4,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "LUNR",
+				symbol: "LUNR",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 4,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/lunr.png",
+			coingeckoId: "lunr-token",
+			unifiedCryptoassetId: "12971"
+		},
+		{
+			allowSwap: false,
+			allowBridge: true,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Stellar",
+			coin: "XLM",
+			xtokenSymbol: "XXLM",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "XLM",
+				symbol: "XLM",
+				chain: "Stellar",
+				network: "mainnet",
+				precision: 7,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: true
+			}] : [], ...IS_TESTNET ? [{
+				wallet: "XLM",
+				symbol: "XLM",
+				chain: "Stellar (Testnet)",
+				network: "testnet",
+				precision: 7,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: true
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/xlm.png",
+			coingeckoId: "stellar",
+			unifiedCryptoassetId: "512"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Sense",
+			coin: "SENSE",
+			xtokenSymbol: "XSENSE",
+			xtokenPrecision: 4,
+			xtokenContract: "sense",
+			wallets: [],
+			image: "https://app.metalx.com/img/tokens/sense.png",
+			coingeckoId: "sense",
+			unifiedCryptoassetId: ""
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Polkadot",
+			coin: "DOT",
+			xtokenSymbol: "XDOT",
+			xtokenPrecision: 8,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "DOT",
+				symbol: "DOT",
+				chain: "Polkadot",
+				network: "mainnet",
+				precision: 10,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/dot.png",
+			coingeckoId: "polkadot",
+			unifiedCryptoassetId: "6636"
+		},
+		{
+			allowSwap: true,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Binance Coin",
+			coin: "BNB",
+			xtokenSymbol: "XBNB",
+			xtokenPrecision: 8,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [] : []],
+			image: "https://app.metalx.com/img/tokens/bnb.png",
+			coingeckoId: "binancecoin",
+			unifiedCryptoassetId: "1839"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Binance USD",
+			coin: "BUSD",
+			xtokenSymbol: "XBUSD",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [],
+			image: "https://app.metalx.com/img/tokens/busd.png",
+			coingeckoId: "binance-usd",
+			unifiedCryptoassetId: "4687"
+		},
+		{
+			allowSwap: true,
+			allowBridge: true,
+			allowLend: false,
+			allowBorrow: false,
+			name: "EOS",
+			coin: "EOS",
+			xtokenSymbol: "XEOS",
+			xtokenPrecision: 4,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "EOS",
+				symbol: "EOS",
+				chain: "EOS",
+				network: "mainnet",
+				precision: 4,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: true
+			}] : [], ...IS_TESTNET ? [{
+				wallet: "EOS",
+				symbol: "EOS",
+				chain: "EOS (Jungle Testnet)",
+				network: "testnet",
+				precision: 4,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: true
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/eos.png",
+			coingeckoId: "eos",
+			unifiedCryptoassetId: "1765"
+		},
+		{
+			allowSwap: IS_MAINNET,
+			allowBridge: IS_MAINNET,
+			allowLend: true,
+			allowBorrow: true,
+			name: "Dogecoin",
+			coin: "DOGE",
+			xtokenSymbol: "XDOGE",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "DOGE",
+				symbol: "DOGE",
+				chain: "Dogecoin",
+				network: "mainnet",
+				precision: 8,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/doge.png",
+			coingeckoId: "dogecoin",
+			unifiedCryptoassetId: "74"
+		},
+		{
+			allowSwap: IS_MAINNET,
+			allowBridge: IS_MAINNET,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Cardano",
+			coin: "ADA",
+			xtokenSymbol: "XADA",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "ADA",
+				symbol: "ADA",
+				chain: "Cardano",
+				network: "mainnet",
+				precision: 6,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/ada.png",
+			coingeckoId: "cardano",
+			unifiedCryptoassetId: "2010"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Terra",
+			coin: "LUNA",
+			xtokenSymbol: "XLUNA",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [],
+			image: "https://app.metalx.com/img/tokens/luna.png",
+			coingeckoId: "terra-luna",
+			unifiedCryptoassetId: "4172"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "TerraUSD",
+			coin: "UST",
+			xtokenSymbol: "XUST",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "UST",
+				symbol: "UST",
+				chain: "Terra",
+				network: "mainnet",
+				precision: 6,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: true
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/ust.png",
+			coingeckoId: "terrausd",
+			unifiedCryptoassetId: "7129"
+		},
+		{
+			allowSwap: false,
+			allowBridge: IS_MAINNET,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Solana",
+			coin: "SOL",
+			xtokenSymbol: "XSOL",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "SOL",
+				symbol: "SOL",
+				chain: "Solana",
+				network: "mainnet",
+				precision: 9,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/sol.png",
+			coingeckoId: "solana",
+			unifiedCryptoassetId: "5426"
+		},
+		{
+			allowSwap: false,
+			allowBridge: IS_MAINNET,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Ripple",
+			coin: "XRP",
+			xtokenSymbol: "XXRP",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "XRP",
+				symbol: "XRP",
+				chain: "Ripple",
+				network: "mainnet",
+				precision: 6,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: true
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/xrp.png",
+			coingeckoId: "ripple",
+			unifiedCryptoassetId: "52"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Avalanche",
+			coin: "AVAX",
+			xtokenSymbol: "XAVAX",
+			xtokenPrecision: 9,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "AVAX",
+				symbol: "AVAX",
+				chain: "Avalanche C-Chain",
+				network: "mainnet",
+				precision: 9,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/avax.png",
+			coingeckoId: "avalanche-2",
+			unifiedCryptoassetId: "5805"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Polygon",
+			coin: "MATIC",
+			xtokenSymbol: "XMATIC",
+			xtokenPrecision: 8,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "MATIC",
+				symbol: "MATIC",
+				chain: "Polygon",
+				network: "mainnet",
+				precision: 18,
+				contract: "0x0000000000000000000000000000000000000000",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/matic.png",
+			coingeckoId: "matic-network",
+			unifiedCryptoassetId: "3890"
+		},
+		{
+			allowSwap: true,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Metal Dollar",
+			coin: "XMD",
+			xtokenSymbol: "XMD",
+			xtokenPrecision: 6,
+			xtokenContract: "xmd.token",
+			wallets: [],
+			image: "https://app.metalx.com/img/tokens/xmd.png",
+			coingeckoId: "",
+			unifiedCryptoassetId: ""
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Metal Dollar",
+			coin: "MPD",
+			xtokenSymbol: "MPD",
+			xtokenPrecision: 6,
+			xtokenContract: "mpd.token",
+			wallets: [],
+			image: "https://app.metalx.com/img/tokens/mpd.png",
+			coingeckoId: "",
+			unifiedCryptoassetId: ""
+		},
+		{
+			allowSwap: false,
+			allowBridge: true,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Hedera",
+			coin: "HBAR",
+			xtokenSymbol: "XHBAR",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_TESTNET ? [{
+				wallet: "HBAR",
+				symbol: "HBAR",
+				chain: "Hedera (Testnet)",
+				network: "testnet",
+				precision: 8,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: true
+			}] : [{
+				wallet: "HBAR",
+				symbol: "HBAR",
+				chain: "Hedera (Mainnet)",
+				network: "mainnet",
+				precision: 8,
+				contract: void 0,
+				provider: "fireblocks",
+				hasWithdrawMemo: true
+			}]],
+			image: "https://app.metalx.com/img/tokens/hbar.png",
+			coingeckoId: "hedera-hashgraph",
+			unifiedCryptoassetId: "4642"
+		},
+		{
+			allowSwap: false,
+			allowBridge: IS_TESTNET,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Ripple USD",
+			coin: "RLUSD",
+			xtokenSymbol: "XRLUSD",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "RLUSD",
+				symbol: "RLUSD",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 18,
+				contract: "0x8292bb45bf1ee4d140127049757c2e0ff06317ed",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : [{
+				wallet: "RLUSD",
+				symbol: "RLUSD",
+				chain: "Ethereum (Sepolia)",
+				network: "erc20",
+				precision: 18,
+				contract: "0xe101FB315a64cDa9944E570a7bFfaFE60b994b1D",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}]],
+			image: "https://app.metalx.com/img/tokens/rlusd.png",
+			coingeckoId: "ripple-usd",
+			unifiedCryptoassetId: "34387"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Fidelity Digital Dollar",
+			coin: "FIDD",
+			xtokenSymbol: "XFIDD",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [...IS_MAINNET ? [{
+				wallet: "FIDD",
+				symbol: "FIDD",
+				chain: "Ethereum",
+				network: "erc20",
+				precision: 18,
+				contract: "0x7C135549504245B5EAE64FC0E99FA5EBABB8E35D",
+				provider: "fireblocks",
+				hasWithdrawMemo: false
+			}] : []],
+			image: "https://app.metalx.com/img/tokens/fidd.png",
+			coingeckoId: "fidelity-digital-dollar",
+			unifiedCryptoassetId: "39549"
+		},
+		{
+			allowSwap: false,
+			allowBridge: false,
+			allowLend: false,
+			allowBorrow: false,
+			name: "Pax Dollar",
+			coin: "USDP",
+			xtokenSymbol: "XUSDP",
+			xtokenPrecision: 6,
+			xtokenContract: "xtokens",
+			wallets: [],
+			image: "https://app.metalx.com/img/tokens/usdp.png",
+			coingeckoId: "pax-dollar",
+			unifiedCryptoassetId: "3330"
+		}
+	];
+	const walletWithDuplicateChains = coins.find((coin) => {
+		const chains = coin.wallets.map((wallet) => wallet.chain);
+		return new Set(chains).size !== chains.length;
+	});
+	if (walletWithDuplicateChains) throw new Error(`Coin ${walletWithDuplicateChains.coin} has duplicate chains in wallet`);
+	return {
+		allCoins: coins,
+		swapCoins: coins.filter((coin) => coin.allowSwap),
+		bridgeCoins: coins.filter((coin) => coin.allowBridge),
+		lendCoins: coins.filter((coin) => coin.allowLend),
+		borrowCoins: coins.filter((coin) => coin.allowBorrow),
+		loanCoins: coins.filter((coin) => coin.allowLend || coin.allowBorrow),
+		allEnabledCoins: coins.filter((coin) => coin.allowSwap || coin.allowBridge || coin.xtokenSymbol === "XMD")
+	};
+};
+// src/parsers/base.ts
+const accountParser = zod.string().regex(/^[.1-5a-z]{0,12}[.1-5a-j]?$/);
+const authorizationParser = zod.object({
+	actor: accountParser,
+	permission: zod.string()
+});
+const authorizationsParser = zod.array(authorizationParser).min(1);
+const ExtendedAssetParser = zod.object({
+	quantity: zod.string(),
+	contract: accountParser
+});
+const accountRamDeltaParser = zod.object({
+	account: zod.string(),
+	delta: zod.string()
+});
+// src/parsers/actions.ts
+const actionParser = zod.object({
+	account: zod.string(),
+	name: zod.string(),
+	authorization: zod.array(zod.object({
+		actor: zod.string(),
+		permission: zod.string()
+	})),
+	data: zod.any(),
+	hex_data: zod.string().optional()
+});
+const transactionExtensionsParser = zod.array(zod.number().or(zod.string())).optional();
+const rawTransactionParser = zod.object({
+	expiration: zod.string(),
+	ref_block_num: zod.number(),
+	ref_block_prefix: zod.number(),
+	max_net_usage_words: zod.number(),
+	max_cpu_usage_ms: zod.number(),
+	delay_sec: zod.number(),
+	context_free_actions: zod.array(actionParser),
+	transaction_extensions: zod.array(transactionExtensionsParser)
+});
+const baseActionParser = (contract, action, data) => zod.object({
+	account: contract === "*" ? accountParser : zod.literal(contract),
+	name: zod.literal(action),
+	data: zod.object(data),
+	authorization: authorizationsParser
+});
+const baseActionSerializedParser = (contract, action, data) => zod.object({
+	account: contract === "*" ? accountParser : zod.literal(contract),
+	name: zod.literal(action),
+	data: zod.string().or(zod.object(data)),
+	authorization: authorizationsParser
+});
+const webauthActionParser = (contract, action, data) => zod.object({
+	account: zod.literal("webauthn"),
+	name: zod.literal("exec"),
+	data: zod.object({
+		account: accountParser,
+		key: zod.object({
+			key: zod.array(zod.string().or(zod.object({
+				modulus: zod.string(),
+				exponent: zod.string()
+			}))),
+			user_presence: zod.number(),
+			rpid: zod.string()
+		}),
+		nonce: zod.number(),
+		permissions: authorizationsParser,
+		signature: zod.object({
+			auth_data: zod.string(),
+			client_json: zod.string(),
+			signature: zod.string()
+		}),
+		trx: rawTransactionParser.extend({ actions: zod.array(baseActionSerializedParser(contract, action, data)).length(1) })
+	}),
+	authorization: authorizationsParser
+});
+const singleActionTransactionParser = (contract, action, data) => {
+	const baseAction = baseActionParser(contract, action, data);
+	const webauthAction = webauthActionParser(contract, action, data);
+	return rawTransactionParser.extend({ actions: zod.array(baseAction.or(webauthAction)).length(1) });
+};
+// src/constants.ts
+const WRAP_CONTRACT = "proton.wrap";
+const WRAP_AUTH_ACTION = "generateauth";
+const FEE_FACTOR = 1e4;
+const initializeConstants = (chain) => {
+	const { swapCoins, bridgeCoins, allEnabledCoins, allCoins, lendCoins, borrowCoins, loanCoins } = initializeCoins(chain);
+	const constants = {
+		SWAP_CONTRACT: "proton.swaps",
+		VEST_CONTRACT: "vest",
+		DEX_CONTRACT: "dex",
+		FEE_FACTOR,
+		SWAP_URL: chain === "proton" ? "https://otc.protonswap.com" : "https://otc-test.protonswap.com",
+		WRAP_SERVER_URL: chain === "proton" ? "https://www.api.bloks.io/proton-wrap-public2" : "https://www.api.bloks.io/proton-wrap-testnet-public2",
+		WRAP_CONTRACT,
+		WRAP_ACTIONS: {
+			SAVE_ADDRESS: "saveaddress2",
+			DELETE_ADDRESS: "deladdress2",
+			WRAP_START: "wrapstart2",
+			WRAP_FINISH: "wrapfinish2",
+			WRAP_PROCESS: "wrapprocess2",
+			WRAP_SET_CONF: "wrapsetconf2"
+		},
+		WRAP_TABLES: {
+			ADDRESSES: "addresses2",
+			WRAPS: "wraps2"
+		},
+		ADDRESSES_INDEXES: {
+			BY_ACCOUNT: 2,
+			BY_ADDR_HASH: 3
+		},
+		WRAPS_INDEXES: {
+			BY_ACCOUNT: 2,
+			BY_STATUS: 3,
+			BY_WRAP_HASH: 4
+		},
+		WRAP_PROCESS_TIMER: 5e3,
+		FARM_CONTRACT: "yield.farms",
+		WEBHOOK_PERMISSION: "webhook",
+		PUBLIC_PERMISSION: "public",
+		LIGHT_PERMISSION: "light",
+		WRAP_AUTH_ACTION,
+		METAL_ENDPOINT: chain === "proton" ? "https://cirrus.metalpay.com" : "https://cirrus-dev.metalpay.com",
+		METAL_PROTON_ENDPOINT: chain === "proton" ? "https://identity.api.prod.metalx.com" : "https://identity.api.dev.metalx.com",
+		METAL_DEX_HTTP_ENDPOINT: chain === "proton" ? "https://dex.api.mainnet.metalx.com/dex" : "https://dex.api.testnet.metalx.com/dex",
+		METAL_DEX_WS_ENDPOINT: chain === "proton" ? "wss://dex.api.mainnet.metalx.com/dexws" : "wss://dex.api.testnet.metalx.com/dexws",
+		PROTON_ENDPOINTS: chain === "proton" ? [
+			"https://rpc.api.mainnet.metalx.com",
+			"https://proton.greymass.com",
+			"https://proton.eoscafeblock.com",
+			"https://proton.cryptolions.io",
+			"https://proton.eosusa.news"
+		] : ["https://rpc.api.testnet.metalx.com", "https://testnet.protonchain.com"],
+		CHAIN_ID: chain === "proton" ? "384da888112027f0321850a169f737c33e53b388aad48b5adace4bab97f437e0" : "71ee83bcf52142d61019d95f9cc5427ba6a0d7ff8accd9e2088ae2abeaf3d3dd",
+		COINS_URL: chain === "proton" ? "https://app.metalx.com/mainnet-coins.json" : "https://app.metalx.com/testnet-coins.json",
+		DEX_PROCESS_SIZE: 30,
+		DEX_SLTPPROCESS_SIZE: 10,
+		MAX_PRICE: "9223372036854775806",
+		MAX_ITEMS_PER_PAGE_DESKTOP: 100,
+		MIN_PRICE: 1,
+		DEFAULT_DEX_SYMBOL: "XPR_XMD",
+		CHAIN: chain,
+		SWAP_COINS: swapCoins,
+		BRIDGE_COINS: bridgeCoins,
+		ALL_ENABLED_COINS: allEnabledCoins,
+		LEND_COINS: lendCoins,
+		BORROW_COINS: borrowCoins,
+		LOAN_COINS: loanCoins,
+		ALL_COINS: allCoins,
+		XMD_CONTRACT: "xmd.treasury",
+		XMD_TOKEN_CONTRACT: "xmd.token",
+		XMD_SYMBOL_CODE: "XMD",
+		XMD_DECIMALS: 6,
+		findBridgeCoinWalletByXtokenAndChain(xtokenSymbol, chain) {
+			const bridgeCoin = constants.BRIDGE_COINS.find((bridgeCoin) => bridgeCoin.xtokenSymbol === xtokenSymbol);
+			if (!bridgeCoin) return void 0;
+			const bridgeWallet = bridgeCoin.wallets.find((bridgeWallet) => bridgeWallet.chain === chain);
+			if (!bridgeWallet) return void 0;
+			return {
+				...bridgeCoin,
+				...bridgeWallet
+			};
+		},
+		findBridgeCoinWallet(coin, wallet) {
+			const bridgeCoin = constants.BRIDGE_COINS.find((bridgeCoin) => bridgeCoin.coin === coin);
+			if (!bridgeCoin) return void 0;
+			const bridgeWallet = bridgeCoin.wallets.find((bridgeWallet) => bridgeWallet.wallet === wallet);
+			if (!bridgeWallet) return void 0;
+			return {
+				...bridgeCoin,
+				...bridgeWallet
+			};
+		},
+		findBridgeCoinWalletByWallet(wallet) {
+			const matches = [];
+			constants.BRIDGE_COINS.forEach((bridgeCoin) => {
+				bridgeCoin.wallets.forEach((bridgeWallet) => {
+					if (bridgeWallet.wallet === wallet) matches.push({
+						...bridgeCoin,
+						...bridgeWallet
+					});
+				});
+			});
+			return matches.length === 1 ? matches[0] : void 0;
+		},
+		findBridgeCoinNetwork(coin, network) {
+			const bridgeCoin = constants.BRIDGE_COINS.find((bridgeCoin) => bridgeCoin.coin === coin);
+			if (!bridgeCoin) return void 0;
+			const bridgeWallet = bridgeCoin.wallets.find((bridgeWallet) => bridgeWallet.network === network);
+			if (!bridgeWallet) return void 0;
+			return {
+				...bridgeCoin,
+				...bridgeWallet
+			};
+		}
+	};
+	return constants;
+};
+// src/parsers/auth.ts
+const createAbstractAuthParser = (contract, action, data) => {
+	return zod.object({
+		signer: authorizationParser,
+		signatures: zod.array(zod.string()).length(1),
+		transaction: singleActionTransactionParser(contract, action, data)
+	});
+};
+const generateAuthData = {
+	time: zod.string(),
+	protonAccount: zod.string()
+};
+const generateAuthActionsBaseParser = baseActionParser(WRAP_CONTRACT, WRAP_AUTH_ACTION, generateAuthData);
+const generateAuthParser = createAbstractAuthParser(WRAP_CONTRACT, WRAP_AUTH_ACTION, generateAuthData);
+// src/parsers/address.ts
+const addressParser = zod.object({
+	index: zod.number(),
+	account: accountParser,
+	chain: zod.string(),
+	address: zod.string(),
+	address_hash: zod.string()
+});
+const generateAddressBodyParser = generateAuthParser.extend({
+	coin: zod.string(),
+	wallet: zod.string()
+});
+const generateAddressResponse = zod.object({
+	id: zod.string(),
+	address: zod.string(),
+	coin: zod.string(),
+	wallet: zod.string(),
+	memo: zod.string().optional()
+});
+// src/parsers/currency.ts
+const rateParser = zod.object({
+	counterCurrency: zod.string(),
+	price: zod.number(),
+	priceChangePercent: zod.number(),
+	marketCap: zod.number(),
+	volume: zod.number(),
+	timestamp: zod.number()
+});
+const exchangeRateParser = zod.object({
+	contract: zod.string(),
+	symbol: zod.string(),
+	rank: zod.number(),
+	rates: zod.array(rateParser)
+});
+const exchangeRatesParser = zod.array(exchangeRateParser);
+const bloksRatesParser = zod.array(zod.object({
+	contract: zod.string(),
+	symbol: zod.string(),
+	rank: zod.number(),
+	rates: zod.array(rateParser)
+}));
+// src/parsers/deposit.ts
+let Type = /* @__PURE__ */ function(Type) {
+	Type["RECEIVE"] = "receive";
+	Type["SEND"] = "send";
+	return Type;
+}({});
+const depositBodyParser = zod.object({
+	id: zod.string(),
+	type: zod.enum(Type),
+	hash: zod.string(),
+	coin: zod.string(),
+	wallet: zod.string(),
+	network: zod.string()
+});
+const metalTransactionParser = zod.object({
+	id: zod.string(),
+	wallet: zod.string(),
+	value: zod.number(),
+	valueString: zod.string(),
+	address: zod.string(),
+	type: zod.enum(Type),
+	state: zod.string(),
+	confirmations: zod.number(),
+	hash: zod.string(),
+	blockHash: zod.string().optional().nullable(),
+	blockHeight: zod.number().optional().nullable()
+});
+// src/parsers/otc.ts
+const otcOrderResponseParser = zod.object({
+	success: zod.boolean(),
+	transaction_id: zod.string(),
+	errormsg: zod.string().optional()
+});
+const otcQuoteBodyParser = zod.object({
+	baseAmount: zod.number(),
+	baseSymbol: zod.string(),
+	quoteSymbol: zod.string()
+});
+const otcQuoteResponseParser = zod.object({
+	success: zod.boolean(),
+	token: zod.string(),
+	qty: zod.number(),
+	errormsg: zod.string().optional()
+});
+// src/parsers/withdraw.ts
+const withdrawData = {
+	from: zod.string().refine((val) => val !== WRAP_CONTRACT, { error: `${WRAP_CONTRACT} must be receiver` }),
+	to: zod.literal(WRAP_CONTRACT),
+	quantity: zod.string(),
+	memo: zod.string()
+};
+const withdrawBodyBaseAction = baseActionParser("*", "transfer", withdrawData);
+const withdrawBodyParser = zod.object({
+	signer: authorizationParser,
+	signatures: zod.array(zod.string()).length(1),
+	transaction: singleActionTransactionParser("*", "transfer", withdrawData),
+	quoteId: zod.string(),
+	provider: zod.string().optional()
+});
+const withdrawMetalResponseParser = zod.object({
+	success: zod.boolean(),
+	id: zod.string()
+});
+const withdrawalFeeQuoteParser = zod.object({
+	quoteId: zod.string(),
+	estimatedFee: zod.string(),
+	currency: zod.string(),
+	network: zod.string()
+});
+// src/parsers/withdrawalHistory.ts
+const withdrawHistoryMetalSwapParser = zod.object({
+	id: zod.string(),
+	status: zod.string(),
+	amount: zod.string(),
+	currency: zod.string(),
+	network: zod.string(),
+	created: zod.string(),
+	withdrawalAddress: zod.string(),
+	withdrawalHash: zod.string().optional()
+});
+const withdrawHistoryMetalResponseParser = zod.object({
+	swaps: zod.array(withdrawHistoryMetalSwapParser),
+	page: zod.number(),
+	pageSize: zod.number(),
+	numberOfElements: zod.number(),
+	totalPages: zod.number(),
+	totalElements: zod.number()
+});
+// src/parsers/wrap.ts
+let Status = /* @__PURE__ */ function(Status) {
+	Status["PENDING"] = "pending";
+	Status["SUCCESS"] = "success";
+	Status["FAIL"] = "fail";
+	Status["PROCESSING"] = "processing";
+	return Status;
+}({});
+const wrapStartParser = zod.object({
+	balance: ExtendedAssetParser,
+	id: zod.string(),
+	txid: zod.string(),
+	chain: zod.string(),
+	deposit_address: zod.string(),
+	confirmations: zod.number()
+});
+const wrapSetConfParser = zod.object({
+	wrap_hash: zod.string(),
+	confirmations: zod.number()
+});
+const wrapParser = zod.object({
+	index: zod.number(),
+	proton_account: zod.string(),
+	balance: ExtendedAssetParser,
+	id: zod.string(),
+	txid: zod.string(),
+	chain: zod.string(),
+	deposit_address: zod.string(),
+	status: zod.enum(Status),
+	finish_txid: zod.string(),
+	wrap_hash: zod.string(),
+	confirmations: zod.number()
+});
+// src/parsers/dex.ts
+const booleanParamSchema = zod.boolean().or(zod.enum(["true", "false"]).transform((value) => value === "true"));
+const createLimit = (base, max) => zod.coerce.number().default(base).refine((n) => +n > 0 && +n <= max, { error: `Limit must be between 0 and ${max}` });
+const createOffset = (base) => zod.coerce.number().default(base);
+const ordinalOrderIdsParser = zod.array(zod.string()).or(zod.string()).optional().transform((oids) => {
+	if (!oids) return [];
+	return Array.isArray(oids) ? oids : [oids];
+});
+const marketIdsParser = zod.array(zod.coerce.number()).or(zod.coerce.number()).transform((mids) => Array.isArray(mids) ? mids : [mids]).refine((mids) => mids.length > 0, { error: "Must provide atleast one market ID" });
+const contractFiltersParser = zod.array(zod.string()).or(zod.string()).optional().transform((oids) => {
+	if (!oids) return [];
+	return Array.isArray(oids) ? oids : [oids];
+});
+const sortDirectionEnum = zod.enum(["asc", "desc"]);
+/**
+* OHLCV
+*/
+const ohlcvParser = zod.object({
+	time: zod.number(),
+	open: zod.number(),
+	high: zod.number(),
+	low: zod.number(),
+	close: zod.number(),
+	volume: zod.number(),
+	volume_bid: zod.number(),
+	count: zod.number()
+});
+const getOhlcvParser = zod.object({
+	interval: zod.string(),
+	from: zod.string(),
+	to: zod.string(),
+	symbol: zod.string(),
+	limit: createLimit(500, 2e3)
+});
+const getOhlcvResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.array(ohlcvParser)
+});
+/**
+* Order History
+*/
+const openOrderParser = zod.object({
+	block_time: zod.string(),
+	order_id: zod.string(),
+	ordinal_order_id: zod.string(),
+	market_id: zod.number(),
+	quantity_init: zod.number().optional(),
+	quantity_curr: zod.number(),
+	price: zod.number(),
+	account_name: zod.string(),
+	order_side: zod.number(),
+	order_type: zod.number(),
+	trigger_price: zod.number(),
+	fill_type: zod.number(),
+	status: zod.string(),
+	filled_total: zod.number().optional(),
+	filled_amount: zod.number().optional(),
+	filled_fee: zod.number().optional(),
+	created_at: zod.string(),
+	updated_at: zod.string()
+});
+const orderLogParser = zod.object({
+	seq: zod.string(),
+	block_num: zod.string(),
+	block_time: zod.string(),
+	order_id: zod.string(),
+	market_id: zod.number(),
+	quantity: zod.string(),
+	price: zod.string(),
+	account_name: zod.string(),
+	order_side: zod.number(),
+	order_type: zod.number(),
+	trigger_price: zod.string(),
+	fill_type: zod.number(),
+	status: zod.string(),
+	quantity_change: zod.string(),
+	trx_id: zod.string()
+});
+const orderHistoryParser = zod.object({
+	block_num: zod.string(),
+	block_time: zod.string(),
+	order_id: zod.string(),
+	ordinal_order_id: zod.string(),
+	market_id: zod.number(),
+	quantity_init: zod.number().optional(),
+	quantity_curr: zod.number(),
+	price: zod.number(),
+	account_name: zod.string(),
+	order_side: zod.number(),
+	order_type: zod.number(),
+	trigger_price: zod.number(),
+	fill_type: zod.number(),
+	status: zod.string(),
+	quantity_change: zod.number(),
+	filled_total: zod.number().optional(),
+	filled_amount: zod.number().optional(),
+	filled_fee: zod.number().optional(),
+	seq: zod.string(),
+	trx_id: zod.string()
+});
+const getOpenOrdersParser = zod.object({
+	account: zod.string(),
+	symbol: zod.string().optional(),
+	offset: createOffset(0),
+	limit: createLimit(100, 250),
+	ordinal_order_ids: ordinalOrderIdsParser
+});
+const getOpenOrdersResponseParser = zod.object({
+	sync: zod.number(),
+	count: zod.number(),
+	data: zod.array(openOrderParser)
+});
+const getOrderHistoryParser = zod.object({
+	account: zod.string(),
+	symbol: zod.string().optional(),
+	offset: createOffset(0),
+	limit: createLimit(100, 250),
+	ordinal_order_ids: ordinalOrderIdsParser,
+	trx_id: zod.string().optional(),
+	status: zod.string().optional()
+});
+const getOrderHistoryResponseParser = zod.object({
+	sync: zod.number(),
+	count: zod.number(),
+	data: zod.array(orderHistoryParser)
+});
+const getOrderLifecycleParser = zod.object({
+	order_id: zod.string().optional(),
+	ordinal_order_id: zod.string().optional()
+});
+const getOrderLifecycleResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.array(orderHistoryParser)
+});
+/**
+* Submit Order
+*/
+const postSubmitOrderParser = zod.object({
+	serialized_tx_hex: zod.string(),
+	signatures: zod.array(zod.string())
+});
+const postSubmitOrderResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.object({
+		trx_id: zod.string(),
+		block_time: zod.string(),
+		orders: zod.array(zod.object({
+			ordinal_order_id: zod.string(),
+			order_id: zod.string(),
+			status: zod.string()
+		}))
+	})
+});
+/**
+* Serialize Order
+*/
+const postSerializeOrderParser = zod.object({ transaction: zod.object({ actions: zod.array(zod.object({
+	account: zod.string(),
+	name: zod.string(),
+	authorization: zod.array(authorizationParser),
+	data: zod.record(zod.string(), zod.any())
+})) }) });
+const postSerializeOrderResponseParser = zod.object({ data: zod.object({
+	serialized_tx_hex: zod.string(),
+	digest_hex: zod.string()
+}) });
+/**
+* Depth
+*/
+const depthParser = zod.object({
+	level: zod.number(),
+	ask: zod.number(),
+	bid: zod.number(),
+	count: zod.number()
+});
+const getDepthParser = zod.object({
+	symbol: zod.string(),
+	step: zod.coerce.number(),
+	limit: createLimit(100, 250)
+});
+const getDepthResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.object({
+		bids: zod.array(depthParser),
+		asks: zod.array(depthParser)
+	})
+});
+/**
+* Daily
+*/
+const dailyParser = zod.object({
+	market_id: zod.number(),
+	symbol: zod.string(),
+	open: zod.number(),
+	high: zod.number(),
+	low: zod.number(),
+	close: zod.number(),
+	volume_bid: zod.number(),
+	volume_ask: zod.number(),
+	change_percentage: zod.number()
+});
+const getDailyResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.array(dailyParser)
+});
+/**
+* Markets
+*/
+const marketParser = zod.object({
+	market_id: zod.number(),
+	symbol: zod.string(),
+	status_code: zod.number(),
+	type: zod.string(),
+	maker_fee: zod.number(),
+	taker_fee: zod.number(),
+	order_min: zod.number(),
+	bid_token: zod.object({
+		code: zod.string(),
+		precision: zod.number(),
+		contract: zod.string(),
+		multiplier: zod.number()
+	}),
+	ask_token: zod.object({
+		code: zod.string(),
+		precision: zod.number(),
+		contract: zod.string(),
+		multiplier: zod.number()
+	})
+});
+const dbMarketParser = zod.object({
+	market_id: zod.number(),
+	order_min: zod.string(),
+	status_code: zod.number(),
+	ask_oracle_index: zod.string(),
+	bid_token_c: zod.string(),
+	bid_token_s: zod.string(),
+	bid_token_m: zod.string(),
+	ask_token_c: zod.string(),
+	ask_token_s: zod.string(),
+	ask_token_m: zod.string(),
+	created_at: zod.date(),
+	updated_at: zod.date()
+});
+const getMarketsResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.array(marketParser)
+});
+/**
+* Trades
+*/
+const tradeLogParser = zod.object({
+	block_num: zod.string(),
+	block_time: zod.string(),
+	trade_id: zod.string(),
+	market_id: zod.number(),
+	price: zod.string(),
+	bid_user: zod.string(),
+	bid_user_order_id: zod.string(),
+	bid_total: zod.string(),
+	bid_amount: zod.string(),
+	bid_fee: zod.string(),
+	bid_referrer: zod.string(),
+	bid_referrer_fee: zod.string(),
+	ask_user: zod.string(),
+	ask_user_order_id: zod.string(),
+	ask_total: zod.string(),
+	ask_amount: zod.string(),
+	ask_fee: zod.string(),
+	ask_referrer: zod.string(),
+	ask_referrer_fee: zod.string(),
+	order_side: zod.number(),
+	trx_id: zod.string()
+});
+const tradeParser = zod.object({
+	block_num: zod.string(),
+	block_time: zod.string(),
+	trade_id: zod.string(),
+	market_id: zod.number(),
+	price: zod.number(),
+	bid_user: zod.string(),
+	bid_user_order_id: zod.string(),
+	bid_user_ordinal_order_id: zod.string(),
+	bid_total: zod.number(),
+	bid_amount: zod.number(),
+	bid_fee: zod.number(),
+	bid_referrer: zod.string(),
+	bid_referrer_fee: zod.number(),
+	ask_user: zod.string(),
+	ask_user_order_id: zod.string(),
+	ask_user_ordinal_order_id: zod.string(),
+	ask_total: zod.number(),
+	ask_amount: zod.number(),
+	ask_fee: zod.number(),
+	ask_referrer: zod.string(),
+	ask_referrer_fee: zod.number(),
+	order_side: zod.number(),
+	trx_id: zod.string()
+});
+const getTradesParser = zod.object({
+	symbol: zod.string(),
+	offset: createOffset(0),
+	limit: createLimit(100, 250)
+});
+const getTradesResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.array(tradeParser)
+});
+const getTradeHistoryParser = zod.object({
+	account: zod.string(),
+	symbol: zod.string().optional(),
+	offset: createOffset(0),
+	ordinal_order_ids: ordinalOrderIdsParser,
+	limit: createLimit(100, 250)
+});
+const getTradeHistoryResponseParser = zod.object({
+	sync: zod.number(),
+	count: zod.number(),
+	data: zod.array(tradeParser)
+});
+/**
+* SYNC
+*/
+const syncParser = zod.object({
+	sourceid: zod.number(),
+	block_num: zod.string(),
+	block_time: zod.string(),
+	irreversible: zod.string(),
+	is_master: zod.number(),
+	last_updated: zod.string()
+});
+const getSyncResponseParser = zod.object({
+	dbSecondsBehind: zod.number(),
+	chronicleSecondsBehind: zod.number(),
+	maxSecondsBehind: zod.number()
+});
+/**
+* Referral Totals
+*/
+const refferalTotalParser = zod.object({
+	referrer: zod.string(),
+	market_id: zod.number(),
+	bid_fee: zod.number(),
+	bid_total: zod.number(),
+	ask_fee: zod.number(),
+	ask_total: zod.number()
+});
+const getReferralTotalsParser = zod.object({ referrer: zod.string() });
+const getReferralTotalsResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.array(refferalTotalParser)
+});
+/**
+* Referrals
+*/
+const refferalParser = zod.object({ referred_user: zod.string() });
+const getReferralsParser = zod.object({ referrer: zod.string() });
+const getReferralsResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.array(refferalParser)
+});
+/**
+* Leaderboard
+*/
+const leaderboardParser = zod.object({
+	user: zod.string(),
+	total: zod.number()
+});
+const getLeaderboardParser = zod.object({
+	market_ids: marketIdsParser,
+	from: zod.string(),
+	to: zod.string(),
+	exclude_zero_fee: booleanParamSchema.prefault("true")
+});
+const getLeaderboardResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.array(leaderboardParser)
+});
+/**
+* History Transaction
+*/
+const historyPartialParser = zod.object({
+	expiration: zod.object({ utc_seconds: zod.string() }),
+	ref_block_num: zod.string(),
+	ref_block_prefix: zod.string(),
+	max_net_usage_words: zod.string(),
+	max_cpu_usage_ms: zod.string(),
+	delay_sec: zod.string(),
+	transaction_extensions: zod.array(zod.unknown()),
+	signatures: zod.array(zod.string()),
+	context_free_data: zod.array(zod.unknown())
+});
+const actParser = zod.object({
+	account: zod.string(),
+	name: zod.string(),
+	authorization: zod.array(authorizationParser),
+	data: zod.any()
+});
+const receiptParser = zod.object({
+	receiver: zod.string(),
+	act_digest: zod.string(),
+	global_sequence: zod.string(),
+	recv_sequence: zod.string(),
+	auth_sequence: zod.array(zod.object({
+		account: zod.string(),
+		sequence: zod.string()
+	})),
+	code_sequence: zod.string(),
+	abi_sequence: zod.string()
+});
+const actionTraceParser = zod.object({
+	action_ordinal: zod.string(),
+	creator_action_ordinal: zod.string(),
+	receipt: receiptParser,
+	receiver: zod.string(),
+	act: actParser,
+	context_free: zod.string(),
+	elapsed: zod.string(),
+	console: zod.string(),
+	account_ram_deltas: zod.array(accountRamDeltaParser),
+	except: zod.string(),
+	error_code: zod.string().nullable(),
+	return_value: zod.string()
+});
+const traceParser = zod.object({
+	id: zod.string(),
+	status: zod.string(),
+	cpu_usage_us: zod.string(),
+	net_usage_words: zod.string(),
+	elapsed: zod.string(),
+	net_usage: zod.string(),
+	scheduled: zod.string(),
+	action_traces: zod.array(actionTraceParser),
+	account_ram_delta: zod.array(accountRamDeltaParser).nullable(),
+	except: zod.string(),
+	error_code: zod.string().nullable(),
+	failed_dtrx_trace: zod.array(zod.unknown()),
+	partial: historyPartialParser
+});
+const historyTransactionParser = zod.object({
+	seq: zod.string(),
+	block_num: zod.string(),
+	block_time: zod.string(),
+	trx_id: zod.string(),
+	trace: zod.object({
+		block_num: zod.string(),
+		block_timestamp: zod.string(),
+		trace: traceParser
+	}),
+	irreversible: zod.boolean()
+});
+const getHistoryTransactionResponseParser = zod.object({ data: historyTransactionParser.nullable() });
+const chronicleTransactionParser = zod.object({
+	block_num: zod.string(),
+	block_timestamp: zod.string(),
+	trace: traceParser
+});
+const dbHistoryTransactionParser = zod.object({
+	seq: zod.string(),
+	block_num: zod.string(),
+	block_time: zod.string(),
+	trx_id: zod.string(),
+	trace: zod.any()
+});
+/**
+* History Actions
+*/
+const getHistoryActionsParser = zod.object({
+	account: zod.string().min(1, { error: "account is required" }),
+	contract_filters: contractFiltersParser,
+	account_seq_from: zod.string().optional(),
+	account_seq_to: zod.string().optional(),
+	date_from: zod.string().optional(),
+	date_to: zod.string().optional(),
+	direction: sortDirectionEnum.optional(),
+	limit: createLimit(100, 250)
+});
+const historyActionParser = zod.object({
+	block_num: zod.number(),
+	block_time: zod.string(),
+	trx_id: zod.string(),
+	account_action_seq: zod.number(),
+	global_action_seq: zod.number(),
+	action_trace: actionTraceParser,
+	irreversible: zod.boolean()
+});
+const getHistoryActionsResponseParser = zod.object({
+	sync: zod.number(),
+	last_irreversible_block_num: zod.number(),
+	data: zod.array(historyActionParser)
+});
+/**
+* History transfers
+*/
+const getHistoryTransfersParser = zod.object({
+	transfer_from: zod.string().optional(),
+	transfer_to: zod.string().optional(),
+	contract: zod.string().optional(),
+	symbol: zod.string().optional(),
+	amount_precision: zod.string().optional(),
+	amount_min: zod.string().optional(),
+	amount_max: zod.string().optional(),
+	date_from: zod.string().optional(),
+	date_to: zod.string().optional(),
+	global_seq_from: zod.string().optional(),
+	global_seq_to: zod.string().optional(),
+	direction: sortDirectionEnum.optional(),
+	limit: createLimit(100, 250)
+});
+const historyTransferParser = zod.object({
+	block_num: zod.number(),
+	block_time: zod.string(),
+	trx_id: zod.string(),
+	account_action_seq: zod.number(),
+	global_action_seq: zod.number(),
+	action_trace: actionTraceParser,
+	irreversible: zod.boolean()
+});
+const getHistoryTransfersResponseParser = zod.object({
+	sync: zod.number(),
+	last_irreversible_block_num: zod.number(),
+	data: zod.array(historyTransferParser)
+});
+/**
+* Open orders Balances
+*/
+const marketOpenOrdersBalanceParser = zod.object({
+	market_id: zod.number(),
+	bid_token_quantity: zod.number(),
+	bid_token: zod.string(),
+	ask_token_quantity: zod.number(),
+	ask_token: zod.string()
+});
+const getOpenOrdersBalancesResponseParser = zod.object({
+	sync: zod.number(),
+	data: zod.array(marketOpenOrdersBalanceParser)
+});
+/**
+* Basic Types
+*/
+let orderType = /* @__PURE__ */ function(orderType) {
+	orderType[orderType["ORDERBOOK"] = 0] = "ORDERBOOK";
+	orderType[orderType["LIMIT"] = 1] = "LIMIT";
+	orderType[orderType["STOPLOSS"] = 2] = "STOPLOSS";
+	orderType[orderType["TAKEPROFIT"] = 3] = "TAKEPROFIT";
+	return orderType;
+}({});
+let orderSide = /* @__PURE__ */ function(orderSide) {
+	orderSide[orderSide["INVALID"] = 0] = "INVALID";
+	orderSide[orderSide["BUY"] = 1] = "BUY";
+	orderSide[orderSide["SELL"] = 2] = "SELL";
+	return orderSide;
+}({});
+let fillType = /* @__PURE__ */ function(fillType) {
+	fillType[fillType["GTC"] = 0] = "GTC";
+	fillType[fillType["IOC"] = 1] = "IOC";
+	fillType[fillType["POST_ONLY"] = 2] = "POST_ONLY";
+	return fillType;
+}({});
+let logStatus = /* @__PURE__ */ function(logStatus) {
+	logStatus["CREATE"] = "create";
+	logStatus["UPDATE"] = "update";
+	logStatus["TRANSFER"] = "transfer";
+	logStatus["CANCEL"] = "cancel";
+	logStatus["DELETE"] = "delete";
+	return logStatus;
+}({});
+let ITopics = /* @__PURE__ */ function(ITopics) {
+	ITopics["TRADES"] = "TRADES";
+	ITopics["ORDERS"] = "ORDERS";
+	return ITopics;
+}({});
+const TOPICS = {
+	["TRADES"]: { topic: "TRADES" },
+	["ORDERS"]: { topic: "ORDERS" }
+};
+// src/parsers/login.ts
+const loginAccountParamsV3Parser = generateAuthParser.extend({
+	email: zod.string().optional(),
+	verificationCode: zod.string().optional()
+});
+// src/utils.ts
+const isSameToken = (token1, token2) => {
+	return token1.xtokenSymbol === token2.xtokenSymbol && token1.xtokenPrecision === token2.xtokenPrecision && token1.xtokenContract === token2.xtokenContract;
+};
+const median = (numbers) => {
+	const sorted = numbers.slice().sort((a, b) => a - b);
+	const middle = Math.floor(sorted.length / 2);
+	if (sorted.length % 2 === 0) return (sorted[middle - 1] + sorted[middle]) / 2;
+	return sorted[middle];
+};
+// src/graph.ts
+var INode = class {
+	constructor(key, data) {
+		this.key = key;
+		this.data = {};
+		if (data) this.data = data;
+	}
+};
+var ILink = class {
+	constructor(from, to, data) {
+		this.from = from;
+		this.to = to;
+		this.data = {};
+		if (data) this.data = data;
+	}
+};
+var Graph = class {
+	constructor() {
+		this.nodes = [];
+		this.links = [];
+		this.lastPathFound = [];
+		this.isEquals = (a, b) => a.key === b.key;
+	}
+	addNode(k, v) {
+		if (!this.findNode(k)) this.nodes.push(new INode(k, v));
+	}
+	addNodes(...nodes) {
+		nodes.forEach((node) => typeof node === "string" ? this.addNode(node) : this.addNode(node[0], node[1]));
+	}
+	findNode(k) {
+		const inode = new INode(k);
+		return this.nodes.find((node) => this.isEquals(node, inode));
+	}
+	findNodes(...keys) {
+		return keys.map((k) => this.findNode(k));
+	}
+	requireFindNodes(...keys) {
+		const nodes = this.findNodes(...keys);
+		if (nodes.some((n) => n === void 0)) throw new Error("One of the nodes does not exist");
+		return nodes;
+	}
+	addLink(nodeA, nodeB, data) {
+		const [inodeA, inodeB] = this.requireFindNodes(nodeA, nodeB);
+		this.links.push(new ILink(inodeA, inodeB, data));
+	}
+	addLinks(...links) {
+		links.forEach((link) => this.addLink(...link));
+	}
+	/** 
+	* Get all nodes linked 
+	* to from `node`.
+	*/
+	findLinkedNodes(node) {
+		return this.links.reduce((acc, link) => {
+			if (this.isEquals(link.from, node)) acc.push(link.to);
+			return acc;
+		}, []);
+	}
+	findAllPaths(from, to) {
+		const allPaths = [];
+		const [fromNode, toNode] = this.requireFindNodes(from, to);
+		const path = [fromNode];
+		let seen = /* @__PURE__ */ new Set();
+		const stuck = (x) => {
+			if (this.isEquals(x, toNode)) return false;
+			for (const y of this.findLinkedNodes(x)) if (!seen.has(y.key)) {
+				seen.add(y.key);
+				if (!stuck(y)) return false;
+			}
+			return true;
+		};
+		const search = (x) => {
+			if (this.isEquals(x, toNode)) {
+				allPaths.push((0, lodash_clonedeep.default)(path));
+				return;
+			}
+			seen = new Set(path.map((p) => p.key));
+			if (stuck(x)) return;
+			for (const y of this.findLinkedNodes(x)) if (!path.includes(y)) {
+				path.push(y);
+				search(y);
+				path.pop();
+			}
+		};
+		search(fromNode);
+		return allPaths;
+	}
+};
+// src/math.ts
+/**
+* XPR<>XUSDT (XPR -> XUSDT)
+*
+*                     pool1 * pool2
+*  term =  pool2  -  --------------
+*                     pool1 + swap
+*
+*  result = term - (term * fee)
+*/
+const compute_transfer = (pool1, pool2, swap, exchange_fee, precision) => {
+	const term1 = pool2;
+	const term2over = pool1.times(pool2);
+	const term2under = pool1.plus(swap);
+	const term2 = term2over.div(term2under).integerValue(bignumber_js.default.ROUND_DOWN);
+	const term = term1.minus(term2);
+	const fee = new bignumber_js.default(exchange_fee).div(FEE_FACTOR);
+	return term.minus(term.times(fee)).integerValue(bignumber_js.default.ROUND_DOWN).shiftedBy(-precision);
+};
+const compute_transfer_curve = (reserve_in, reserve_out, amount_in, exchange_fee, precision, amplifier) => {
+	if (amplifier === 0) return compute_transfer(new bignumber_js.default(reserve_in), new bignumber_js.default(reserve_out), new bignumber_js.default(amount_in), exchange_fee, precision);
+	const MAX_ITERATIONS = 10;
+	const sum = reserve_in + reserve_out;
+	let D = sum;
+	let D_prev = 0;
+	const F = (v) => {
+		return (v >= 0 ? 1 : -1) * Math.floor(Math.abs(v));
+	};
+	let i = MAX_ITERATIONS;
+	while (D != D_prev && i--) {
+		const prod1 = F(F(D * D / (reserve_in * 2)) * D / (reserve_out * 2));
+		D_prev = D;
+		D = F(2 * D * (amplifier * sum + prod1) / ((2 * amplifier - 1) * D + 3 * prod1));
+	}
+	const b = reserve_in + amount_in + F(D / (amplifier * 2)) - D;
+	const c = F(F(D * D / ((reserve_in + amount_in) * 2)) * D / (amplifier * 4));
+	let x = D, x_prev = 0;
+	i = MAX_ITERATIONS;
+	while (x != x_prev && i--) {
+		x_prev = F(x);
+		x = +new bignumber_js.default(x * x + c).div(2 * x + b).toFixed(0, bignumber_js.default.ROUND_DOWN);
+	}
+	if (reserve_out <= x) throw new Error("curve: insufficient reserve out");
+	const amount_out_with_fee = new bignumber_js.default(reserve_out - x);
+	const fee = amount_out_with_fee.times(exchange_fee).div(FEE_FACTOR).plus(1).toFixed(0, bignumber_js.default.ROUND_DOWN);
+	return amount_out_with_fee.minus(fee).integerValue(bignumber_js.default.ROUND_DOWN).shiftedBy(-precision);
+};
+const compute_liquidity = (amount_lt, pool, lt_supply, precision) => {
+	const over = amount_lt.times(pool);
+	const under = lt_supply;
+	return +over.div(under).integerValue(bignumber_js.default.ROUND_DOWN).shiftedBy(-precision).toFixed(precision, bignumber_js.default.ROUND_DOWN);
+};
+const isInputInvalid = (data, value, pool) => {
+	value = String(value);
+	const isBackspace = data === null;
+	const isNumber = !/[0-9]|\./.test(data);
+	const isDoubleDot = data === "." && value.indexOf(".") !== value.length - 1;
+	const isPrecisionTooHigh = value && value.indexOf(".") !== -1 && value.split(".")[1].length > pool.xtokenPrecision;
+	return !isBackspace && Boolean(isNumber || isDoubleDot || isPrecisionTooHigh);
+};
+const applyDiscountToFee = (fee, staked) => {
+	if (staked >= 1e7) return fee * 0;
+	else if (staked >= 1e6) return fee * .33;
+	else if (staked >= 1e5) return fee * .66;
+	else return fee;
+};
+// src/validation/address.ts
+/**
+* Withdrawal destination validation for the bridge (MFE-855).
+*
+* The address and memo end up inside the XPR transfer memo as
+* `coin:network:address[?memo=...]:fee`, which the bridge server splits on ':'.
+* So beyond per-chain format checks, these validators also reject characters
+* that would corrupt that structure.
+*
+* Result levels:
+*  - 'full'  : the chain's address format was fully checked, including its
+*              checksum where the format has one. Formats without a checksum
+*              (Solana keys, EOS names, Hedera ids, single-case EVM) cannot
+*              catch every typo even at this level.
+*  - 'basic' : only the shared safety rules (and partial format checks) ran,
+*              because no complete validator exists for this chain/format.
+*/
+const MAX_ADDRESS_LENGTH = 128;
+const MAX_DEFAULT_MEMO_BYTES = 256;
+const FULL = {
+	valid: true,
+	level: "full"
+};
+const BASIC = {
+	valid: true,
+	level: "basic"
+};
+const fail = (reason) => ({
+	valid: false,
+	reason
+});
+const PRINTABLE_ASCII = /^[\x21-\x7e]+$/;
+const sharedAddressChecks = (address) => {
+	if (typeof address !== "string" || address.length === 0) return fail("Address is required.");
+	if (address.length > 128) return fail("Address is too long.");
+	if (!PRINTABLE_ASCII.test(address)) return fail("Address contains spaces or unsupported characters.");
+	if (address.includes(":")) return fail("Address must not contain \":\". If you pasted a payment link, paste only the address.");
+	if (address.includes("?")) return fail("Address must not contain \"?\". Use the memo field for memos or tags.");
+	return null;
+};
+const tryDecode = (fn) => {
+	try {
+		return fn();
+	} catch {
+		return;
+	}
+};
+const bytesEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+const allZero = (a) => a.every((v) => v === 0);
+const UTXO_PARAMS = {
+	["Bitcoin"]: {
+		name: "Bitcoin",
+		segwitHrp: "bc",
+		base58Versions: [0, 5]
+	},
+	["Bitcoin (Testnet)"]: {
+		name: "Bitcoin testnet",
+		segwitHrp: "tb",
+		base58Versions: [111, 196]
+	},
+	["Litecoin"]: {
+		name: "Litecoin",
+		segwitHrp: "ltc",
+		base58Versions: [
+			48,
+			50,
+			5
+		]
+	},
+	["Litecoin (Testnet)"]: {
+		name: "Litecoin testnet",
+		segwitHrp: "tltc",
+		base58Versions: [
+			111,
+			58,
+			196
+		]
+	},
+	["Dogecoin"]: {
+		name: "Dogecoin",
+		base58Versions: [30, 22]
+	}
+};
+const base58check = (0, _scure_base.createBase58check)(_noble_hashes_sha2.sha256);
+const BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+const validateSegwit = (address, hrp, name) => {
+	if (address.length > 90) return fail(`Not a valid ${name} address.`);
+	const lower = address.toLowerCase();
+	const version = BECH32_CHARSET.indexOf(lower.charAt(hrp.length + 1));
+	if (version < 0) return fail(`Not a valid ${name} address.`);
+	const decoded = tryDecode(() => (version === 0 ? _scure_base.bech32 : _scure_base.bech32m).decode(address, 90));
+	if (!decoded || decoded.prefix !== hrp) return fail(`Not a valid ${name} address (checksum or network mismatch).`);
+	const program = tryDecode(() => _scure_base.bech32.fromWords(decoded.words.slice(1)));
+	if (!program) return fail(`Not a valid ${name} address.`);
+	if (version === 0 && program.length !== 20 && program.length !== 32) return fail(`Not a valid ${name} address.`);
+	if (version === 1 && program.length !== 32) return fail(`Not a valid ${name} address.`);
+	if (version > 1) return fail(`Unsupported ${name} address version.`);
+	return FULL;
+};
+const validateUtxo = (address, params) => {
+	const { name, segwitHrp, base58Versions } = params;
+	if (segwitHrp && address.toLowerCase().startsWith(`${segwitHrp}1`)) return validateSegwit(address, segwitHrp, name);
+	const payload = tryDecode(() => base58check.decode(address));
+	if (!payload || payload.length !== 21 || !base58Versions.includes(payload[0])) return fail(`Not a valid ${name} address (checksum or network mismatch).`);
+	return FULL;
+};
+const EVM_CHAINS = /* @__PURE__ */ new Set([
+	"Ethereum",
+	"Ethereum (Sepolia)",
+	"Binance (BEP20)",
+	"Polygon",
+	"Avalanche C-Chain",
+	"Metal C-Chain",
+	"Metal C-Chain (Testnet)",
+	"Metal L2",
+	"Metal L2 (Testnet)"
+]);
+const toHex = (bytes) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+const validateHex40 = (hex) => {
+	if (!/^[0-9a-fA-F]{40}$/.test(hex)) return fail("Address must be 0x followed by 40 hexadecimal characters.");
+	if (/^0{40}$/.test(hex)) return fail("Withdrawing to the zero address would burn the funds.");
+	const lower = hex.toLowerCase();
+	if (hex === lower || hex === hex.toUpperCase()) return FULL;
+	const hash = toHex((0, _noble_hashes_sha3.keccak_256)(new TextEncoder().encode(lower)));
+	for (let i = 0; i < 40; i++) {
+		const c = hex[i];
+		if (c >= "0" && c <= "9") continue;
+		const shouldBeUpper = parseInt(hash[i], 16) >= 8;
+		if (c === c.toUpperCase() !== shouldBeUpper) return fail("Address checksum (EIP-55 capitalization) is invalid. Check for a typo.");
+	}
+	return FULL;
+};
+const validateEvm = (address) => address.startsWith("0x") ? validateHex40(address.slice(2)) : fail("Address must start with 0x.");
+const validateXdc = (address) => {
+	if (address.startsWith("xdc") || address.startsWith("0x")) return validateHex40(address.slice(address.startsWith("xdc") ? 3 : 2));
+	return fail("Address must start with xdc or 0x.");
+};
+const crc16xmodem = (data) => {
+	let crc = 0;
+	for (const byte of data) {
+		crc ^= byte << 8;
+		for (let i = 0; i < 8; i++) crc = crc & 32768 ? (crc << 1 ^ 4129) & 65535 : crc << 1 & 65535;
+	}
+	return crc;
+};
+const STELLAR_KINDS = {
+	G: {
+		length: 56,
+		version: 48,
+		bytes: 35
+	},
+	M: {
+		length: 69,
+		version: 96,
+		bytes: 43
+	}
+};
+const validateStellar = (address) => {
+	const kind = STELLAR_KINDS[address[0]];
+	if (!kind || address.length !== kind.length || !/^[A-Z2-7]+$/.test(address)) return fail("Not a valid Stellar address (should start with G and be 56 characters).");
+	const data = tryDecode(() => _scure_base.base32nopad.decode(address));
+	if (!data || data.length !== kind.bytes || data[0] !== kind.version) return fail("Not a valid Stellar address.");
+	const body = data.slice(0, -2);
+	const crc = crc16xmodem(body);
+	if (data[data.length - 2] !== (crc & 255) || data[data.length - 1] !== crc >> 8) return fail("Stellar address checksum is invalid. Check for a typo.");
+	return FULL;
+};
+const XRP_BLACKHOLES = [/* @__PURE__ */ new Uint8Array(20), Uint8Array.from([.../* @__PURE__ */ new Uint8Array(19), 1])];
+const validateXrp = (address) => {
+	if (address.startsWith("X") || address.startsWith("T")) return fail("X-addresses are not supported. Use the classic r-address and put the destination tag in the memo field.");
+	if (!address.startsWith("r") || address.length < 25 || address.length > 35) return fail("Not a valid XRP address.");
+	const data = tryDecode(() => _scure_base.base58xrp.decode(address));
+	if (!data || data.length !== 25 || data[0] !== 0) return fail("Not a valid XRP address.");
+	const checksum = (0, _noble_hashes_sha2.sha256)((0, _noble_hashes_sha2.sha256)(data.slice(0, 21))).slice(0, 4);
+	if (!bytesEqual(checksum, data.slice(21))) return fail("XRP address checksum is invalid. Check for a typo.");
+	const accountId = data.slice(1, 21);
+	if (XRP_BLACKHOLES.some((b) => bytesEqual(b, accountId))) return fail("This XRP address is unspendable (black hole).");
+	return FULL;
+};
+const validateSolana = (address) => {
+	if (address.length < 32 || address.length > 44) return fail("Not a valid Solana address.");
+	const key = tryDecode(() => _scure_base.base58.decode(address));
+	if (!key || key.length !== 32) return fail("Not a valid Solana address.");
+	if (allZero(key)) return fail("This is the Solana system program, not a wallet address.");
+	return FULL;
+};
+const validateCardano = (address) => {
+	const lower = address.toLowerCase();
+	if (lower.startsWith("addr_test1")) return fail("This is a Cardano testnet address.");
+	if (lower.startsWith("stake")) return fail("This is a Cardano stake (reward) address, not a payment address.");
+	if (lower.startsWith("addr1")) {
+		const decoded = tryDecode(() => _scure_base.bech32.decode(address, 1023));
+		const data = decoded && tryDecode(() => _scure_base.bech32.fromWords(decoded.words));
+		if (!decoded || decoded.prefix !== "addr" || !data || data.length === 0) return fail("Not a valid Cardano address (checksum failed). Check for a typo.");
+		const type = data[0] >> 4;
+		if ((data[0] & 15) !== 1) return fail("This Cardano address is not for mainnet.");
+		return (type <= 3 ? data.length === 57 : type <= 5 ? data.length > 29 : type <= 7 ? data.length === 29 : false) ? FULL : fail("Not a valid Cardano payment address.");
+	}
+	if ((address.startsWith("Ae2") || address.startsWith("DdzFF")) && tryDecode(() => _scure_base.base58.decode(address))) return BASIC;
+	return fail("Not a valid Cardano address.");
+};
+const validateEos = (address) => /^[a-z1-5.]{1,12}$/.test(address) && !address.endsWith(".") ? FULL : fail("EOS account names are 1-12 characters: a-z, 1-5 and \".\" (not at the end).");
+const validateHedera = (address) => {
+	const match = /^0\.0\.(\d{1,19})(-[a-z]{5})?$/.exec(address);
+	if (!match) return fail("Hedera account ids look like 0.0.12345.");
+	return match[2] ? BASIC : FULL;
+};
+const VALIDATORS = {
+	["XDC Network"]: validateXdc,
+	["Stellar"]: validateStellar,
+	["Stellar (Testnet)"]: validateStellar,
+	["Ripple"]: validateXrp,
+	["Solana"]: validateSolana,
+	["Cardano"]: validateCardano,
+	["EOS"]: validateEos,
+	["EOS (Jungle Testnet)"]: validateEos,
+	["Hedera (Mainnet)"]: validateHedera,
+	["Hedera (Testnet)"]: validateHedera
+};
+/**
+* Validate a withdrawal destination address for the given bridge chain
+* (a `Chains` enum value, i.e. `wallet.chain`). Expects already-trimmed input.
+* Pure and synchronous, so it is safe to call on every keystroke.
+*/
+const validateWithdrawAddress = (chain, address) => {
+	const sharedFailure = sharedAddressChecks(address);
+	if (sharedFailure) return sharedFailure;
+	const utxo = UTXO_PARAMS[chain];
+	if (utxo) return validateUtxo(address, utxo);
+	if (EVM_CHAINS.has(chain)) return validateEvm(address);
+	const validator = VALIDATORS[chain];
+	return validator ? validator(address) : BASIC;
+};
+const MEMO_BYTE_LIMITS = {
+	["Stellar"]: 28,
+	["Stellar (Testnet)"]: 28,
+	["Hedera (Mainnet)"]: 100,
+	["Hedera (Testnet)"]: 100
+};
+/**
+* Validate an optional withdrawal memo / destination tag. The memo is appended
+* to the address as `?memo=...` inside the ':'-delimited bridge memo, so
+* delimiter and URL-structure characters are rejected on every chain.
+*/
+const validateWithdrawMemo = (chain, memo) => {
+	if (memo === void 0 || memo === "") return { valid: true };
+	if (typeof memo !== "string") return fail("Memo must be text.");
+	if (/\p{Cc}/u.test(memo)) return fail("Memo contains unsupported characters.");
+	if (/[:?&#=]/.test(memo)) return fail("Memo must not contain : ? & # or =.");
+	if (chain === "Ripple") return /^\d{1,10}$/.test(memo) && Number(memo) <= 4294967295 ? { valid: true } : fail("XRP destination tags must be a whole number between 0 and 4294967295.");
+	const limit = MEMO_BYTE_LIMITS[chain] ?? MAX_DEFAULT_MEMO_BYTES;
+	if (new TextEncoder().encode(memo).length > limit) return fail(`Memo must be at most ${limit} bytes.`);
+	return { valid: true };
+};
+// src/validation/withdrawError.ts
+/**
+* Turn a failed bridge withdrawal request into a message that is safe to show
+* to the user (MFE-855).
+*
+* Only 4xx responses are treated as user-facing: they describe a problem with
+* the request (for example an invalid address passed through from Proton Swap).
+* 5xx responses, network failures and anything unrecognised get a generic
+* message, so server internals such as stack traces are never displayed and
+* the raw "AxiosError: Request failed with status code 500" is never shown.
+*
+* Duck-typed so it has no axios dependency.
+*/
+const GENERIC_WITHDRAW_ERROR = "Withdrawal failed. Please check the amount and address and try again.";
+const MAX_WITHDRAW_ERROR_LENGTH = 200;
+const sanitize = (raw) => {
+	const cleaned = raw.replace(/[\p{Cc}\s]+/gu, " ").trim();
+	return cleaned.length > 200 ? `${cleaned.slice(0, 199)}…` : cleaned;
+};
+const messageFromBody = (data) => {
+	if (typeof data === "string") return data;
+	if (data && typeof data === "object") {
+		const { message, error } = data;
+		if (typeof message === "string") return message;
+		if (typeof error === "string") return error;
+	}
+};
+const withdrawErrorMessage = (error) => {
+	const response = error?.response;
+	const status = response?.status;
+	if (typeof status !== "number" || status < 400 || status >= 500) return GENERIC_WITHDRAW_ERROR;
+	const raw = messageFromBody(response?.data);
+	return (raw === void 0 ? "" : sanitize(raw)) || "Withdrawal failed. Please check the amount and address and try again.";
+};
+exports.Chains = Chains;
+exports.ExtendedAssetParser = ExtendedAssetParser;
+exports.FEE_FACTOR = FEE_FACTOR;
+exports.GENERIC_WITHDRAW_ERROR = GENERIC_WITHDRAW_ERROR;
+exports.Graph = Graph;
+exports.ILink = ILink;
+exports.INode = INode;
+exports.ITopics = ITopics;
+exports.MAX_ADDRESS_LENGTH = MAX_ADDRESS_LENGTH;
+exports.MAX_WITHDRAW_ERROR_LENGTH = MAX_WITHDRAW_ERROR_LENGTH;
+exports.Networks = Networks;
+exports.Providers = Providers;
+exports.Status = Status;
+exports.TOPICS = TOPICS;
+exports.Type = Type;
+exports.WRAP_AUTH_ACTION = WRAP_AUTH_ACTION;
+exports.WRAP_CONTRACT = WRAP_CONTRACT;
+exports.accountParser = accountParser;
+exports.accountRamDeltaParser = accountRamDeltaParser;
+exports.actParser = actParser;
+exports.actionTraceParser = actionTraceParser;
+exports.addressParser = addressParser;
+exports.applyDiscountToFee = applyDiscountToFee;
+exports.authorizationParser = authorizationParser;
+exports.authorizationsParser = authorizationsParser;
+exports.baseActionParser = baseActionParser;
+exports.baseActionSerializedParser = baseActionSerializedParser;
+exports.bloksRatesParser = bloksRatesParser;
+exports.chronicleTransactionParser = chronicleTransactionParser;
+exports.compute_liquidity = compute_liquidity;
+exports.compute_transfer = compute_transfer;
+exports.compute_transfer_curve = compute_transfer_curve;
+exports.createAbstractAuthParser = createAbstractAuthParser;
+exports.dailyParser = dailyParser;
+exports.dbHistoryTransactionParser = dbHistoryTransactionParser;
+exports.dbMarketParser = dbMarketParser;
+exports.depositBodyParser = depositBodyParser;
+exports.depthParser = depthParser;
+exports.exchangeRateParser = exchangeRateParser;
+exports.exchangeRatesParser = exchangeRatesParser;
+exports.explorerLinkByChain = explorerLinkByChain;
+exports.fillType = fillType;
+exports.generateAddressBodyParser = generateAddressBodyParser;
+exports.generateAddressResponse = generateAddressResponse;
+exports.generateAuthActionsBaseParser = generateAuthActionsBaseParser;
+exports.generateAuthParser = generateAuthParser;
+exports.getDailyResponseParser = getDailyResponseParser;
+exports.getDepthParser = getDepthParser;
+exports.getDepthResponseParser = getDepthResponseParser;
+exports.getHistoryActionsParser = getHistoryActionsParser;
+exports.getHistoryActionsResponseParser = getHistoryActionsResponseParser;
+exports.getHistoryTransactionResponseParser = getHistoryTransactionResponseParser;
+exports.getHistoryTransfersParser = getHistoryTransfersParser;
+exports.getHistoryTransfersResponseParser = getHistoryTransfersResponseParser;
+exports.getLeaderboardParser = getLeaderboardParser;
+exports.getLeaderboardResponseParser = getLeaderboardResponseParser;
+exports.getMarketsResponseParser = getMarketsResponseParser;
+exports.getOhlcvParser = getOhlcvParser;
+exports.getOhlcvResponseParser = getOhlcvResponseParser;
+exports.getOpenOrdersBalancesResponseParser = getOpenOrdersBalancesResponseParser;
+exports.getOpenOrdersParser = getOpenOrdersParser;
+exports.getOpenOrdersResponseParser = getOpenOrdersResponseParser;
+exports.getOrderHistoryParser = getOrderHistoryParser;
+exports.getOrderHistoryResponseParser = getOrderHistoryResponseParser;
+exports.getOrderLifecycleParser = getOrderLifecycleParser;
+exports.getOrderLifecycleResponseParser = getOrderLifecycleResponseParser;
+exports.getReferralTotalsParser = getReferralTotalsParser;
+exports.getReferralTotalsResponseParser = getReferralTotalsResponseParser;
+exports.getReferralsParser = getReferralsParser;
+exports.getReferralsResponseParser = getReferralsResponseParser;
+exports.getSyncResponseParser = getSyncResponseParser;
+exports.getTradeHistoryParser = getTradeHistoryParser;
+exports.getTradeHistoryResponseParser = getTradeHistoryResponseParser;
+exports.getTradesParser = getTradesParser;
+exports.getTradesResponseParser = getTradesResponseParser;
+exports.historyActionParser = historyActionParser;
+exports.historyPartialParser = historyPartialParser;
+exports.historyTransactionParser = historyTransactionParser;
+exports.historyTransferParser = historyTransferParser;
+exports.initializeCoins = initializeCoins;
+exports.initializeConstants = initializeConstants;
+exports.isInputInvalid = isInputInvalid;
+exports.isSameToken = isSameToken;
+exports.leaderboardParser = leaderboardParser;
+exports.logStatus = logStatus;
+exports.loginAccountParamsV3Parser = loginAccountParamsV3Parser;
+exports.marketOpenOrdersBalanceParser = marketOpenOrdersBalanceParser;
+exports.marketParser = marketParser;
+exports.median = median;
+exports.metalTransactionParser = metalTransactionParser;
+exports.ohlcvParser = ohlcvParser;
+exports.openOrderParser = openOrderParser;
+exports.orderHistoryParser = orderHistoryParser;
+exports.orderLogParser = orderLogParser;
+exports.orderSide = orderSide;
+exports.orderType = orderType;
+exports.otcOrderResponseParser = otcOrderResponseParser;
+exports.otcQuoteBodyParser = otcQuoteBodyParser;
+exports.otcQuoteResponseParser = otcQuoteResponseParser;
+exports.postSerializeOrderParser = postSerializeOrderParser;
+exports.postSerializeOrderResponseParser = postSerializeOrderResponseParser;
+exports.postSubmitOrderParser = postSubmitOrderParser;
+exports.postSubmitOrderResponseParser = postSubmitOrderResponseParser;
+exports.protonExplorerTxUrl = protonExplorerTxUrl;
+exports.rateParser = rateParser;
+exports.receiptParser = receiptParser;
+exports.refferalParser = refferalParser;
+exports.refferalTotalParser = refferalTotalParser;
+exports.similarChains = similarChains;
+exports.singleActionTransactionParser = singleActionTransactionParser;
+exports.sortDirectionEnum = sortDirectionEnum;
+exports.syncParser = syncParser;
+exports.traceParser = traceParser;
+exports.tradeLogParser = tradeLogParser;
+exports.tradeParser = tradeParser;
+exports.validateWithdrawAddress = validateWithdrawAddress;
+exports.validateWithdrawMemo = validateWithdrawMemo;
+exports.webauthActionParser = webauthActionParser;
+exports.withdrawBodyBaseAction = withdrawBodyBaseAction;
+exports.withdrawBodyParser = withdrawBodyParser;
+exports.withdrawErrorMessage = withdrawErrorMessage;
+exports.withdrawHistoryMetalResponseParser = withdrawHistoryMetalResponseParser;
+exports.withdrawHistoryMetalSwapParser = withdrawHistoryMetalSwapParser;
+exports.withdrawMetalResponseParser = withdrawMetalResponseParser;
+exports.withdrawalFeeQuoteParser = withdrawalFeeQuoteParser;
+exports.wrapParser = wrapParser;
+exports.wrapSetConfParser = wrapSetConfParser;
+exports.wrapStartParser = wrapStartParser;