@swapkit/helpers 1.0.0-rc.9 → 1.0.0-rc.91

package/dist/index.js

@@ -0,0 +1,2099 @@
+var __require = ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/types/abis/erc20.ts
+var erc20ABI = [
+  { inputs: [], stateMutability: "nonpayable", type: "constructor" },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "owner", type: "address" },
+      { indexed: true, internalType: "address", name: "spender", type: "address" },
+      { indexed: false, internalType: "uint256", name: "value", type: "uint256" }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "from", type: "address" },
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "uint256", name: "value", type: "uint256" }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "", type: "address" },
+      { internalType: "address", name: "", type: "address" }
+    ],
+    name: "allowance",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "spender", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [{ internalType: "bool", name: "success", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "name",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "totalSupply",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" }
+    ],
+    name: "transfer",
+    outputs: [{ internalType: "bool", name: "success", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "from", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" }
+    ],
+    name: "transferFrom",
+    outputs: [{ internalType: "bool", name: "success", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+// src/types/abis/tcEthVault.ts
+var TCEthereumVaultAbi = [
+  {
+    inputs: [{ internalType: "address", name: "rune", type: "address" }],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: true, internalType: "address", name: "asset", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "Deposit",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "oldVault", type: "address" },
+      { indexed: true, internalType: "address", name: "newVault", type: "address" },
+      { indexed: false, internalType: "address", name: "asset", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "TransferAllowance",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "vault", type: "address" },
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "address", name: "asset", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "TransferOut",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "vault", type: "address" },
+      { indexed: false, internalType: "address", name: "target", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "address", name: "finalAsset", type: "address" },
+      { indexed: false, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amountOutMin", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "TransferOutAndCall",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "oldVault", type: "address" },
+      { indexed: true, internalType: "address", name: "newVault", type: "address" },
+      {
+        components: [
+          { internalType: "address", name: "asset", type: "address" },
+          { internalType: "uint256", name: "amount", type: "uint256" }
+        ],
+        indexed: false,
+        internalType: "struct THORChain_Router.Coin[]",
+        name: "coins",
+        type: "tuple[]"
+      },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "VaultTransfer",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "RUNE",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "vault", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "deposit",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "vault", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" },
+      { internalType: "uint256", name: "expiration", type: "uint256" }
+    ],
+    name: "depositWithExpiry",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "router", type: "address" },
+      { internalType: "address payable", name: "asgard", type: "address" },
+      {
+        components: [
+          { internalType: "address", name: "asset", type: "address" },
+          { internalType: "uint256", name: "amount", type: "uint256" }
+        ],
+        internalType: "struct THORChain_Router.Coin[]",
+        name: "coins",
+        type: "tuple[]"
+      },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "returnVaultAssets",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "router", type: "address" },
+      { internalType: "address", name: "newVault", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "transferAllowance",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "to", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "transferOut",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "aggregator", type: "address" },
+      { internalType: "address", name: "finalToken", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "amountOutMin", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "transferOutAndCall",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "vault", type: "address" },
+      { internalType: "address", name: "token", type: "address" }
+    ],
+    name: "vaultAllowance",
+    outputs: [{ internalType: "uint256", name: "amount", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var TCAvalancheDepositABI = [
+  { inputs: [], stateMutability: "nonpayable", type: "constructor" },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: true, internalType: "address", name: "asset", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "Deposit",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "oldVault", type: "address" },
+      { indexed: true, internalType: "address", name: "newVault", type: "address" },
+      { indexed: false, internalType: "address", name: "asset", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "TransferAllowance",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "vault", type: "address" },
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "address", name: "asset", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "TransferOut",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "vault", type: "address" },
+      { indexed: false, internalType: "address", name: "target", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "address", name: "finalAsset", type: "address" },
+      { indexed: false, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amountOutMin", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "TransferOutAndCall",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "oldVault", type: "address" },
+      { indexed: true, internalType: "address", name: "newVault", type: "address" },
+      {
+        components: [
+          { internalType: "address", name: "asset", type: "address" },
+          { internalType: "uint256", name: "amount", type: "uint256" }
+        ],
+        indexed: false,
+        internalType: "struct AvaxRouter.Coin[]",
+        name: "coins",
+        type: "tuple[]"
+      },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "VaultTransfer",
+    type: "event"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "vault", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "deposit",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "vault", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" },
+      { internalType: "uint256", name: "expiration", type: "uint256" }
+    ],
+    name: "depositWithExpiry",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "router", type: "address" },
+      { internalType: "address payable", name: "asgard", type: "address" },
+      {
+        components: [
+          { internalType: "address", name: "asset", type: "address" },
+          { internalType: "uint256", name: "amount", type: "uint256" }
+        ],
+        internalType: "struct AvaxRouter.Coin[]",
+        name: "coins",
+        type: "tuple[]"
+      },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "returnVaultAssets",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "router", type: "address" },
+      { internalType: "address", name: "newVault", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "transferAllowance",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "to", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "transferOut",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "target", type: "address" },
+      { internalType: "address", name: "finalToken", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "amountOutMin", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "transferOutAndCall",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "vault", type: "address" },
+      { internalType: "address", name: "token", type: "address" }
+    ],
+    name: "vaultAllowance",
+    outputs: [{ internalType: "uint256", name: "amount", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var TCBscDepositABI = [
+  { inputs: [], stateMutability: "nonpayable", type: "constructor" },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: true, internalType: "address", name: "asset", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "Deposit",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "oldVault", type: "address" },
+      { indexed: true, internalType: "address", name: "newVault", type: "address" },
+      { indexed: false, internalType: "address", name: "asset", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "TransferAllowance",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "vault", type: "address" },
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "address", name: "asset", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "TransferOut",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "vault", type: "address" },
+      { indexed: false, internalType: "address", name: "target", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" },
+      { indexed: false, internalType: "address", name: "finalAsset", type: "address" },
+      { indexed: false, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amountOutMin", type: "uint256" },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "TransferOutAndCall",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "oldVault", type: "address" },
+      { indexed: true, internalType: "address", name: "newVault", type: "address" },
+      {
+        components: [
+          { internalType: "address", name: "asset", type: "address" },
+          { internalType: "uint256", name: "amount", type: "uint256" }
+        ],
+        indexed: false,
+        internalType: "struct THORChain_Router.Coin[]",
+        name: "coins",
+        type: "tuple[]"
+      },
+      { indexed: false, internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "VaultTransfer",
+    type: "event"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "vault", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" },
+      { internalType: "uint256", name: "expiration", type: "uint256" }
+    ],
+    name: "depositWithExpiry",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "router", type: "address" },
+      { internalType: "address payable", name: "asgard", type: "address" },
+      {
+        components: [
+          { internalType: "address", name: "asset", type: "address" },
+          { internalType: "uint256", name: "amount", type: "uint256" }
+        ],
+        internalType: "struct THORChain_Router.Coin[]",
+        name: "coins",
+        type: "tuple[]"
+      },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "returnVaultAssets",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "router", type: "address" },
+      { internalType: "address", name: "newVault", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "transferAllowance",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "to", type: "address" },
+      { internalType: "address", name: "asset", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "transferOut",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address payable", name: "target", type: "address" },
+      { internalType: "address", name: "finalToken", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "amountOutMin", type: "uint256" },
+      { internalType: "string", name: "memo", type: "string" }
+    ],
+    name: "transferOutAndCall",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "vault", type: "address" },
+      { internalType: "address", name: "token", type: "address" }
+    ],
+    name: "vaultAllowance",
+    outputs: [{ internalType: "uint256", name: "amount", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+// src/types/network.ts
+var RPCUrl;
+(function(RPCUrl2) {
+  RPCUrl2["Arbitrum"] = "https://arb1.arbitrum.io/rpc";
+  RPCUrl2["Avalanche"] = "https://node-router.thorswap.net/avalanche-c";
+  RPCUrl2["Binance"] = "";
+  RPCUrl2["BinanceSmartChain"] = "https://bsc-dataseed.binance.org";
+  RPCUrl2["Bitcoin"] = "https://node-router.thorswap.net/bitcoin";
+  RPCUrl2["BitcoinCash"] = "https://node-router.thorswap.net/bitcoin-cash";
+  RPCUrl2["Chainflip"] = "wss://mainnet-archive.chainflip.io";
+  RPCUrl2["Cosmos"] = "https://node-router.thorswap.net/cosmos/rpc";
+  RPCUrl2["Dash"] = "https://node-router.thorswap.net/dash";
+  RPCUrl2["Dogecoin"] = "https://node-router.thorswap.net/dogecoin";
+  RPCUrl2["Ethereum"] = "https://node-router.thorswap.net/ethereum";
+  RPCUrl2["Kujira"] = "https://rpc-kujira.synergynodes.com/";
+  RPCUrl2["Litecoin"] = "https://node-router.thorswap.net/litecoin";
+  RPCUrl2["Maya"] = "https://tendermint.mayachain.info";
+  RPCUrl2["MayaStagenet"] = "https://stagenet.tendermint.mayachain.info";
+  RPCUrl2["Optimism"] = "https://mainnet.optimism.io";
+  RPCUrl2["Polkadot"] = "wss://rpc.polkadot.io";
+  RPCUrl2["Polygon"] = "https://polygon-rpc.com";
+  RPCUrl2["THORChain"] = "https://rpc.thorswap.net";
+  RPCUrl2["THORChainStagenet"] = "https://stagenet-rpc.ninerealms.com";
+})(RPCUrl || (RPCUrl = {}));
+var ExplorerUrl;
+(function(ExplorerUrl2) {
+  ExplorerUrl2["Arbitrum"] = "https://arbiscan.io";
+  ExplorerUrl2["Avalanche"] = "https://snowtrace.io";
+  ExplorerUrl2["Binance"] = "https://explorer.binance.org";
+  ExplorerUrl2["BinanceSmartChain"] = "https://bscscan.com";
+  ExplorerUrl2["Bitcoin"] = "https://blockchair.com/bitcoin";
+  ExplorerUrl2["BitcoinCash"] = "https://www.blockchair.com/bitcoin-cash";
+  ExplorerUrl2["Chainflip"] = "https://explorer.polkascan.io/polkadot";
+  ExplorerUrl2["Cosmos"] = "https://www.mintscan.io/cosmos";
+  ExplorerUrl2["Dash"] = "https://blockchair.com/dash";
+  ExplorerUrl2["Dogecoin"] = "https://blockchair.com/dogecoin";
+  ExplorerUrl2["Ethereum"] = "https://etherscan.io";
+  ExplorerUrl2["Kujira"] = "https://finder.kujira.network/kaiyo-1";
+  ExplorerUrl2["Litecoin"] = "https://blockchair.com/litecoin";
+  ExplorerUrl2["Maya"] = "https://www.mayascan.org";
+  ExplorerUrl2["Optimism"] = "https://optimistic.etherscan.io";
+  ExplorerUrl2["Polkadot"] = "https://polkadot.subscan.io/";
+  ExplorerUrl2["Polygon"] = "https://polygonscan.com";
+  ExplorerUrl2["THORChain"] = "https://runescan.io";
+})(ExplorerUrl || (ExplorerUrl = {}));
+
+// src/types/chains.ts
+var Chain;
+(function(Chain2) {
+  Chain2["Arbitrum"] = "ARB";
+  Chain2["Avalanche"] = "AVAX";
+  Chain2["Binance"] = "BNB";
+  Chain2["BinanceSmartChain"] = "BSC";
+  Chain2["Bitcoin"] = "BTC";
+  Chain2["BitcoinCash"] = "BCH";
+  Chain2["Cosmos"] = "GAIA";
+  Chain2["Dash"] = "DASH";
+  Chain2["Dogecoin"] = "DOGE";
+  Chain2["Ethereum"] = "ETH";
+  Chain2["Kujira"] = "KUJI";
+  Chain2["Litecoin"] = "LTC";
+  Chain2["Maya"] = "MAYA";
+  Chain2["Optimism"] = "OP";
+  Chain2["Polkadot"] = "DOT";
+  Chain2["Chainflip"] = "FLIP";
+  Chain2["Polygon"] = "MATIC";
+  Chain2["THORChain"] = "THOR";
+})(Chain || (Chain = {}));
+var ChainId;
+(function(ChainId2) {
+  ChainId2["Arbitrum"] = "42161";
+  ChainId2["ArbitrumHex"] = "0xa4b1";
+  ChainId2["Avalanche"] = "43114";
+  ChainId2["AvalancheHex"] = "0xa86a";
+  ChainId2["Binance"] = "Binance-Chain-Tigris";
+  ChainId2["BinanceSmartChain"] = "56";
+  ChainId2["BinanceSmartChainHex"] = "0x38";
+  ChainId2["Bitcoin"] = "bitcoin";
+  ChainId2["BitcoinCash"] = "bitcoincash";
+  ChainId2["Chainflip"] = "chainflip";
+  ChainId2["Cosmos"] = "cosmoshub-4";
+  ChainId2["Dash"] = "dash";
+  ChainId2["Dogecoin"] = "dogecoin";
+  ChainId2["Kujira"] = "kaiyo-1";
+  ChainId2["Ethereum"] = "1";
+  ChainId2["EthereumHex"] = "0x1";
+  ChainId2["Litecoin"] = "litecoin";
+  ChainId2["Maya"] = "mayachain-mainnet-v1";
+  ChainId2["MayaStagenet"] = "mayachain-stagenet-v1";
+  ChainId2["Optimism"] = "10";
+  ChainId2["OptimismHex"] = "0xa";
+  ChainId2["Polkadot"] = "polkadot";
+  ChainId2["Polygon"] = "137";
+  ChainId2["PolygonHex"] = "0x89";
+  ChainId2["THORChain"] = "thorchain-mainnet-v1";
+  ChainId2["THORChainStagenet"] = "thorchain-stagenet-v2";
+})(ChainId || (ChainId = {}));
+var ChainIdToChain = {
+  [ChainId.ArbitrumHex]: Chain.Arbitrum,
+  [ChainId.Arbitrum]: Chain.Arbitrum,
+  [ChainId.AvalancheHex]: Chain.Avalanche,
+  [ChainId.Avalanche]: Chain.Avalanche,
+  [ChainId.BinanceSmartChainHex]: Chain.BinanceSmartChain,
+  [ChainId.BinanceSmartChain]: Chain.BinanceSmartChain,
+  [ChainId.Binance]: Chain.Binance,
+  [ChainId.BitcoinCash]: Chain.BitcoinCash,
+  [ChainId.Bitcoin]: Chain.Bitcoin,
+  [ChainId.Chainflip]: Chain.Chainflip,
+  [ChainId.Cosmos]: Chain.Cosmos,
+  [ChainId.Dash]: Chain.Dash,
+  [ChainId.Dogecoin]: Chain.Dogecoin,
+  [ChainId.EthereumHex]: Chain.Ethereum,
+  [ChainId.Kujira]: Chain.Kujira,
+  [ChainId.Ethereum]: Chain.Ethereum,
+  [ChainId.Litecoin]: Chain.Litecoin,
+  [ChainId.MayaStagenet]: Chain.Maya,
+  [ChainId.Maya]: Chain.Maya,
+  [ChainId.OptimismHex]: Chain.Optimism,
+  [ChainId.Optimism]: Chain.Optimism,
+  [ChainId.Polkadot]: Chain.Polkadot,
+  [ChainId.PolygonHex]: Chain.Polygon,
+  [ChainId.Polygon]: Chain.Polygon,
+  [ChainId.THORChainStagenet]: Chain.THORChain,
+  [ChainId.THORChain]: Chain.THORChain
+};
+var chainNames = Object.keys(Chain);
+var chains = Object.values(Chain);
+var BaseDecimal;
+(function(BaseDecimal2) {
+  BaseDecimal2[BaseDecimal2["ARB"] = 18] = "ARB";
+  BaseDecimal2[BaseDecimal2["AVAX"] = 18] = "AVAX";
+  BaseDecimal2[BaseDecimal2["BCH"] = 8] = "BCH";
+  BaseDecimal2[BaseDecimal2["BNB"] = 8] = "BNB";
+  BaseDecimal2[BaseDecimal2["BSC"] = 18] = "BSC";
+  BaseDecimal2[BaseDecimal2["BTC"] = 8] = "BTC";
+  BaseDecimal2[BaseDecimal2["DASH"] = 8] = "DASH";
+  BaseDecimal2[BaseDecimal2["DOGE"] = 8] = "DOGE";
+  BaseDecimal2[BaseDecimal2["DOT"] = 10] = "DOT";
+  BaseDecimal2[BaseDecimal2["ETH"] = 18] = "ETH";
+  BaseDecimal2[BaseDecimal2["FLIP"] = 18] = "FLIP";
+  BaseDecimal2[BaseDecimal2["GAIA"] = 6] = "GAIA";
+  BaseDecimal2[BaseDecimal2["KUJI"] = 6] = "KUJI";
+  BaseDecimal2[BaseDecimal2["LTC"] = 8] = "LTC";
+  BaseDecimal2[BaseDecimal2["MATIC"] = 18] = "MATIC";
+  BaseDecimal2[BaseDecimal2["MAYA"] = 10] = "MAYA";
+  BaseDecimal2[BaseDecimal2["OP"] = 18] = "OP";
+  BaseDecimal2[BaseDecimal2["THOR"] = 8] = "THOR";
+  BaseDecimal2[BaseDecimal2["ZEC"] = 8] = "ZEC";
+})(BaseDecimal || (BaseDecimal = {}));
+var SubstrateChains = [Chain.Polkadot, Chain.Chainflip];
+var EVMChains = [
+  Chain.Ethereum,
+  Chain.Avalanche,
+  Chain.BinanceSmartChain,
+  Chain.Arbitrum,
+  Chain.Optimism,
+  Chain.Polygon
+];
+var UTXOChains = [
+  Chain.Bitcoin,
+  Chain.BitcoinCash,
+  Chain.Dash,
+  Chain.Dogecoin,
+  Chain.Litecoin
+];
+var CosmosChains = [
+  Chain.Cosmos,
+  Chain.THORChain,
+  Chain.Binance,
+  Chain.Maya,
+  Chain.Kujira
+];
+var TCSupportedChains = [
+  Chain.Avalanche,
+  Chain.Binance,
+  Chain.BinanceSmartChain,
+  Chain.Bitcoin,
+  Chain.BitcoinCash,
+  Chain.Cosmos,
+  Chain.Dogecoin,
+  Chain.Ethereum,
+  Chain.Litecoin,
+  Chain.THORChain
+];
+var MAYASupportedChains = [
+  Chain.Arbitrum,
+  Chain.Dash,
+  Chain.Ethereum,
+  Chain.Kujira,
+  Chain.Maya,
+  Chain.THORChain
+];
+var ChainToChainName = chains.reduce((acc, chain) => {
+  const chainName = chainNames.find((key) => Chain[key] === chain);
+  if (chainName)
+    acc[chain] = chainName;
+  return acc;
+}, {});
+var ChainToChainId = chains.reduce((acc, chain) => {
+  acc[chain] = ChainId[ChainToChainName[chain]];
+  return acc;
+}, {});
+var ChainToRPC = chains.reduce((acc, chain) => {
+  acc[chain] = RPCUrl[ChainToChainName[chain]];
+  return acc;
+}, {});
+var ChainToHexChainId = chains.reduce((acc, chain) => {
+  const chainString = `${ChainToChainName[chain]}Hex`;
+  acc[chain] = ChainId[chainString];
+  return acc;
+}, {});
+var ChainToExplorerUrl = chains.reduce((acc, chain) => {
+  acc[chain] = ExplorerUrl[ChainToChainName[chain]];
+  return acc;
+}, {});
+// src/types/commonTypes.ts
+var QuoteMode;
+(function(QuoteMode2) {
+  QuoteMode2["TC_SUPPORTED_TO_TC_SUPPORTED"] = "TC-TC";
+  QuoteMode2["TC_SUPPORTED_TO_ETH"] = "TC-ERC20";
+  QuoteMode2["TC_SUPPORTED_TO_AVAX"] = "TC-ARC20";
+  QuoteMode2["TC_SUPPORTED_TO_BSC"] = "TC-BEP20";
+  QuoteMode2["ETH_TO_TC_SUPPORTED"] = "ERC20-TC";
+  QuoteMode2["ETH_TO_ETH"] = "ERC20-ERC20";
+  QuoteMode2["ETH_TO_AVAX"] = "ERC20-ARC20";
+  QuoteMode2["ETH_TO_BSC"] = "ERC20-BEP20";
+  QuoteMode2["AVAX_TO_TC_SUPPORTED"] = "ARC20-TC";
+  QuoteMode2["AVAX_TO_ETH"] = "ARC20-ERC20";
+  QuoteMode2["AVAX_TO_AVAX"] = "ARC20-ARC20";
+  QuoteMode2["AVAX_TO_BSC"] = "ARC20-BEP20";
+  QuoteMode2["BSC_TO_TC_SUPPORTED"] = "BEP20-TC";
+  QuoteMode2["BSC_TO_ETH"] = "BEP20-ERC20";
+  QuoteMode2["BSC_TO_AVAX"] = "BEP20-ARC20";
+  QuoteMode2["BSC_TO_BSC"] = "BEP20-BEP20";
+})(QuoteMode || (QuoteMode = {}));
+var AGG_SWAP = [QuoteMode.ETH_TO_ETH, QuoteMode.AVAX_TO_AVAX, QuoteMode.BSC_TO_BSC];
+var SWAP_IN = [
+  QuoteMode.ETH_TO_TC_SUPPORTED,
+  QuoteMode.ETH_TO_AVAX,
+  QuoteMode.ETH_TO_BSC,
+  QuoteMode.AVAX_TO_TC_SUPPORTED,
+  QuoteMode.AVAX_TO_ETH,
+  QuoteMode.AVAX_TO_BSC,
+  QuoteMode.BSC_TO_TC_SUPPORTED,
+  QuoteMode.BSC_TO_ETH,
+  QuoteMode.BSC_TO_AVAX
+];
+var SWAP_OUT = [
+  QuoteMode.TC_SUPPORTED_TO_TC_SUPPORTED,
+  QuoteMode.TC_SUPPORTED_TO_ETH,
+  QuoteMode.TC_SUPPORTED_TO_AVAX,
+  QuoteMode.TC_SUPPORTED_TO_BSC
+];
+// src/types/derivationPath.ts
+var ContractAddress;
+(function(ContractAddress2) {
+  ContractAddress2["ARB"] = "0x0000000000000000000000000000000000000000";
+  ContractAddress2["AVAX"] = "0x0000000000000000000000000000000000000000";
+  ContractAddress2["ETH"] = "0x0000000000000000000000000000000000000000";
+  ContractAddress2["BSC"] = "0x0000000000000000000000000000000000000000";
+  ContractAddress2["MATIC"] = "0x0000000000000000000000000000000000001010";
+  ContractAddress2["OP"] = "0x4200000000000000000000000000000000000042";
+})(ContractAddress || (ContractAddress = {}));
+var DerivationPath;
+(function(DerivationPath2) {
+  DerivationPath2["ARB"] = "m/44'/60'/0'/0";
+  DerivationPath2["AVAX"] = "m/44'/60'/0'/0";
+  DerivationPath2["BCH"] = "m/44'/145'/0'/0";
+  DerivationPath2["BNB"] = "m/44'/714'/0'/0";
+  DerivationPath2["BSC"] = "m/44'/60'/0'/0";
+  DerivationPath2["BTC"] = "m/84'/0'/0'/0";
+  DerivationPath2["DASH"] = "m/44'/5'/0'/0";
+  DerivationPath2["DOGE"] = "m/44'/3'/0'/0";
+  DerivationPath2["DOT"] = "////";
+  DerivationPath2["ETH"] = "m/44'/60'/0'/0";
+  DerivationPath2["FLIP"] = "////";
+  DerivationPath2["GAIA"] = "m/44'/118'/0'/0";
+  DerivationPath2["KUJI"] = "m/44'/118'/0'/0";
+  DerivationPath2["LTC"] = "m/84'/2'/0'/0";
+  DerivationPath2["MATIC"] = "m/44'/60'/0'/0";
+  DerivationPath2["MAYA"] = "m/44'/931'/0'/0";
+  DerivationPath2["OP"] = "m/44'/60'/0'/0";
+  DerivationPath2["THOR"] = "m/44'/931'/0'/0";
+})(DerivationPath || (DerivationPath = {}));
+var NetworkDerivationPath = {
+  ARB: [44, 60, 0, 0, 0],
+  AVAX: [44, 60, 0, 0, 0],
+  BCH: [44, 145, 0, 0, 0],
+  BNB: [44, 714, 0, 0, 0],
+  BSC: [44, 60, 0, 0, 0],
+  BTC: [84, 0, 0, 0, 0],
+  DASH: [44, 5, 0, 0, 0],
+  DOGE: [44, 3, 0, 0, 0],
+  ETH: [44, 60, 0, 0, 0],
+  GAIA: [44, 118, 0, 0, 0],
+  KUJI: [44, 118, 0, 0, 0],
+  LTC: [84, 2, 0, 0, 0],
+  MATIC: [44, 60, 0, 0, 0],
+  MAYA: [44, 931, 0, 0, 0],
+  OP: [44, 60, 0, 0, 0],
+  THOR: [44, 931, 0, 0, 0],
+  DOT: [0, 0, 0, 0, 0],
+  FLIP: [0, 0, 0, 0, 0]
+};
+// src/types/wallet.ts
+var WalletOption;
+(function(WalletOption2) {
+  WalletOption2["KEYSTORE"] = "KEYSTORE";
+  WalletOption2["KEEPKEY"] = "KEEPKEY";
+  WalletOption2["XDEFI"] = "XDEFI";
+  WalletOption2["METAMASK"] = "METAMASK";
+  WalletOption2["COINBASE_WEB"] = "COINBASE_WEB";
+  WalletOption2["COINBASE_MOBILE"] = "COINBASE_MOBILE";
+  WalletOption2["TREZOR"] = "TREZOR";
+  WalletOption2["TRUSTWALLET_WEB"] = "TRUSTWALLET_WEB";
+  WalletOption2["LEDGER"] = "LEDGER";
+  WalletOption2["KEPLR"] = "KEPLR";
+  WalletOption2["OKX"] = "OKX";
+  WalletOption2["OKX_MOBILE"] = "OKX_MOBILE";
+  WalletOption2["BRAVE"] = "BRAVE";
+  WalletOption2["WALLETCONNECT"] = "WALLETCONNECT";
+})(WalletOption || (WalletOption = {}));
+var LedgerErrorCode;
+(function(LedgerErrorCode2) {
+  LedgerErrorCode2[LedgerErrorCode2["NoError"] = 36864] = "NoError";
+  LedgerErrorCode2[LedgerErrorCode2["LockedDevice"] = 21781] = "LockedDevice";
+  LedgerErrorCode2[LedgerErrorCode2["TC_NotFound"] = 65535] = "TC_NotFound";
+})(LedgerErrorCode || (LedgerErrorCode = {}));
+// src/types/sdk.ts
+var FeeOption;
+(function(FeeOption2) {
+  FeeOption2["Average"] = "average";
+  FeeOption2["Fast"] = "fast";
+  FeeOption2["Fastest"] = "fastest";
+})(FeeOption || (FeeOption = {}));
+var ApproveMode;
+(function(ApproveMode2) {
+  ApproveMode2["Approve"] = "approve";
+  ApproveMode2["CheckOnly"] = "checkOnly";
+})(ApproveMode || (ApproveMode = {}));
+var MemoType;
+(function(MemoType2) {
+  MemoType2["BOND"] = "BOND";
+  MemoType2["DEPOSIT"] = "+";
+  MemoType2["LEAVE"] = "LEAVE";
+  MemoType2["THORNAME_REGISTER"] = "~";
+  MemoType2["UNBOND"] = "UNBOND";
+  MemoType2["WITHDRAW"] = "-";
+  MemoType2["OPEN_LOAN"] = "$+";
+  MemoType2["CLOSE_LOAN"] = "$-";
+})(MemoType || (MemoType = {}));
+// src/modules/requestClient.ts
+import ky from "ky";
+function setRequestClientConfig({ apiKey, ...config }) {
+  kyClient = ky.create({
+    ...config,
+    headers: { ...defaultRequestHeaders, ...config.headers, "x-api-key": apiKey }
+  });
+}
+var getKyClient = function() {
+  if (kyClient)
+    return kyClient;
+  kyClient = ky.create({ headers: defaultRequestHeaders });
+  return kyClient;
+};
+var kyClient;
+var defaultRequestHeaders = typeof window !== "undefined" ? {} : { referrer: "https://sk.thorswap.net", referer: "https://sk.thorswap.net" };
+var RequestClient = {
+  get: (url, options) => getKyClient().get(url, options).json(),
+  post: (url, options) => getKyClient().post(url, options).json()
+};
+
+// src/helpers/asset.ts
+async function findAssetBy(params) {
+  const tokenPackages = await import("@swapkit/tokens");
+  for (const tokenList of Object.values(tokenPackages)) {
+    for (const { identifier, chain: tokenChain, ...rest } of tokenList.tokens) {
+      if ("identifier" in params && identifier === params.identifier) {
+        return identifier;
+      }
+      if ("address" in rest && "chain" in params && tokenChain === params.chain && rest.address.toLowerCase() === params.contract.toLowerCase())
+        return identifier;
+    }
+  }
+  return;
+}
+var getDecimalMethodHex = "0x313ce567";
+var getContractDecimals = async ({ chain, to }) => {
+  try {
+    const { result } = await RequestClient.post(ChainToRPC[chain], {
+      headers: {
+        accept: "*/*",
+        "content-type": "application/json",
+        "cache-control": "no-cache"
+      },
+      body: JSON.stringify({
+        id: 44,
+        jsonrpc: "2.0",
+        method: "eth_call",
+        params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, "latest"]
+      })
+    });
+    return Number.parseInt(BigInt(result || BaseDecimal[chain]).toString());
+  } catch (error) {
+    console.error(error);
+    return BaseDecimal[chain];
+  }
+};
+var getETHAssetDecimal = (symbol) => {
+  if (symbol === Chain.Ethereum)
+    return BaseDecimal.ETH;
+  const [, address] = symbol.split("-");
+  return address?.startsWith("0x") ? getContractDecimals({ chain: Chain.Ethereum, to: address }) : BaseDecimal.ETH;
+};
+var getAVAXAssetDecimal = (symbol) => {
+  const [, address] = symbol.split("-");
+  return address?.startsWith("0x") ? getContractDecimals({ chain: Chain.Avalanche, to: address.toLowerCase() }) : BaseDecimal.AVAX;
+};
+var getBSCAssetDecimal = (symbol) => {
+  if (symbol === Chain.BinanceSmartChain)
+    return BaseDecimal.BSC;
+  return BaseDecimal.BSC;
+};
+var getDecimal = ({ chain, symbol }) => {
+  switch (chain) {
+    case Chain.Ethereum:
+      return getETHAssetDecimal(symbol);
+    case Chain.Avalanche:
+      return getAVAXAssetDecimal(symbol);
+    case Chain.BinanceSmartChain:
+      return getBSCAssetDecimal(symbol);
+    default:
+      return BaseDecimal[chain];
+  }
+};
+var isGasAsset = ({ chain, symbol }) => {
+  switch (chain) {
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+      return symbol === "ETH";
+    case Chain.Maya:
+      return symbol === "CACAO";
+    case Chain.Kujira:
+      return symbol === "KUJI";
+    case Chain.Cosmos:
+      return symbol === "ATOM";
+    case Chain.Polygon:
+      return symbol === "MATIC";
+    case Chain.BinanceSmartChain:
+      return symbol === "BNB";
+    case Chain.THORChain:
+      return symbol === "RUNE";
+    default:
+      return symbol === chain;
+  }
+};
+var getCommonAssetInfo = (assetString) => {
+  switch (assetString) {
+    case `${Chain.Ethereum}.THOR`:
+      return { identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044", decimal: 18 };
+    case `${Chain.Ethereum}.vTHOR`:
+      return { identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d", decimal: 18 };
+    case Chain.Cosmos:
+      return { identifier: "GAIA.ATOM", decimal: BaseDecimal[assetString] };
+    case Chain.THORChain:
+      return { identifier: "THOR.RUNE", decimal: BaseDecimal[assetString] };
+    case Chain.BinanceSmartChain:
+      return { identifier: "BSC.BNB", decimal: BaseDecimal[assetString] };
+    case Chain.Maya:
+      return { identifier: "MAYA.CACAO", decimal: BaseDecimal.MAYA };
+    case `${Chain.Maya}.MAYA`:
+      return { identifier: "MAYA.MAYA", decimal: 4 };
+    case `${Chain.Kujira}.USK`:
+      return { identifier: `${Chain.Kujira}.USK`, decimal: 6 };
+    default:
+      return { identifier: `${assetString}.${assetString}`, decimal: BaseDecimal[assetString] };
+  }
+};
+var getAssetType = ({ chain, symbol }) => {
+  if (symbol.includes("/"))
+    return "Synth";
+  switch (chain) {
+    case Chain.Cosmos:
+      return symbol === "ATOM" ? "Native" : Chain.Cosmos;
+    case Chain.Kujira:
+      return symbol === Chain.Kujira ? "Native" : Chain.Kujira;
+    case Chain.Binance:
+      return symbol === Chain.Binance ? "Native" : "BEP2";
+    case Chain.BinanceSmartChain:
+      return symbol === Chain.Binance ? "Native" : "BEP20";
+    case Chain.Ethereum:
+      return symbol === Chain.Ethereum ? "Native" : "ERC20";
+    case Chain.Avalanche:
+      return symbol === Chain.Avalanche ? "Native" : Chain.Avalanche;
+    case Chain.Polygon:
+      return symbol === Chain.Polygon ? "Native" : "POLYGON";
+    case Chain.Arbitrum:
+      return [Chain.Ethereum, Chain.Arbitrum].includes(symbol) ? "Native" : "ARBITRUM";
+    case Chain.Optimism:
+      return [Chain.Ethereum, Chain.Optimism].includes(symbol) ? "Native" : "OPTIMISM";
+    default:
+      return "Native";
+  }
+};
+var assetFromString = (assetString) => {
+  const [chain, ...symbolArray] = assetString.split(".");
+  const synth = assetString.includes("/");
+  const symbol = symbolArray.join(".");
+  const ticker = symbol?.split("-")?.[0];
+  return { chain, symbol, ticker, synth };
+};
+var potentialScamRegex = new RegExp(/(.)\1{6}|\.ORG|\.NET|\.FINANCE|\.COM|WWW|HTTP|\\\\|\/\/|[\s$%:[\]]/, "gmi");
+var evmAssetHasAddress = (assetString) => {
+  const [chain, symbol] = assetString.split(".");
+  if (!EVMChains.includes(chain))
+    return true;
+  const [, address] = symbol.split("-");
+  return isGasAsset({ chain, symbol }) || !!address;
+};
+var filterAssets = (tokens2) => tokens2.filter(({ chain, value, symbol }) => {
+  const assetString = `${chain}.${symbol}`;
+  return !potentialScamRegex.test(assetString) && evmAssetHasAddress(assetString) && value !== "0";
+});
+// src/helpers/derivationPath.ts
+function getDerivationPathFor({ chain, index, type }) {
+  if (EVMChains.includes(chain)) {
+    if (type === "legacy")
+      return [44, 60, 0, index];
+    if (type === "ledgerLive")
+      return [44, 60, index, 0, 0];
+    return updatedLastIndex(NetworkDerivationPath[chain], index);
+  }
+  if ([Chain.Bitcoin, Chain.Litecoin].includes(chain)) {
+    const chainId = chain === Chain.Bitcoin ? 0 : 2;
+    if (type === "nativeSegwitMiddleAccount")
+      return [84, chainId, index, 0, 0];
+    if (type === "segwit")
+      return [49, chainId, 0, 0, index];
+    if (type === "legacy")
+      return [44, chainId, 0, 0, index];
+    return updatedLastIndex(NetworkDerivationPath[chain], index);
+  }
+  return updatedLastIndex(NetworkDerivationPath[chain], index);
+}
+function getWalletFormatFor(path) {
+  const [_, purpose, chainId] = path.split("/").map((p) => Number.parseInt(p, 10));
+  if (chainId === 145)
+    ;
+  switch (purpose) {
+    case 44:
+      return "legacy";
+    case 49:
+      return "p2sh";
+    default:
+      return "bech32";
+  }
+}
+var updatedLastIndex = (path, index) => [
+  ...path.slice(0, path.length - 1),
+  index
+];
+// src/helpers/liquidity.ts
+function getAsymmetricRuneShare({
+  liquidityUnits,
+  poolUnits,
+  runeDepth
+}) {
+  const s = toTCSwapKitNumber(liquidityUnits);
+  const T = toTCSwapKitNumber(poolUnits);
+  const A = toTCSwapKitNumber(runeDepth);
+  const part1 = s.mul(A);
+  const part2 = T.mul(T).mul(2);
+  const part3 = T.mul(s).mul(2);
+  const part4 = s.mul(s);
+  const part5 = T.mul(T).mul(T);
+  const numerator = part1.mul(part2.sub(part3).add(part4));
+  return numerator.div(part5);
+}
+function getAsymmetricAssetShare({
+  liquidityUnits,
+  poolUnits,
+  assetDepth
+}) {
+  const s = toTCSwapKitNumber(liquidityUnits);
+  const T = toTCSwapKitNumber(poolUnits);
+  const A = toTCSwapKitNumber(assetDepth);
+  const part1 = s.mul(A);
+  const part2 = T.mul(T).mul(2);
+  const part3 = T.mul(s).mul(2);
+  const part4 = s.mul(s);
+  const numerator = part1.mul(part2.sub(part3).add(part4));
+  const part5 = T.mul(T).mul(T);
+  return numerator.div(part5);
+}
+function getAsymmetricRuneWithdrawAmount({
+  percent,
+  runeDepth,
+  liquidityUnits,
+  poolUnits
+}) {
+  return getAsymmetricRuneShare({ runeDepth, liquidityUnits, poolUnits }).mul(percent);
+}
+function getAsymmetricAssetWithdrawAmount({
+  percent,
+  assetDepth,
+  liquidityUnits,
+  poolUnits
+}) {
+  return getAsymmetricAssetShare({ assetDepth, liquidityUnits, poolUnits }).mul(percent);
+}
+var toTCSwapKitNumber = function(value) {
+  return SwapKitNumber.fromBigInt(BigInt(value), BaseDecimal.THOR);
+};
+function getSymmetricPoolShare({
+  liquidityUnits,
+  poolUnits,
+  runeDepth,
+  assetDepth
+}) {
+  return {
+    assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
+    runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits)
+  };
+}
+function getSymmetricWithdraw({
+  liquidityUnits,
+  poolUnits,
+  runeDepth,
+  assetDepth,
+  percent
+}) {
+  return Object.fromEntries(Object.entries(getSymmetricPoolShare({ liquidityUnits, poolUnits, runeDepth, assetDepth })).map(([name, value]) => [name, value.mul(percent)]));
+}
+function getEstimatedPoolShare({
+  runeDepth,
+  poolUnits,
+  assetDepth,
+  liquidityUnits,
+  runeAmount,
+  assetAmount
+}) {
+  const R = new SwapKitNumber({ value: runeDepth, decimal: 8 });
+  const A = new SwapKitNumber({ value: assetDepth, decimal: 8 });
+  const P = new SwapKitNumber({ value: poolUnits, decimal: 8 });
+  const runeAddAmount = new SwapKitNumber({ value: runeAmount, decimal: 8 });
+  const assetAddAmount = new SwapKitNumber({ value: assetAmount, decimal: 8 });
+  const rA = runeAddAmount.mul(A);
+  const aR = assetAddAmount.mul(R);
+  const ra = runeAddAmount.mul(assetAddAmount);
+  const RA = R.mul(A);
+  const numerator = P.mul(rA.add(aR.add(ra.mul(2))));
+  const denominator = rA.add(aR.add(RA.mul(2)));
+  const liquidityUnitsAfterAdd = numerator.div(denominator);
+  const estimatedLiquidityUnits = toTCSwapKitNumber(liquidityUnits).add(liquidityUnitsAfterAdd);
+  if (liquidityUnitsAfterAdd.getBaseValue("number") === 0) {
+    return estimatedLiquidityUnits.div(P).getBaseValue("number");
+  }
+  const newPoolUnits = P.add(estimatedLiquidityUnits);
+  return estimatedLiquidityUnits.div(newPoolUnits).getBaseValue("number");
+}
+function getLiquiditySlippage({
+  runeAmount,
+  assetAmount,
+  runeDepth,
+  assetDepth
+}) {
+  if (runeAmount === "0" || assetAmount === "0" || runeDepth === "0" || assetDepth === "0")
+    return 0;
+  const R = toTCSwapKitNumber(runeDepth);
+  const T = toTCSwapKitNumber(assetDepth);
+  const assetAddAmount = toTCSwapKitNumber(assetAmount);
+  const runeAddAmount = toTCSwapKitNumber(runeAmount);
+  const numerator = assetAddAmount.mul(R).sub(T.mul(runeAddAmount));
+  const denominator = T.mul(runeAddAmount).add(R.mul(T));
+  return Math.abs(numerator.div(denominator).getBaseValue("number"));
+}
+// src/helpers/memo.ts
+var getMemoFor = (memoType, options) => {
+  switch (memoType) {
+    case MemoType.LEAVE:
+    case MemoType.BOND: {
+      const { address } = options;
+      return `${memoType}:${address}`;
+    }
+    case MemoType.UNBOND: {
+      const { address, unbondAmount } = options;
+      return `${memoType}:${address}:${unbondAmount}`;
+    }
+    case MemoType.THORNAME_REGISTER: {
+      const { name, chain, address, owner } = options;
+      return `${memoType}:${name}:${chain}:${address}${owner ? `:${owner}` : ""}`;
+    }
+    case MemoType.DEPOSIT: {
+      const { chain, symbol, address, singleSide } = options;
+      const getPoolIdentifier = (chain2, symbol2) => {
+        switch (chain2) {
+          case Chain.Litecoin:
+            return "l";
+          case Chain.Dogecoin:
+            return "d";
+          case Chain.BitcoinCash:
+            return "c";
+          default:
+            return `${chain2}.${symbol2}`;
+        }
+      };
+      return singleSide ? `${memoType}:${chain}/${symbol}` : `${memoType}:${getPoolIdentifier(chain, symbol)}:${address || ""}`;
+    }
+    case MemoType.WITHDRAW: {
+      const { chain, ticker, symbol, basisPoints, targetAssetString, singleSide } = options;
+      const shortenedSymbol = chain === "ETH" && ticker !== "ETH" ? `${ticker}-${symbol.slice(-3)}` : symbol;
+      const target = !singleSide && targetAssetString ? `:${targetAssetString}` : "";
+      const assetDivider = singleSide ? "/" : ".";
+      return `${memoType}:${chain}${assetDivider}${shortenedSymbol}:${basisPoints}${target}`;
+    }
+    case MemoType.OPEN_LOAN:
+    case MemoType.CLOSE_LOAN: {
+      const { asset, address } = options;
+      return `${memoType}:${asset}:${address}`;
+    }
+    default:
+      return "";
+  }
+};
+// src/modules/swapKitError.ts
+var errorMessages = {
+  core_wallet_connection_not_found: 10001,
+  core_estimated_max_spendable_chain_not_supported: 10002,
+  core_extend_error: 10003,
+  core_inbound_data_not_found: 10004,
+  core_approve_asset_address_or_from_not_found: 10005,
+  core_plugin_not_found: 10006,
+  core_plugin_swap_not_found: 10007,
+  core_chain_halted: 10099,
+  core_wallet_xdefi_not_installed: 10101,
+  core_wallet_evmwallet_not_installed: 10102,
+  core_wallet_walletconnect_not_installed: 10103,
+  core_wallet_keystore_not_installed: 10104,
+  core_wallet_ledger_not_installed: 10105,
+  core_wallet_trezor_not_installed: 10106,
+  core_wallet_keplr_not_installed: 10107,
+  core_wallet_okx_not_installed: 10108,
+  core_wallet_keepkey_not_installed: 10109,
+  core_swap_invalid_params: 10200,
+  core_swap_route_not_complete: 10201,
+  core_swap_asset_not_recognized: 10202,
+  core_swap_contract_not_found: 10203,
+  core_swap_route_transaction_not_found: 10204,
+  core_swap_contract_not_supported: 10205,
+  core_swap_transaction_error: 10206,
+  core_swap_quote_mode_not_supported: 10207,
+  core_transaction_deposit_error: 10301,
+  core_transaction_create_liquidity_rune_error: 10302,
+  core_transaction_create_liquidity_asset_error: 10303,
+  core_transaction_create_liquidity_invalid_params: 10304,
+  core_transaction_add_liquidity_invalid_params: 10305,
+  core_transaction_add_liquidity_no_rune_address: 10306,
+  core_transaction_add_liquidity_rune_error: 10307,
+  core_transaction_add_liquidity_asset_error: 10308,
+  core_transaction_withdraw_error: 10309,
+  core_transaction_deposit_to_pool_error: 10310,
+  core_transaction_deposit_insufficient_funds_error: 10311,
+  core_transaction_deposit_gas_error: 10312,
+  core_transaction_invalid_sender_address: 10313,
+  core_transaction_deposit_server_error: 10314,
+  core_transaction_user_rejected: 10315,
+  wallet_ledger_connection_error: 20001,
+  wallet_ledger_connection_claimed: 20002,
+  wallet_ledger_get_address_error: 20003,
+  wallet_ledger_device_not_found: 20004,
+  wallet_ledger_device_locked: 20005,
+  chainflip_channel_error: 30001,
+  chainflip_broker_recipient_error: 30002,
+  helpers_number_different_decimals: 99101
+};
+
+class SwapKitError extends Error {
+  constructor(errorKey, sourceError) {
+    if (sourceError) {
+      console.error(sourceError, {
+        stack: sourceError?.stack,
+        message: sourceError?.message
+      });
+    }
+    super(errorKey, {
+      cause: { code: errorMessages[errorKey], message: errorKey }
+    });
+    Object.setPrototypeOf(this, SwapKitError.prototype);
+  }
+}
+
+// src/helpers/others.ts
+function getTHORNameCost(numberOfYears) {
+  if (numberOfYears < 0)
+    throw new Error("Invalid number of years");
+  return 10 + numberOfYears;
+}
+function getMAYANameCost(numberOfYears) {
+  if (numberOfYears < 0)
+    throw new Error("Invalid number of year");
+  return Math.round((10 + numberOfYears * 1.0512) * 10000000000) / 10000000000;
+}
+function derivationPathToString([network3, chainId, account, change, index]) {
+  const shortPath = typeof index !== "number";
+  return `m/${network3}'/${chainId}'/${account}'/${change}${shortPath ? "" : `/${index}`}`;
+}
+function wrapWithThrow(fn, errorKey) {
+  try {
+    return fn();
+  } catch (error) {
+    if (errorKey) {
+      throw new SwapKitError(errorKey, error);
+    }
+    return console.error(error);
+  }
+}
+// src/helpers/validators.ts
+function validateIdentifier(identifier = "") {
+  const uppercasedIdentifier = identifier.toUpperCase();
+  const [chain] = uppercasedIdentifier.split(".");
+  if (supportedChains.includes(chain))
+    return true;
+  const [synthChain] = uppercasedIdentifier.split("/");
+  if (supportedChains.includes(synthChain))
+    return true;
+  throw new Error(`Invalid identifier: ${identifier}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`);
+}
+function validateTNS(name) {
+  if (name.length > 30)
+    return false;
+  const regex = /^[a-zA-Z0-9+_-]+$/g;
+  return !!name.match(regex);
+}
+var supportedChains = [...Object.values(Chain), "TERRA"];
+// src/helpers/web3wallets.ts
+var methodsToWrap = [
+  "approve",
+  "approvedAmount",
+  "call",
+  "sendTransaction",
+  "transfer",
+  "getBalance",
+  "isApproved",
+  "approvedAmount",
+  "EIP1193SendTransaction",
+  "getFeeData",
+  "broadcastTransaction",
+  "estimateCall",
+  "estimateGasLimit",
+  "estimateGasPrices",
+  "createContractTxObject"
+];
+var wrapMethodWithNetworkSwitch = (func, provider, chainId) => async (...args) => {
+  try {
+    await switchEVMWalletNetwork(provider, chainId);
+  } catch (error) {
+    throw new Error(`Failed to switch network: ${error}`);
+  }
+  return func(...args);
+};
+var providerRequest = ({ provider, params, method }) => {
+  if (!provider?.send)
+    throw new Error("Provider not found");
+  const providerParams = params ? Array.isArray(params) ? params : [params] : [];
+  return provider.send(method, providerParams);
+};
+var prepareNetworkSwitch = ({
+  toolbox,
+  chainId,
+  provider = window.ethereum
+}) => {
+  const wrappedMethods = methodsToWrap.reduce((object, methodName) => {
+    if (!toolbox[methodName])
+      return object;
+    const method = toolbox[methodName];
+    if (typeof method !== "function")
+      return object;
+    return {
+      ...object,
+      [methodName]: wrapMethodWithNetworkSwitch(method, provider, chainId)
+    };
+  }, {});
+  return { ...toolbox, ...wrappedMethods };
+};
+var addEVMWalletNetwork = (provider, networkParams) => providerRequest({ provider, method: "wallet_addEthereumChain", params: [networkParams] });
+var switchEVMWalletNetwork = (provider, chainId = ChainId.EthereumHex) => providerRequest({ provider, method: "wallet_switchEthereumChain", params: [{ chainId }] });
+var addAccountsChangedCallback = (callback) => {
+  window.ethereum?.on("accountsChanged", () => callback());
+  window.xfi?.ethereum.on("accountsChanged", () => callback());
+};
+var getETHDefaultWallet = () => {
+  const { isTrust, isBraveWallet, __XDEFI, overrideIsMetaMask, selectedProvider } = window?.ethereum || {};
+  if (isTrust)
+    return WalletOption.TRUSTWALLET_WEB;
+  if (isBraveWallet)
+    return WalletOption.BRAVE;
+  if (overrideIsMetaMask && selectedProvider?.isCoinbaseWallet)
+    return WalletOption.COINBASE_WEB;
+  if (__XDEFI)
+    WalletOption.XDEFI;
+  return WalletOption.METAMASK;
+};
+var isDetected = (walletOption) => {
+  return listWeb3EVMWallets().includes(walletOption);
+};
+var listWeb3EVMWallets = () => {
+  const metamaskEnabled = window?.ethereum && !window.ethereum?.isBraveWallet;
+  const xdefiEnabled = window?.xfi || window?.ethereum?.__XDEFI;
+  const braveEnabled = window?.ethereum?.isBraveWallet;
+  const trustEnabled = window?.ethereum?.isTrust || window?.trustwallet;
+  const coinbaseEnabled = window?.ethereum?.overrideIsMetaMask && window?.ethereum?.selectedProvider?.isCoinbaseWallet || window?.coinbaseWalletExtension;
+  const wallets = [];
+  if (metamaskEnabled)
+    wallets.push(WalletOption.METAMASK);
+  if (xdefiEnabled)
+    wallets.push(WalletOption.XDEFI);
+  if (braveEnabled)
+    wallets.push(WalletOption.BRAVE);
+  if (trustEnabled)
+    wallets.push(WalletOption.TRUSTWALLET_WEB);
+  if (coinbaseEnabled)
+    wallets.push(WalletOption.COINBASE_WEB);
+  if (okxMobileEnabled())
+    wallets.push(WalletOption.OKX_MOBILE);
+  return wallets;
+};
+var okxMobileEnabled = () => {
+  const ua = navigator.userAgent;
+  const isIOS = /iphone|ipad|ipod|ios/i.test(ua);
+  const isAndroid = /android|XiaoMi|MiuiBrowser/i.test(ua);
+  const isMobile = isIOS || isAndroid;
+  const isOKApp = /OKApp/i.test(ua);
+  return isMobile && isOKApp;
+};
+var isWeb3Detected = () => typeof window.ethereum !== "undefined";
+// src/modules/bigIntArithmetics.ts
+function formatBigIntToSafeValue({
+  value,
+  bigIntDecimal = DEFAULT_DECIMAL,
+  decimal = DEFAULT_DECIMAL
+}) {
+  if (decimal === 0)
+    return value.toString();
+  const isNegative = value < 0n;
+  let valueString = value.toString().substring(isNegative ? 1 : 0);
+  const padLength = decimal - (valueString.length - 1);
+  if (padLength > 0) {
+    valueString = "0".repeat(padLength) + valueString;
+  }
+  const decimalIndex = valueString.length - decimal;
+  let decimalString = valueString.slice(-decimal);
+  if (Number.parseInt(decimalString[bigIntDecimal] || "0") >= 5) {
+    decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1).toString()}`;
+  } else {
+    decimalString = decimalString.substring(0, bigIntDecimal);
+  }
+  return `${isNegative ? "-" : ""}${valueString.slice(0, decimalIndex)}.${decimalString}`.replace(/\.?0*$/, "");
+}
+var toSafeValue = function(value) {
+  const parsedValue = typeof value === "number" ? numberFormatter.format(value) : getStringValue(value);
+  const splitValue = `${parsedValue}`.replaceAll(",", ".").split(".");
+  return splitValue.length > 1 ? `${splitValue.slice(0, -1).join("")}.${splitValue.at(-1)}` : splitValue[0] || "0";
+};
+var getFloatDecimals = function(value) {
+  const decimals = value.split(".")[1]?.length || 0;
+  return Math.max(decimals, DEFAULT_DECIMAL);
+};
+var getStringValue = function(param) {
+  return typeof param === "object" ? "getValue" in param ? param.getValue("string") : param.value : param;
+};
+var DEFAULT_DECIMAL = 8;
+var toMultiplier = (decimal) => 10n ** BigInt(decimal);
+var decimalFromMultiplier = (multiplier) => Math.log10(Number.parseFloat(multiplier.toString()));
+
+class BigIntArithmetics {
+  decimalMultiplier = 10n ** 8n;
+  bigIntValue = 0n;
+  decimal;
+  static fromBigInt(value, decimal) {
+    return new BigIntArithmetics({
+      decimal,
+      value: formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal })
+    });
+  }
+  static shiftDecimals({
+    value,
+    from,
+    to
+  }) {
+    return BigIntArithmetics.fromBigInt(value.getBaseValue("bigint") * toMultiplier(to) / toMultiplier(from), to);
+  }
+  constructor(params) {
+    const value = getStringValue(params);
+    const isComplex = typeof params === "object";
+    this.decimal = isComplex ? params.decimal : undefined;
+    this.decimalMultiplier = isComplex && "decimalMultiplier" in params ? params.decimalMultiplier : toMultiplier(Math.max(getFloatDecimals(toSafeValue(value)), this.decimal || 0));
+    this.#setValue(value);
+  }
+  set(value) {
+    return new this.constructor({ decimal: this.decimal, value, identifier: this.toString() });
+  }
+  add(...args) {
+    return this.#arithmetics("add", ...args);
+  }
+  sub(...args) {
+    return this.#arithmetics("sub", ...args);
+  }
+  mul(...args) {
+    return this.#arithmetics("mul", ...args);
+  }
+  div(...args) {
+    return this.#arithmetics("div", ...args);
+  }
+  gt(value) {
+    return this.#comparison("gt", value);
+  }
+  gte(value) {
+    return this.#comparison("gte", value);
+  }
+  lt(value) {
+    return this.#comparison("lt", value);
+  }
+  lte(value) {
+    return this.#comparison("lte", value);
+  }
+  eqValue(value) {
+    return this.#comparison("eqValue", value);
+  }
+  getValue(type) {
+    const value = this.formatBigIntToSafeValue(this.bigIntValue, this.decimal || decimalFromMultiplier(this.decimalMultiplier));
+    switch (type) {
+      case "number":
+        return Number(value);
+      case "string":
+        return value;
+      case "bigint":
+        return this.bigIntValue * 10n ** BigInt(this.decimal || 8n) / this.decimalMultiplier;
+    }
+  }
+  getBaseValue(type) {
+    const divisor = this.decimalMultiplier / toMultiplier(this.decimal || BaseDecimal.THOR);
+    const baseValue = this.bigIntValue / divisor;
+    switch (type) {
+      case "number":
+        return Number(baseValue);
+      case "string":
+        return baseValue.toString();
+      case "bigint":
+        return baseValue;
+    }
+  }
+  getBigIntValue(value, decimal) {
+    if (!decimal && typeof value === "object")
+      return value.bigIntValue;
+    const stringValue = getStringValue(value);
+    const safeValue = toSafeValue(stringValue);
+    if (safeValue === "0" || safeValue === "undefined")
+      return 0n;
+    return this.#toBigInt(safeValue, decimal);
+  }
+  toSignificant(significantDigits = 6) {
+    const [int, dec] = this.getValue("string").split(".");
+    const integer = int || "";
+    const decimal = dec || "";
+    const valueLength = Number.parseInt(integer) ? integer.length + decimal.length : decimal.length;
+    if (valueLength <= significantDigits) {
+      return this.getValue("string");
+    }
+    if (integer.length >= significantDigits) {
+      return integer.slice(0, significantDigits).padEnd(integer.length, "0");
+    }
+    if (Number.parseInt(integer)) {
+      return `${integer}.${decimal.slice(0, significantDigits - integer.length)}`.padEnd(significantDigits - integer.length, "0");
+    }
+    const trimmedDecimal = Number.parseInt(decimal);
+    const slicedDecimal = `${trimmedDecimal}`.slice(0, significantDigits);
+    return `0.${slicedDecimal.padStart(decimal.length - `${trimmedDecimal}`.length + slicedDecimal.length, "0")}`;
+  }
+  toFixed(fixedDigits = 6) {
+    const [int, dec] = this.getValue("string").split(".");
+    const integer = int || "";
+    const decimal = dec || "";
+    if (Number.parseInt(integer)) {
+      return `${integer}.${decimal.slice(0, fixedDigits)}`.padEnd(fixedDigits, "0");
+    }
+    const trimmedDecimal = Number.parseInt(decimal);
+    const slicedDecimal = `${trimmedDecimal}`.slice(0, fixedDigits);
+    return `0.${slicedDecimal.padStart(decimal.length - `${trimmedDecimal}`.length + slicedDecimal.length, "0")}`;
+  }
+  toAbbreviation(digits = 2) {
+    const value = this.getValue("number");
+    const abbreviations = ["", "K", "M", "B", "T", "Q", "Qi", "S"];
+    const tier = Math.floor(Math.log10(Math.abs(value)) / 3);
+    const suffix = abbreviations[tier];
+    if (!suffix)
+      return this.getValue("string");
+    const scale = 10 ** (tier * 3);
+    const scaled = value / scale;
+    return `${scaled.toFixed(digits)}${suffix}`;
+  }
+  toCurrency(currency = "$", {
+    currencyPosition = "start",
+    decimal = 2,
+    decimalSeparator = ".",
+    thousandSeparator = ","
+  } = {}) {
+    const value = this.getValue("number");
+    const [int = "", dec = ""] = value.toFixed(6).split(".");
+    const integer = int.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator);
+    const parsedValue = int || dec ? int === "0" ? `${Number.parseFloat(`0.${dec}`)}`.replace(".", decimalSeparator) : `${integer}${Number.parseInt(dec) ? `${decimalSeparator}${dec.slice(0, decimal)}` : ""}` : "0.00";
+    return `${currencyPosition === "start" ? currency : ""}${parsedValue}${currencyPosition === "end" ? currency : ""}`;
+  }
+  formatBigIntToSafeValue(value, decimal) {
+    const bigIntDecimal = decimal || this.decimal || DEFAULT_DECIMAL;
+    const decimalToUseForConversion = Math.max(bigIntDecimal, decimalFromMultiplier(this.decimalMultiplier));
+    const isNegative = value < 0n;
+    const valueString = value.toString().substring(isNegative ? 1 : 0);
+    const padLength = decimalToUseForConversion - (valueString.length - 1);
+    const parsedValueString = padLength > 0 ? "0".repeat(padLength) + valueString : valueString;
+    const decimalIndex = parsedValueString.length - decimalToUseForConversion;
+    let decimalString = parsedValueString.slice(-decimalToUseForConversion);
+    if (Number.parseInt(decimalString[bigIntDecimal] || "0") >= 5) {
+      decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1).toString()}`;
+    } else {
+      decimalString = decimalString.substring(0, bigIntDecimal);
+    }
+    return `${isNegative ? "-" : ""}${parsedValueString.slice(0, decimalIndex)}.${decimalString}`.replace(/\.?0*$/, "");
+  }
+  #arithmetics(method, ...args) {
+    const precisionDecimal = this.#retrievePrecisionDecimal(this, ...args);
+    const decimal = Math.max(precisionDecimal, decimalFromMultiplier(this.decimalMultiplier));
+    const precisionDecimalMultiplier = toMultiplier(decimal);
+    const result = args.reduce((acc, arg) => {
+      const value2 = this.getBigIntValue(arg, decimal);
+      switch (method) {
+        case "add":
+          return acc + value2;
+        case "sub":
+          return acc - value2;
+        case "mul":
+          return acc * value2 / precisionDecimalMultiplier;
+        case "div": {
+          if (value2 === 0n)
+            throw new RangeError("Division by zero");
+          return acc * precisionDecimalMultiplier / value2;
+        }
+        default:
+          return acc;
+      }
+    }, this.bigIntValue * precisionDecimalMultiplier / this.decimalMultiplier);
+    const value = formatBigIntToSafeValue({
+      bigIntDecimal: decimal,
+      decimal,
+      value: result
+    });
+    return new this.constructor({
+      decimalMultiplier: toMultiplier(decimal),
+      decimal: this.decimal,
+      value,
+      identifier: this.toString()
+    });
+  }
+  #comparison(method, ...args) {
+    const decimal = this.#retrievePrecisionDecimal(this, ...args);
+    const value = this.getBigIntValue(args[0] || "0", decimal);
+    const compareToValue = this.getBigIntValue(this, decimal);
+    switch (method) {
+      case "gt":
+        return compareToValue > value;
+      case "gte":
+        return compareToValue >= value;
+      case "lt":
+        return compareToValue < value;
+      case "lte":
+        return compareToValue <= value;
+      case "eqValue":
+        return compareToValue === value;
+    }
+  }
+  #setValue(value) {
+    const safeValue = toSafeValue(value) || "0";
+    this.bigIntValue = this.#toBigInt(safeValue);
+  }
+  #retrievePrecisionDecimal(...args) {
+    const decimals = args.map((arg) => {
+      const isObject = typeof arg === "object";
+      const value = isObject ? arg.decimal || decimalFromMultiplier(arg.decimalMultiplier) : getFloatDecimals(toSafeValue(arg));
+      return value;
+    }).filter(Boolean);
+    return Math.max(...decimals, DEFAULT_DECIMAL);
+  }
+  #toBigInt(value, decimal) {
+    const multiplier = decimal ? toMultiplier(decimal) : this.decimalMultiplier;
+    const padDecimal = decimalFromMultiplier(multiplier);
+    const [integerPart = "", decimalPart = ""] = value.split(".");
+    return BigInt(`${integerPart}${decimalPart.padEnd(padDecimal, "0")}`);
+  }
+}
+var numberFormatter = Intl.NumberFormat("fullwide", {
+  useGrouping: false,
+  maximumFractionDigits: 20
+});
+
+// src/modules/swapKitNumber.ts
+class SwapKitNumber extends BigIntArithmetics {
+  constructor() {
+    super(...arguments);
+  }
+  eq(value) {
+    return this.eqValue(value);
+  }
+  static fromBigInt(value, decimal) {
+    return new SwapKitNumber({
+      decimal,
+      value: formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal })
+    });
+  }
+}
+
+// src/modules/assetValue.ts
+function getMinAmountByChain(chain) {
+  const asset2 = AssetValue.fromChainOrSignature(chain);
+  switch (chain) {
+    case Chain.Bitcoin:
+    case Chain.Litecoin:
+    case Chain.BitcoinCash:
+      return asset2.set(0.00010001);
+    case Chain.Dogecoin:
+      return asset2.set(1.00000001);
+    case Chain.Avalanche:
+    case Chain.Ethereum:
+      return asset2.set(0.00000001);
+    case Chain.THORChain:
+    case Chain.Maya:
+      return asset2.set(0);
+    case Chain.Cosmos:
+      return asset2.set(0.000001);
+    default:
+      return asset2.set(0.00000001);
+  }
+}
+async function createAssetValue(identifier, value = 0) {
+  validateIdentifier(identifier);
+  const staticToken = staticTokensMap.get(identifier.toUpperCase());
+  const decimal = staticToken?.decimal || await getDecimal(getAssetInfo(identifier));
+  if (!staticToken) {
+    staticTokensMap.set(identifier.toUpperCase(), { identifier, decimal });
+  }
+  return new AssetValue({ decimal, value: safeValue(value, decimal), identifier });
+}
+var createSyntheticAssetValue = function(identifier, value = 0) {
+  const [synthChain, symbol] = identifier.split(".")?.[0]?.toUpperCase() === Chain.THORChain ? identifier.split(".").slice(1).join().split("/") : identifier.split("/");
+  if (!(synthChain && symbol))
+    throw new Error("Invalid asset identifier");
+  return new AssetValue({
+    decimal: 8,
+    value: safeValue(value, 8),
+    identifier: `${Chain.THORChain}.${synthChain}/${symbol}`
+  });
+};
+var safeValue = function(value, decimal) {
+  return typeof value === "bigint" ? formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal }) : value;
+};
+var getAssetInfo = function(identifier) {
+  const isSynthetic = identifier.slice(0, 14).includes("/");
+  const isThorchain = identifier.split(".")?.[0]?.toUpperCase() === Chain.THORChain;
+  const isMaya = identifier.split(".")?.[0]?.toUpperCase() === Chain.Maya;
+  const [synthChain, synthSymbol = ""] = isThorchain || isMaya ? identifier.split(".").slice(1).join().split("/") : identifier.split("/");
+  if (isSynthetic && !(synthChain && synthSymbol))
+    throw new Error("Invalid asset identifier");
+  const adjustedIdentifier = identifier.includes(".") && !isSynthetic ? identifier : `${isMaya ? Chain.Maya : Chain.THORChain}.${synthSymbol}`;
+  const [chain, ...rest] = adjustedIdentifier.split(".");
+  const [ticker, address] = (isSynthetic ? synthSymbol : rest.join(".")).split("-");
+  const symbol = isSynthetic ? synthSymbol : rest.join(".");
+  return {
+    address: address?.toLowerCase(),
+    chain,
+    isGasAsset: isGasAsset({ chain, symbol }),
+    isSynthetic,
+    symbol: (isSynthetic ? `${synthChain}/` : "") + (address ? `${ticker}-${address?.toLowerCase() ?? ""}` : symbol),
+    ticker
+  };
+};
+var staticTokensMap = new Map;
+
+class AssetValue extends BigIntArithmetics {
+  address;
+  chain;
+  isGasAsset = false;
+  isSynthetic = false;
+  symbol;
+  tax;
+  ticker;
+  type;
+  chainId;
+  constructor({
+    value,
+    decimal,
+    tax,
+    chain,
+    symbol,
+    identifier
+  }) {
+    super(typeof value === "object" ? value : { decimal, value });
+    const assetInfo = getAssetInfo(identifier || `${chain}.${symbol}`);
+    this.type = getAssetType(assetInfo);
+    this.tax = tax;
+    this.chain = assetInfo.chain;
+    this.ticker = assetInfo.ticker;
+    this.symbol = assetInfo.symbol;
+    this.address = assetInfo.address;
+    this.isSynthetic = assetInfo.isSynthetic;
+    this.isGasAsset = assetInfo.isGasAsset;
+    this.chainId = ChainToChainId[assetInfo.chain];
+  }
+  toString() {
+    return this.isSynthetic ? this.symbol : `${this.chain}.${this.symbol}`;
+  }
+  toUrl() {
+    return this.isSynthetic ? `${this.chain}.${this.symbol.replace("/", ".")}` : this.toString();
+  }
+  eq({ chain, symbol }) {
+    return this.chain === chain && this.symbol === symbol;
+  }
+  static fromUrl(urlAsset, value = 0) {
+    const [chain, ticker, symbol] = urlAsset.split(".");
+    if (!(chain && ticker))
+      throw new Error("Invalid asset url");
+    const assetString = chain === Chain.THORChain && symbol ? `${chain}.${ticker}/${symbol}` : urlAsset;
+    return createAssetValue(assetString, value);
+  }
+  static fromString(assetString, value = 0) {
+    return createAssetValue(assetString, value);
+  }
+  static fromIdentifier(assetString, value = 0) {
+    return createAssetValue(assetString, value);
+  }
+  static fromStringSync(assetString, value = 0) {
+    const { chain, isSynthetic } = getAssetInfo(assetString);
+    const tokenInfo = staticTokensMap.get(assetString.toUpperCase());
+    if (isSynthetic)
+      return createSyntheticAssetValue(assetString, value);
+    const { tax, decimal, identifier } = tokenInfo || {
+      decimal: BaseDecimal[chain],
+      identifier: assetString
+    };
+    return new AssetValue({
+      tax,
+      value: safeValue(value, decimal),
+      identifier: isSynthetic ? assetString : identifier,
+      decimal: isSynthetic ? 8 : decimal
+    });
+  }
+  static async fromStringWithBase(assetString, value = 0, baseDecimal = BaseDecimal.THOR) {
+    const shiftedAmount = BigIntArithmetics.shiftDecimals({
+      value: SwapKitNumber.fromBigInt(BigInt(value)),
+      from: 0,
+      to: baseDecimal
+    }).getBaseValue("string");
+    const assetValue = await AssetValue.fromString(assetString, value);
+    return assetValue.set(shiftedAmount);
+  }
+  static fromStringWithBaseSync(assetString, value = 0, baseDecimal = BaseDecimal.THOR) {
+    const { chain, isSynthetic } = getAssetInfo(assetString);
+    const tokenInfo = staticTokensMap.get(assetString.toUpperCase());
+    if (isSynthetic)
+      return createSyntheticAssetValue(assetString, value);
+    const { tax, decimal, identifier } = tokenInfo || {
+      decimal: BaseDecimal[chain],
+      identifier: assetString
+    };
+    return new AssetValue({
+      tax,
+      value: safeValue(BigInt(value), baseDecimal),
+      identifier,
+      decimal
+    });
+  }
+  static fromIdentifierSync(assetString, value = 0) {
+    const { chain, isSynthetic } = getAssetInfo(assetString);
+    const tokenInfo = staticTokensMap.get(assetString);
+    if (isSynthetic)
+      return createSyntheticAssetValue(assetString, value);
+    const { tax, decimal, identifier } = tokenInfo || {
+      decimal: BaseDecimal[chain],
+      identifier: assetString
+    };
+    return new AssetValue({ tax, decimal, identifier, value: safeValue(value, decimal) });
+  }
+  static fromChainOrSignature(assetString, value = 0) {
+    const { decimal, identifier } = getCommonAssetInfo(assetString);
+    return new AssetValue({ value: safeValue(value, decimal), decimal, identifier });
+  }
+  static loadStaticAssets() {
+    return new Promise((resolve, reject) => {
+      try {
+        import("@swapkit/tokens").then((tokenPackages) => {
+          for (const tokenList of Object.values(tokenPackages)) {
+            for (const { identifier, chain, ...rest } of tokenList.tokens) {
+              staticTokensMap.set(identifier.toUpperCase(), {
+                identifier,
+                decimal: "decimals" in rest ? rest.decimals : BaseDecimal[chain]
+              });
+            }
+          }
+          resolve({ ok: true });
+        });
+      } catch (error) {
+        console.error(error);
+        reject({
+          ok: false,
+          error,
+          message: "Couldn't load static assets. Ensure you have installed @swapkit/tokens package"
+        });
+      }
+    });
+  }
+}
+export {
+  wrapWithThrow,
+  wrapMethodWithNetworkSwitch,
+  validateTNS,
+  validateIdentifier,
+  switchEVMWalletNetwork,
+  setRequestClientConfig,
+  prepareNetworkSwitch,
+  okxMobileEnabled,
+  isWeb3Detected,
+  isGasAsset,
+  isDetected,
+  getWalletFormatFor,
+  getTHORNameCost,
+  getSymmetricWithdraw,
+  getSymmetricPoolShare,
+  getMinAmountByChain,
+  getMemoFor,
+  getMAYANameCost,
+  getLiquiditySlippage,
+  getEstimatedPoolShare,
+  getETHDefaultWallet,
+  getDerivationPathFor,
+  getDecimal,
+  getCommonAssetInfo,
+  getAsymmetricRuneWithdrawAmount,
+  getAsymmetricRuneShare,
+  getAsymmetricAssetWithdrawAmount,
+  getAsymmetricAssetShare,
+  getAssetType,
+  formatBigIntToSafeValue,
+  findAssetBy,
+  filterAssets,
+  erc20ABI,
+  derivationPathToString,
+  defaultRequestHeaders,
+  assetFromString,
+  addEVMWalletNetwork,
+  addAccountsChangedCallback,
+  WalletOption,
+  UTXOChains,
+  TCSupportedChains,
+  TCEthereumVaultAbi,
+  TCBscDepositABI,
+  TCAvalancheDepositABI,
+  SwapKitNumber,
+  SwapKitError,
+  SubstrateChains,
+  SWAP_OUT,
+  SWAP_IN,
+  RequestClient,
+  RPCUrl,
+  QuoteMode,
+  NetworkDerivationPath,
+  MemoType,
+  MAYASupportedChains,
+  LedgerErrorCode,
+  FeeOption,
+  ExplorerUrl,
+  EVMChains,
+  DerivationPath,
+  CosmosChains,
+  ContractAddress,
+  ChainToRPC,
+  ChainToHexChainId,
+  ChainToExplorerUrl,
+  ChainToChainId,
+  ChainIdToChain,
+  ChainId,
+  Chain,
+  BigIntArithmetics,
+  BaseDecimal,
+  AssetValue,
+  ApproveMode,
+  AGG_SWAP
+};
+
+//# debugId=0CED187DA85AD4E064756e2164756e21