@bze/bze-ui-kit 0.1.0

package/dist/index.mjs

@@ -0,0 +1,4663 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/constants/chain.ts
+import { chains as testnetChains } from "chain-registry/testnet";
+import { getAssetLists as ibcAssetsList } from "@chain-registry/utils";
+
+// src/constants/assets.ts
+var ASSET_TYPE_FACTORY = "Factory";
+var ASSET_TYPE_IBC = "IBC";
+var ASSET_TYPE_NATIVE = "Native";
+var ASSET_TYPE_LP = "LP";
+var VERIFIED_ASSETS = {
+  "factory/testbz1w9vva0muctcrmd9xgret9x4wasw2rrflsdkwfs/faneatiku2": true,
+  "factory/testbz1z3mkcr2jz424w6m49frgjmy9uhlrx69p4cvrgf/vidulum": true,
+  "factory/testbz1z3mkcr2jz424w6m49frgjmy9uhlrx69p4cvrgf/bitcoinz": true,
+  "ubze": true,
+  "utbz": true,
+  "factory/bze13gzq40che93tgfm9kzmkpjamah5nj0j73pyhqk/uvdl": true,
+  "factory/bze15pqjgk4la0mfphwddce00d05n3th3u66n3ptcv/2MARS": true,
+  "factory/bze12gyp30f29zg26nuqrwdhl26ej4q066pt572fhm/GGE": true
+};
+var EXCLUDED_ASSETS = {
+  "factory/testbz1w9vva0muctcrmd9xgret9x4wasw2rrflsdkwfs/faneatiku1": false,
+  "factory/bze1972aqfzdg29ugjln74edx0xvcg4ehvysjptk77/1000000000": true,
+  "ibc/689DD6F80E4DBCE14877462B182504037FAEAD0699D5804A7F5CB328D33ED24B": true,
+  "factory/bze1f0qgels0eu96ev6a67znu70q7rquy9eragn8nw/ucorey": true
+};
+var STABLE_COINS = {
+  "factory/testbz1z3mkcr2jz424w6m49frgjmy9uhlrx69p4cvrgf/uusdt": true,
+  "factory/bze1z3mkcr2jz424w6m49frgjmy9uhlrx69phqwg3l/testusd": true,
+  "ibc/6490A7EAB61059BFC1CDDEB05917DD70BDF3A611654162A1A47DB930D40D8AF4": true
+};
+var getChainNativeAssetDenom = () => {
+  return process.env.NEXT_PUBLIC_CHAIN_NATIVE_ASSET_DENOM || "ubze";
+};
+var getUSDCDenom = () => {
+  return process.env.NEXT_PUBLIC_USDC_IBC_DENOM || "";
+};
+
+// src/constants/testnet.ts
+var BZE_TESTNET_2_SUGGEST_CHAIN = {
+  chainId: "bzetestnet-3",
+  chainType: "cosmos",
+  chainName: "BeeZee Testnet 3",
+  prettyName: "BeeZee Testnet 3",
+  networkType: "mainnet",
+  bech32Prefix: "bze",
+  status: "live",
+  slip44: 118,
+  logoURIs: {
+    svg: "https://raw.githubusercontent.com/cosmos/chain-registry/master/beezee/images/bze.svg"
+  },
+  fees: {
+    feeTokens: [
+      {
+        denom: getChainNativeAssetDenom(),
+        fixedMinGasPrice: 0.01,
+        lowGasPrice: 0.01,
+        averageGasPrice: 0.025,
+        highGasPrice: 0.04
+      }
+    ]
+  },
+  keyAlgos: [
+    "secp256k1"
+  ],
+  staking: {
+    stakingTokens: [
+      {
+        denom: getChainNativeAssetDenom()
+      }
+    ]
+  },
+  explorers: [
+    {
+      "kind": "ping.pub",
+      "url": "https://testnet.explorer.thesilverfox.pro/beezee",
+      "tx_page": "https://testnet.explorer.thesilverfox.pro/beezee/tx/${txHash}"
+    }
+  ],
+  codebase: {
+    "git_repo": "https://github.com/bze-alphateam/bze",
+    "recommended_version": "v5.1.2",
+    "compatible_versions": [
+      "v5.1.2"
+    ],
+    "binaries": {
+      "darwin/amd64": "https://github.com/bze-alphateam/bze/releases/download/v5.1.2/bze-5.1.2-darwin-amd64.tar.gz",
+      "darwin/arm64": "https://github.com/bze-alphateam/bze/releases/download/v5.1.2/bze-5.1.2-darwin-arm64.tar.gz",
+      "linux/amd64": "https://github.com/bze-alphateam/bze/releases/download/v5.1.2/bze-5.1.2-linux-amd64.tar.gz",
+      "linux/arm64": "https://github.com/bze-alphateam/bze/releases/download/v5.1.2/bze-5.1.2-linux-arm64.tar.gz",
+      "windows/amd64": "https://github.com/bze-alphateam/bze/releases/download/v5.1.2/bze-5.1.2-win64.zip"
+    },
+    "genesis": {
+      "genesis_url": "https://raw.githubusercontent.com/bze-alphateam/bze/main/genesis.json"
+    }
+  },
+  apis: {
+    "rpc": [
+      {
+        "address": "https://testnet-rpc.getbze.com",
+        "provider": "AlphaTeam"
+      }
+    ],
+    "rest": [
+      {
+        "address": "https://testnet.getbze.com",
+        "provider": "AlphaTeam"
+      }
+    ],
+    "grpc": [
+      {
+        "address": "grpc.getbze.com:9999",
+        "provider": "AlphaTeam"
+      }
+    ]
+  }
+};
+var BZE_TESTNET_NETWORK = {
+  base: {
+    explorerBaseUrl: "https://explorer.getbze.com/bze%20testnet",
+    rpcUrl: "https://testnet-rpc.getbze.com",
+    restUrl: "https://testnet.getbze.com",
+    chainName: BZE_TESTNET_2_SUGGEST_CHAIN.chainName
+  },
+  chain: [BZE_TESTNET_2_SUGGEST_CHAIN],
+  assets: [
+    {
+      chainName: BZE_TESTNET_2_SUGGEST_CHAIN.chainName,
+      assets: [
+        {
+          "description": "BeeZee native blockchain",
+          "typeAsset": "sdk.coin",
+          "denomUnits": [
+            {
+              "denom": getChainNativeAssetDenom(),
+              "exponent": 0
+            },
+            {
+              "denom": "TBZE",
+              "exponent": 6
+            }
+          ],
+          "base": getChainNativeAssetDenom(),
+          "name": "BeeZee",
+          "display": "TBZE",
+          "symbol": "TBZE",
+          "logoURIs": {
+            "svg": "https://raw.githubusercontent.com/cosmos/chain-registry/master/beezee/images/bze.svg",
+            "png": "https://raw.githubusercontent.com/cosmos/chain-registry/master/beezee/images/bze.png"
+          },
+          "coingeckoId": "bzedge"
+        },
+        {
+          "description": "Lumen",
+          "typeAsset": "sdk.coin",
+          "denomUnits": [
+            {
+              "denom": "ibc/9DA252F9F9C86132CC282EA431DFB7DE7729501F6DC9A3E0F50EC8C6EE380CC7",
+              "exponent": 0,
+              "aliases": []
+            },
+            {
+              "denom": "LMN",
+              "exponent": 6,
+              "aliases": []
+            }
+          ],
+          "base": "ibc/9DA252F9F9C86132CC282EA431DFB7DE7729501F6DC9A3E0F50EC8C6EE380CC7",
+          "display": "LMN",
+          "name": "Lumen",
+          "symbol": "LMN",
+          "logoURIs": {
+            "png": "https://raw.githubusercontent.com/cosmos/chain-registry/master/lumen/images/lmn.png"
+          }
+        },
+        {
+          "description": "Vidulum app token",
+          "typeAsset": "sdk.coin",
+          "denomUnits": [
+            {
+              "denom": "factory/bze1z3mkcr2jz424w6m49frgjmy9uhlrx69phqwg3l/vidulum",
+              "exponent": 0,
+              "aliases": []
+            },
+            {
+              "denom": "VDL",
+              "exponent": 6,
+              "aliases": []
+            }
+          ],
+          "base": "factory/bze1z3mkcr2jz424w6m49frgjmy9uhlrx69phqwg3l/vidulum",
+          "display": "VDL",
+          "name": "Vidulum",
+          "symbol": "VDL",
+          "logoURIs": {
+            "png": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/beezee/factory/bze13gzq40che93tgfm9kzmkpjamah5nj0j73pyhqk/uvdl.png"
+          }
+        }
+      ]
+    }
+  ]
+};
+
+// src/constants/chain.ts
+import { assetLists, chains, ibcData } from "@chain-registry/v2";
+var getChainId = () => {
+  return process.env.NEXT_PUBLIC_CHAIN_ID || "beezee-1";
+};
+var getChainName = () => {
+  return process.env.NEXT_PUBLIC_CHAIN_NAME || "beezee";
+};
+var isTestnetChain = () => {
+  const isTestnet = process.env.NEXT_PUBLIC_CHAIN_IS_TESTNET;
+  return isTestnet === "true" || isTestnet === "1";
+};
+var getChains = () => {
+  let localChains = chains;
+  if (isTestnetChain()) {
+    localChains = [...testnetChains, BZE_TESTNET_2_SUGGEST_CHAIN];
+  }
+  return localChains;
+};
+var getChainByChainId = (chainId) => {
+  let localChains = chains;
+  if (isTestnetChain()) {
+    localChains = [...testnetChains, BZE_TESTNET_2_SUGGEST_CHAIN];
+  }
+  return localChains.find((c) => {
+    var _a2;
+    return ((_a2 = c.chainId) == null ? void 0 : _a2.toLowerCase()) === chainId.toLowerCase();
+  });
+};
+var getChainByName = (name) => {
+  let localChains = chains;
+  if (isTestnetChain()) {
+    localChains = [...testnetChains, BZE_TESTNET_2_SUGGEST_CHAIN];
+  }
+  return localChains.find((c) => c.chainName.toLowerCase() === name.toLowerCase());
+};
+var getWalletChainsNames = () => {
+  const localChains = getChains();
+  const envChainsNames = process.env.NEXT_PUBLIC_WALLET_CHAINS_NAMES;
+  if (!envChainsNames) {
+    return localChains.filter((c) => c.chainId === getChainId());
+  }
+  const split = envChainsNames.split(",");
+  return appChainFirst(localChains.filter((c) => split.includes(c.chainName)));
+};
+var appChainFirst = (chains2) => {
+  return chains2.sort((a, b) => a.chainId === getChainId() ? -1 : b.chainId === getChainId() ? 1 : 0);
+};
+var getAssetLists = () => {
+  let localAssetLists = assetLists;
+  if (isTestnetChain()) {
+    localAssetLists = BZE_TESTNET_NETWORK.assets;
+  }
+  return localAssetLists;
+};
+var getIBCAssetList = () => {
+  const all = ibcAssetsList(getChainName(), ibcData, getAssetLists());
+  return all.length > 0 ? all[0].assets : [];
+};
+var getChainAddressPrefix = () => {
+  return process.env.NEXT_PUBLIC_CHAIN_ADDRESS_PREFIX || "bze";
+};
+var getChainExplorerURL = (chainName) => {
+  if (process.env.NEXT_PUBLIC_EXPLORER_URL) {
+    return `${process.env.NEXT_PUBLIC_EXPLORER_URL}/${chainName}`;
+  }
+  return `https://explorer.chaintools.tech/${chainName}`;
+};
+var getLockerAddress = () => {
+  return process.env.NEXT_PUBLIC_LOCKER_ADDRESS || "bze1pc5zjcvhx3e8l305zjl72grytfa30r5mdypmw4";
+};
+
+// src/storage/storage.ts
+var TTL_NO_EXPIRY = 0;
+var _storageKeyVersion = "1";
+var setStorageKeyVersion = (version) => {
+  _storageKeyVersion = version;
+};
+var getFromLocalStorage = (key) => {
+  if (typeof window === "undefined") return null;
+  try {
+    const cachedItem = localStorage.getItem(prefixedKey(key));
+    if (cachedItem) {
+      const item = JSON.parse(cachedItem);
+      const now = (/* @__PURE__ */ new Date()).getTime();
+      if (item.expiry === TTL_NO_EXPIRY || now < item.expiry) {
+        return item.data;
+      }
+      localStorage.removeItem(prefixedKey(key));
+    }
+  } catch (error) {
+    console.error("Failed to get data from localStorage:", error);
+  }
+  return null;
+};
+var setInLocalStorage = (key, data, ttl) => {
+  if (typeof window === "undefined") return false;
+  try {
+    if (ttl < 0) ttl = 0;
+    const item = {
+      data,
+      expiry: TTL_NO_EXPIRY
+    };
+    if (ttl > 0) {
+      const now = (/* @__PURE__ */ new Date()).getTime();
+      item.expiry = now + ttl * 1e3;
+    }
+    localStorage.setItem(prefixedKey(key), JSON.stringify(item));
+    return true;
+  } catch (error) {
+    console.error("Failed to set data in localStorage:", error);
+  }
+  return false;
+};
+var removeFromLocalStorage = (key) => {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.removeItem(prefixedKey(key));
+  } catch (error) {
+    console.error("Failed to remove data from localStorage:", error);
+  }
+};
+var getKeyExpiry = (key) => {
+  if (typeof window === "undefined") return null;
+  try {
+    const cachedItem = localStorage.getItem(prefixedKey(key));
+    if (cachedItem) {
+      const item = JSON.parse(cachedItem);
+      if (item.expiry > TTL_NO_EXPIRY) {
+        return new Date(item.expiry);
+      }
+    }
+  } catch (error) {
+    console.error("Failed to get data from localStorage:", error);
+  }
+  return null;
+};
+var setKeyExpiry = (key, expiry) => {
+  if (typeof window === "undefined") return false;
+  try {
+    const cachedItem = localStorage.getItem(prefixedKey(key));
+    if (cachedItem) {
+      const item = JSON.parse(cachedItem);
+      if (item) {
+        item.expiry = expiry.getTime();
+        localStorage.setItem(prefixedKey(key), JSON.stringify(item));
+        return true;
+      }
+    }
+  } catch (error) {
+    console.error("Failed to set data in localStorage:", error);
+  }
+  return false;
+};
+var prefixedKey = (key) => {
+  return `${_storageKeyVersion}-${getChainId()}:${key}`;
+};
+
+// src/constants/placeholders.ts
+var TOKEN_LOGO_PLACEHOLDER = "/images/token.svg";
+var BZE_CIRCLE_LOGO = "/images/bze_alternative_512x512.png";
+var _defaultTxMemo = "getbze.com";
+var DEFAULT_TX_MEMO = _defaultTxMemo;
+var setDefaultTxMemo = (memo) => {
+  _defaultTxMemo = memo;
+};
+var getDefaultTxMemo = () => {
+  return _defaultTxMemo;
+};
+
+// src/types/asset.ts
+var LP_ASSETS_DECIMALS = 12;
+
+// src/types/market.ts
+var ORDER_TYPE_BUY = "buy";
+var ORDER_TYPE_SELL = "sell";
+
+// src/types/settings.ts
+var CONNECTION_TYPE_WS = 2;
+var CONNECTION_TYPE_POLLING = 1;
+var CONNECTION_TYPE_NONE = 0;
+
+// src/types/events.ts
+var CURRENT_WALLET_BALANCE_EVENT = "current_wallet_balance";
+var ORDER_EXECUTED_EVENT = "order_executed";
+var ORDER_BOOK_CHANGED_EVENT = "order_book_changed";
+var SUPPLY_CHANGED_EVENT = "supply_changed";
+var SWAP_EXECUTED_EVENT = "swap_executed";
+var NEXT_BURN_CHANGED_EVENT = "next_burn_changed";
+var RAFFLE_CHANGED_EVENT = "raffle_changed";
+var LOCK_CHANGED_EVENT = "lock_changed";
+var EPOCH_START_EVENT = "epoch_start";
+
+// src/utils/amount.ts
+import BigNumber from "bignumber.js";
+var MAX_PRICE_DECIMALS = 14;
+function toBigNumber(amount) {
+  if (amount instanceof BigNumber) {
+    return amount;
+  }
+  return new BigNumber(amount);
+}
+function uAmountToAmount(amount, noOfDecimals) {
+  return uAmountToBigNumberAmount(amount, noOfDecimals).toString();
+}
+function uAmountToBigNumberAmount(amount, noOfDecimals) {
+  return toBigNumber(amount || 0).shiftedBy(-1 * noOfDecimals).decimalPlaces(noOfDecimals || 6);
+}
+function amountToBigNumberUAmount(amount, noOfDecimals) {
+  return toBigNumber(amount).shiftedBy(noOfDecimals).decimalPlaces(noOfDecimals || 6);
+}
+function amountToUAmount(amount, noOfDecimals) {
+  return amountToBigNumberUAmount(amount, noOfDecimals).toString();
+}
+function prettyAmount(amount) {
+  const num = toBigNumber(amount);
+  if (num.isNaN()) {
+    return "0";
+  }
+  if (num.lt(1) && num.gt(0)) {
+    return num.toFixed(6);
+  }
+  return Intl.NumberFormat("en", { notation: "standard" }).format(num.toNumber());
+}
+var priceToUPrice = (price, quoteExponent, baseExponent) => {
+  return priceToBigNumberUPrice(price, quoteExponent, baseExponent).toFixed(MAX_PRICE_DECIMALS).toString();
+};
+var priceToBigNumberUPrice = (price, quoteExponent, baseExponent) => {
+  price = toBigNumber(price);
+  return price.multipliedBy(Math.pow(10, quoteExponent - baseExponent));
+};
+var uPriceToPrice = (price, quoteExponent, baseExponent) => {
+  return uPriceToBigNumberPrice(toBigNumber(price), quoteExponent, baseExponent).toString();
+};
+var uPriceToBigNumberPrice = (price, quoteExponent, baseExponent) => {
+  const converted = toBigNumber(price);
+  return converted.multipliedBy(Math.pow(10, baseExponent - quoteExponent));
+};
+
+// src/utils/address.ts
+import { fromBech32 } from "@interchainjs/encoding";
+
+// src/utils/strings.ts
+function stringTruncateFromCenter(str, maxLength) {
+  const midChar = "\u2026";
+  if (str.length <= maxLength) return str;
+  const left = Math.ceil(maxLength / 2);
+  const right = str.length - Math.floor(maxLength / 2) + 1;
+  return str.substring(0, left) + midChar + str.substring(right);
+}
+function removeLeadingZeros(str) {
+  return str.replace(/^0+/, "") || "0";
+}
+
+// src/utils/address.ts
+var truncateAddress = (address) => {
+  return stringTruncateFromCenter(address, 12);
+};
+var validateBech32Address = (address, prefix) => {
+  const result = {
+    isValid: false,
+    message: ""
+  };
+  try {
+    const { prefix: addressPrefix } = fromBech32(address);
+    if (addressPrefix === prefix) {
+      result.isValid = true;
+      return result;
+    }
+    result.message = `This address is from another network (${addressPrefix}). Please use an address from the destination network (${prefix}).`;
+  } catch (e) {
+    console.error("invalid address ", e);
+    result.message = "Invalid address";
+  }
+  return result;
+};
+var validateBZEBech32Address = (address) => validateBech32Address(address, getChainAddressPrefix());
+
+// src/utils/charts.ts
+var CHART_4H = "4H";
+var CHART_1D = "1D";
+var CHART_7D = "7D";
+var CHART_30D = "30D";
+var CHART_1Y = "1Y";
+function getNoOfIntervalsNeeded(chart) {
+  switch (chart) {
+    case CHART_4H:
+      return 12 * 4;
+    case CHART_1D:
+      return 4 * 24;
+    case CHART_7D:
+      return 24 * 7;
+    case CHART_30D:
+      return 6 * 30;
+    case CHART_1Y:
+      return 365;
+    default:
+      return 0;
+  }
+}
+function getChartIntervalsLimit(chart) {
+  switch (chart) {
+    case CHART_4H:
+      return 12 * 24 * 7;
+    case CHART_1D:
+      return 4 * 24 * 30;
+    case CHART_7D:
+      return 24 * 90;
+    case CHART_30D:
+      return 6 * 365;
+    case CHART_1Y:
+      return 365 * 3;
+    default:
+      return 12;
+  }
+}
+function getChartMinutes(chart) {
+  switch (chart) {
+    case CHART_4H:
+      return 5;
+    case CHART_1D:
+      return 15;
+    case CHART_7D:
+      return 60;
+    case CHART_30D:
+      return 240;
+    case CHART_1Y:
+      return 1440;
+    default:
+      return 5;
+  }
+}
+
+// src/utils/debounce.ts
+var debounces = /* @__PURE__ */ new Map();
+async function addMultipleDebounce(name, delay, callback, times) {
+  for (let index = 1; index <= times; index++) {
+    addDebounce(`${name}-${index}`, delay * index, callback);
+  }
+}
+async function addDebounce(name, delay, callback) {
+  cancelDebounce(name);
+  const newTimer = setTimeout(() => {
+    callback();
+  }, delay);
+  debounces.set(name, newTimer);
+}
+async function cancelDebounce(name) {
+  const timer = debounces.get(name);
+  if (timer) {
+    clearTimeout(timer);
+    debounces.delete(name);
+  }
+}
+
+// src/utils/denom.ts
+var MAX_DENOM_LEN = 8;
+var isFactoryDenom = (denom) => denom.startsWith("factory/");
+var isIbcDenom = (denom) => denom.startsWith("ibc/");
+var isLpDenom = (denom) => denom.startsWith("ulp_");
+var isNativeDenom = (denom) => getChainNativeAssetDenom() === denom;
+var getDenomType = (denom) => isFactoryDenom(denom) ? ASSET_TYPE_FACTORY : isIbcDenom(denom) ? ASSET_TYPE_IBC : isLpDenom(denom) ? ASSET_TYPE_LP : ASSET_TYPE_NATIVE;
+function truncateDenom(denom) {
+  return stringTruncateFromCenter(denom, MAX_DENOM_LEN);
+}
+var isIbcAsset = (asset) => asset.type === ASSET_TYPE_IBC;
+
+// src/utils/events.ts
+var getMarketOrderBookChangedEvent = (marketId) => getMarketEventKey(ORDER_BOOK_CHANGED_EVENT, marketId);
+var getMarketEventKey = (eventType, marketId) => `${eventType}:${marketId}`;
+var mapEventAttributes = (attributes) => {
+  return attributes.reduce((acc, attr) => __spreadProps(__spreadValues({}, acc), { [attr.key]: attr.value.replace('"', "").replace('"', "") }), {});
+};
+
+// src/utils/formatter.ts
+import BigNumber2 from "bignumber.js";
+var formatUsdAmount = (priceNum) => {
+  const price = priceNum.toString();
+  const decimalIndex = price.indexOf(".");
+  if (decimalIndex === -1) {
+    return price;
+  }
+  const decimalPart = price.substring(decimalIndex + 1);
+  let significantDigitCount = 0;
+  let decimalsFound = 0;
+  for (let i = 0; i < decimalPart.length; i++) {
+    const digit = decimalPart[i];
+    decimalsFound++;
+    if (digit !== "0" || significantDigitCount > 0) {
+      significantDigitCount++;
+    }
+    if (significantDigitCount >= 6) {
+      break;
+    }
+  }
+  return priceNum.toFixed(decimalsFound).toString();
+};
+function shortNumberFormat(amount) {
+  if (amount.isNaN() || amount.isZero()) {
+    return "0";
+  }
+  if (amount.lt(1e-3)) {
+    return "0";
+  }
+  const units = [
+    { value: new BigNumber2("1e15"), suffix: "Q" },
+    { value: new BigNumber2("1e12"), suffix: "T" },
+    { value: new BigNumber2("1e9"), suffix: "B" },
+    { value: new BigNumber2("1e6"), suffix: "M" },
+    { value: new BigNumber2("1e3"), suffix: "K" }
+  ];
+  for (const unit of units) {
+    if (amount.gte(unit.value)) {
+      const formatted = amount.div(unit.value);
+      const result = formatted.toFixed(3).replace(/\.?0+$/, "");
+      return `${result}${unit.suffix}`;
+    }
+  }
+  return amount.toFixed(3).replace(/\.?0+$/, "");
+}
+var intlDateFormat = new Intl.DateTimeFormat("en-US", {
+  year: "2-digit",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "numeric",
+  minute: "2-digit",
+  hour12: false
+});
+var formatDate = (date) => {
+  return intlDateFormat.format(date);
+};
+var formatTimeRemaining = (targetDate) => {
+  const now = /* @__PURE__ */ new Date();
+  const diff = targetDate.getTime() - now.getTime();
+  if (diff <= 0) {
+    return "Now";
+  }
+  const days = Math.floor(diff / (1e3 * 60 * 60 * 24));
+  const hours = Math.floor(diff % (1e3 * 60 * 60 * 24) / (1e3 * 60 * 60));
+  const minutes = Math.floor(diff % (1e3 * 60 * 60) / (1e3 * 60));
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  return parts.join(" ") || "Now";
+};
+var formatTimeRemainingFromEpochs = (epochs) => {
+  if (epochs.lte(0)) {
+    return "Now";
+  }
+  const totalSeconds = epochs.multipliedBy(60).toNumber();
+  const days = Math.floor(totalSeconds / (60 * 60 * 24));
+  const hours = Math.floor(totalSeconds % (60 * 60 * 24) / (60 * 60));
+  const minutes = Math.floor(totalSeconds % (60 * 60) / 60);
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  return parts.join(" ") || "Now";
+};
+
+// src/utils/functions.ts
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var openExternalLink = (url) => {
+  if (!window) return;
+  window.open(url, "_blank", "noopener,noreferrer");
+};
+
+// src/utils/ibc.ts
+import BigNumber3 from "bignumber.js";
+var canDepositFromIBC = (ibcData2) => {
+  return ibcData2.counterparty.baseDenom !== "" && ibcData2.counterparty.channelId !== "" && ibcData2.counterparty.chainName != "";
+};
+var canSendToIBC = (ibcData2) => {
+  return ibcData2.chain.channelId !== "" && ibcData2.counterparty.chainName != "";
+};
+async function denomOnFirstHopChainFromTrace(trace) {
+  try {
+    if (!(trace == null ? void 0 : trace.base_denom)) return void 0;
+    const parts = trace.path.split("/").filter(Boolean);
+    if (parts.length < 2) {
+      return trace.base_denom || void 0;
+    }
+    const remaining = parts.slice(2);
+    if (remaining.length === 0) {
+      return trace.base_denom;
+    }
+    const remainingPath = remaining.join("/");
+    const full = `${remainingPath}/${trace.base_denom}`;
+    const enc = new TextEncoder();
+    const buf = enc.encode(full);
+    const digest = await crypto.subtle.digest("SHA-256", buf);
+    const hashBytes = new Uint8Array(digest);
+    let hex = "";
+    for (let i = 0; i < hashBytes.length; i++) {
+      const b = hashBytes[i].toString(16).padStart(2, "0");
+      hex += b;
+    }
+    return `ibc/${hex.toUpperCase()}`;
+  } catch (e) {
+    console.error("[denomOnFirstHopChainFromTrace] error:", e);
+    return void 0;
+  }
+}
+var getIbcTransferTimeout = () => {
+  return new BigNumber3(Date.now() + 6e5).multipliedBy(1e6);
+};
+
+// src/utils/liquidity_pool.ts
+var calculateUserPoolData = (balance, lpAsset, poolData) => {
+  const zeroBN = toBigNumber(0);
+  if (!balance || balance.amount.isZero()) {
+    return { userLiquidityUsd: zeroBN, userSharesPercentage: 0 };
+  }
+  if (!lpAsset) {
+    return { userLiquidityUsd: zeroBN, userSharesPercentage: 0 };
+  }
+  const userShares = toBigNumber(balance.amount);
+  const totalShares = toBigNumber(lpAsset.supply);
+  if (totalShares.isZero()) {
+    return { userLiquidityUsd: zeroBN, userSharesPercentage: 0 };
+  }
+  const userSharesPercentage = userShares.dividedBy(totalShares).multipliedBy(100).toNumber();
+  let userLiquidityUsd = zeroBN;
+  if (poolData && poolData.usdValue) {
+    userLiquidityUsd = userShares.dividedBy(totalShares).multipliedBy(poolData.usdValue);
+  }
+  return { userLiquidityUsd, userSharesPercentage };
+};
+var calculatePoolOppositeAmount = (pool, amount, isBase) => {
+  const amountBN = toBigNumber(amount);
+  if (amountBN.isZero() || amountBN.isNaN()) {
+    return toBigNumber(0);
+  }
+  const reserveBase = toBigNumber(pool.reserve_base);
+  const reserveQuote = toBigNumber(pool.reserve_quote);
+  if (reserveBase.isZero() || reserveQuote.isZero()) {
+    return toBigNumber(0);
+  }
+  if (isBase) {
+    return amountBN.multipliedBy(reserveQuote).dividedBy(reserveBase);
+  } else {
+    return amountBN.multipliedBy(reserveBase).dividedBy(reserveQuote);
+  }
+};
+var calculatePoolPrice = (denom, pool) => {
+  if (!pool || !denom) return null;
+  const reserveBase = toBigNumber(pool.reserve_base);
+  const reserveQuote = toBigNumber(pool.reserve_quote);
+  if (reserveBase.lte(0) || reserveQuote.lte(0)) {
+    return null;
+  }
+  if (denom === pool.base) {
+    return reserveQuote.dividedBy(reserveBase);
+  }
+  if (denom === pool.quote) {
+    return reserveBase.dividedBy(reserveQuote);
+  }
+  return null;
+};
+var createPoolId = (base, quote) => {
+  if (base > quote) return `${quote}_${base}`;
+  return `${base}_${quote}`;
+};
+var poolIdFromPoolDenom = (poolDenom) => poolDenom.replace("ulp_", "");
+
+// src/utils/market.ts
+import BigNumber4 from "bignumber.js";
+var createMarketId = (base, quote) => `${base}/${quote}`;
+var calculateTotalAmount = (price, amount, decimals) => {
+  const priceNum = toBigNumber(price);
+  const amountNum = toBigNumber(amount);
+  if (priceNum.isNaN() || amountNum.isNaN() || priceNum.isZero() || amountNum.isZero()) return "";
+  const total = priceNum.multipliedBy(amountNum);
+  return total.decimalPlaces(decimals).toString();
+};
+var calculatePricePerUnit = (amount, totalPrice, decimals) => {
+  const amountNum = toBigNumber(amount);
+  const total = toBigNumber(totalPrice);
+  if (amountNum.isNaN() || total.isNaN() || amountNum.isZero() || total.isZero()) return "";
+  return total.dividedBy(amountNum).decimalPlaces(decimals).toString();
+};
+var calculateAmountFromPrice = (price, totalPrice, decimals) => {
+  const total = toBigNumber(totalPrice);
+  const priceNum = toBigNumber(price);
+  if (total.isNaN() || priceNum.isNaN() || total.isZero() || priceNum.isZero()) return "";
+  return total.div(priceNum).decimalPlaces(decimals).toString();
+};
+var getMinAmount = (uPrice, noOfDecimals) => {
+  const uPriceDec = toBigNumber(uPrice);
+  if (uPriceDec.lte(0)) {
+    return new BigNumber4(0);
+  }
+  const oneDec = new BigNumber4(1);
+  const amtDec = oneDec.dividedBy(uPriceDec).decimalPlaces(0, BigNumber4.ROUND_CEIL).multipliedBy(2);
+  return amtDec.shiftedBy(-1 * noOfDecimals).decimalPlaces(noOfDecimals || 6).multipliedBy(2);
+};
+
+// src/utils/number.ts
+var sanitizeNumberInput = (input) => {
+  let sanitized = input.replace(/[^0-9.,]/g, "");
+  sanitized = sanitized.replace(",", ".");
+  const parts = sanitized.split(".");
+  if (parts.length > 2) {
+    sanitized = parts[0] + "." + parts.slice(1).join("");
+  }
+  return sanitized;
+};
+var sanitizeIntegerInput = (input) => {
+  if (input.length === 0) {
+    return "";
+  }
+  const sanitized = input.replace(/[^0-9]/g, "");
+  const parsed = parseInt(sanitized, 10);
+  if (!parsed) {
+    return "1";
+  }
+  return `${parsed}`;
+};
+var toPercentage = (dec) => toBigNumber(dec).multipliedBy(100).decimalPlaces(2).toString();
+
+// src/utils/staking.ts
+import BigNumber5 from "bignumber.js";
+var DAY_TO_SECONDS = 24 * 60 * 60;
+var calcNativeStakingApr = (pool, communityTax, annualProvisions) => {
+  const totalSupply = new BigNumber5((pool == null ? void 0 : pool.bonded_tokens) || 0).plus(
+    (pool == null ? void 0 : pool.not_bonded_tokens) || 0
+  );
+  if (totalSupply.isZero() || annualProvisions.isZero()) {
+    return "0.00";
+  }
+  const bondedTokens = new BigNumber5((pool == null ? void 0 : pool.bonded_tokens) || 0);
+  if (bondedTokens.isZero()) {
+    return "0.00";
+  }
+  const bondedTokensRatio = bondedTokens.div(totalSupply);
+  const inflation = annualProvisions.div(totalSupply);
+  const communityTaxRate = new BigNumber5(communityTax || 0);
+  const apr = inflation.multipliedBy(new BigNumber5(1).minus(communityTaxRate)).div(bondedTokensRatio).multipliedBy(100).decimalPlaces(2, BigNumber5.ROUND_DOWN);
+  return apr.toString();
+};
+var parseUnbondingDays = (unbondingTime) => {
+  const split = unbondingTime.split("s");
+  return new BigNumber5(split[0] || 0).div(DAY_TO_SECONDS).decimalPlaces(0).toString();
+};
+var calculateRewardsStakingApr = (dailyAmount, staked) => {
+  const stakedNum = new BigNumber5(staked);
+  let computedApr = new BigNumber5(dailyAmount).dividedBy(stakedNum).multipliedBy(365).multipliedBy(100);
+  if (computedApr.lt(1)) {
+    computedApr = computedApr.decimalPlaces(6);
+  } else {
+    computedApr = computedApr.decimalPlaces(2);
+  }
+  return computedApr;
+};
+var calculateRewardsStakingPendingRewards = (stakingReward, userStake) => {
+  const distr = new BigNumber5((stakingReward == null ? void 0 : stakingReward.distributed_stake) || 0);
+  const joinedAt = new BigNumber5((userStake == null ? void 0 : userStake.joined_at) || 0);
+  if (distr.isEqualTo(joinedAt)) {
+    return new BigNumber5(0);
+  }
+  const deposited = new BigNumber5((userStake == null ? void 0 : userStake.amount) || 0);
+  return deposited.multipliedBy(distr.minus(joinedAt)).decimalPlaces(0);
+};
+
+// src/utils/user_errors.ts
+var errorsMap = {
+  "failed to execute message; message index: 0: amount is smaller than staking reward min stake": "Amount is smaller than minimum required stake",
+  "the resulted amount is too low": "Swap minimum amount could not be met. Increase the slippage and try again.",
+  "amount is too low to be traded": "Amount is too low to be traded",
+  "can not buy more than 50 tickets": "You can only contribute up to 50 times per transaction."
+};
+var prettyError = (err) => {
+  if (!err) return void 0;
+  if (errorsMap[err]) {
+    return errorsMap[err];
+  }
+  for (const [key, value] of Object.entries(errorsMap)) {
+    if (err.includes(key)) {
+      return value;
+    }
+  }
+  return err;
+};
+
+// src/constants/settings.ts
+var SETTINGS_STORAGE_KEY = "bze_app_settings";
+var _a, _b;
+var DEFAULT_SETTINGS = {
+  endpoints: {
+    restEndpoint: (_a = process.env.NEXT_PUBLIC_REST_ENDPOINT) != null ? _a : "",
+    rpcEndpoint: (_b = process.env.NEXT_PUBLIC_RPC_ENDPOINT) != null ? _b : ""
+  },
+  preferredFeeDenom: getChainNativeAssetDenom()
+};
+var VALIDATION_ERRORS = {
+  EMPTY_ENDPOINT: "Endpoint cannot be empty",
+  INVALID_URL: "Invalid URL format",
+  INVALID_REST_PROTOCOL: "REST endpoint must use HTTP or HTTPS protocol",
+  INVALID_RPC_PROTOCOL: "RPC endpoint must use WS or WSS protocol for WebSocket connection",
+  CORS_ERROR: "Endpoint validation failed - unable to connect or CORS not enabled",
+  WEBSOCKET_ERROR: "WebSocket connection failed - unable to connect to RPC endpoint",
+  NETWORK_ERROR: "Network error - unable to validate endpoint"
+};
+var getAppName = () => {
+  var _a2;
+  return (_a2 = process.env.NEXT_PUBLIC_APP_NAME) != null ? _a2 : "BZE";
+};
+
+// src/storage/settings.ts
+var getSettings = () => {
+  const saved = getFromLocalStorage(SETTINGS_STORAGE_KEY);
+  if (saved) {
+    const parsed = JSON.parse(saved);
+    return __spreadValues(__spreadValues({}, DEFAULT_SETTINGS), parsed);
+  }
+  return DEFAULT_SETTINGS;
+};
+var setSettings = (newSettings) => {
+  return setInLocalStorage(SETTINGS_STORAGE_KEY, JSON.stringify(newSettings), TTL_NO_EXPIRY);
+};
+
+// src/query/client.ts
+import { bze } from "@bze/bzejs";
+import { PageRequest } from "@bze/bzejs/cosmos/base/query/v1beta1/pagination";
+var getRestClient = () => {
+  const settings = getSettings();
+  return createRestClient(settings.endpoints.restEndpoint);
+};
+var createRestClient = async (endpoint) => {
+  return bze.ClientFactory.createLCDClient({ restEndpoint: endpoint });
+};
+var getPageRequestWithLimit = (limit) => {
+  return PageRequest.fromPartial({
+    limit: BigInt(limit)
+  });
+};
+
+// src/query/burner.ts
+import { bze as bze2 } from "@bze/bzejs";
+import { PageRequest as PageRequest2 } from "@bze/bzejs/cosmos/base/query/v1beta1/pagination";
+var BURNED_KEY = "burner:all_burned_coins";
+var LOCAL_CACHE_TTL = 60 * 60 * 4;
+var { fromPartial: QueryAllBurnedCoinsRequestFromPartial } = bze2.burner.QueryAllBurnedCoinsRequest;
+var getBurnerParams = async () => {
+  try {
+    const client = await getRestClient();
+    return getBurnerParamsWithClient(client);
+  } catch (error) {
+    console.error("failed to get burner params: ", error);
+  }
+  return void 0;
+};
+var getBurnerParamsWithClient = async (client) => {
+  try {
+    const response = await client.bze.burner.params();
+    return response.params;
+  } catch (error) {
+    console.error("failed to get burner params: ", error);
+  }
+  return void 0;
+};
+async function getAllBurnedCoins() {
+  try {
+    const localData = getFromLocalStorage(BURNED_KEY);
+    if (null !== localData) {
+      const parsed = JSON.parse(localData);
+      if (parsed) {
+        return parsed;
+      }
+    }
+    const client = await getRestClient();
+    const response = await client.bze.burner.allBurnedCoins(
+      QueryAllBurnedCoinsRequestFromPartial({
+        pagination: PageRequest2.fromPartial({ reverse: true })
+      })
+    );
+    setInLocalStorage(BURNED_KEY, JSON.stringify(response), LOCAL_CACHE_TTL);
+    return response;
+  } catch (e) {
+    console.error(e);
+    return {
+      burnedCoins: []
+    };
+  }
+}
+
+// src/utils/validation.ts
+function isValidUrl(urlString) {
+  try {
+    const url = new URL(urlString);
+    return url.protocol === "http:" || url.protocol === "https:" || url.protocol === "ws:" || url.protocol === "wss:";
+  } catch (e) {
+    return false;
+  }
+}
+async function validateRestEndpoint(endpoint) {
+  if (!endpoint.trim()) {
+    return { isValid: false, error: VALIDATION_ERRORS.EMPTY_ENDPOINT };
+  }
+  if (!isValidUrl(endpoint)) {
+    return { isValid: false, error: VALIDATION_ERRORS.INVALID_URL };
+  }
+  const url = new URL(endpoint);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return { isValid: false, error: VALIDATION_ERRORS.INVALID_REST_PROTOCOL };
+  }
+  try {
+    const client = await createRestClient(endpoint);
+    const params = await getBurnerParamsWithClient(client);
+    if (params) {
+      return { isValid: true };
+    }
+    return { isValid: false, error: VALIDATION_ERRORS.CORS_ERROR };
+  } catch (error) {
+    console.error(error);
+    return { isValid: false, error: VALIDATION_ERRORS.NETWORK_ERROR };
+  }
+}
+async function validateRpcEndpoint(endpoint) {
+  if (!endpoint.trim()) {
+    return { isValid: false, error: VALIDATION_ERRORS.EMPTY_ENDPOINT };
+  }
+  if (!isValidUrl(endpoint)) {
+    return { isValid: false, error: VALIDATION_ERRORS.INVALID_URL };
+  }
+  const wsEndpoint = convertToWebSocketUrl(endpoint);
+  const url = new URL(wsEndpoint);
+  if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    return { isValid: false, error: VALIDATION_ERRORS.INVALID_RPC_PROTOCOL };
+  }
+  try {
+    const isConnectable = await testWebSocketConnection(wsEndpoint);
+    if (isConnectable) {
+      return { isValid: true };
+    } else {
+      return { isValid: false, error: VALIDATION_ERRORS.WEBSOCKET_ERROR };
+    }
+  } catch (error) {
+    console.error("WebSocket validation error:", error);
+    return { isValid: false, error: VALIDATION_ERRORS.NETWORK_ERROR };
+  }
+}
+function testWebSocketConnection(endpoint) {
+  return new Promise((resolve) => {
+    const ws = new WebSocket(`${endpoint}/websocket`);
+    const timeout = setTimeout(() => {
+      ws.close();
+      resolve(false);
+    }, 5e3);
+    ws.onopen = () => {
+      clearTimeout(timeout);
+      ws.close();
+      resolve(true);
+    };
+    ws.onerror = () => {
+      clearTimeout(timeout);
+      resolve(false);
+    };
+    ws.onclose = (event) => {
+      clearTimeout(timeout);
+      if (event.wasClean) {
+        resolve(true);
+      }
+    };
+  });
+}
+async function validateEndpoints(restEndpoint, rpcEndpoint) {
+  const [restResult, rpcResult] = await Promise.all([
+    validateRestEndpoint(restEndpoint),
+    validateRpcEndpoint(rpcEndpoint)
+  ]);
+  return {
+    rest: restResult,
+    rpc: rpcResult,
+    isValid: restResult.isValid && rpcResult.isValid
+  };
+}
+function convertToWebSocketUrl(url) {
+  try {
+    const parsedUrl = new URL(url);
+    if (parsedUrl.protocol === "http:") {
+      parsedUrl.protocol = "ws:";
+    } else if (parsedUrl.protocol === "https:") {
+      parsedUrl.protocol = "wss:";
+    }
+    return parsedUrl.toString();
+  } catch (error) {
+    console.warn("Failed to parse URL for WebSocket conversion:", error);
+    return url;
+  }
+}
+
+// src/utils/validator.ts
+var getValidatorSupportedDenoms = () => {
+  const denoms = process.env.NEXT_PUBLIC_ATONE_VALIDATOR_SUPPORTED_DENOMS || "";
+  return denoms.split(",").map((d) => d.trim()).filter((d) => d.length > 0);
+};
+var getValidatorPageUrl = () => {
+  return process.env.NEXT_PUBLIC_ATONE_VALIDATOR_PAGE_URL || "";
+};
+var isPoolSupportedByValidator = (baseDenom, quoteDenom) => {
+  const supportedDenoms = getValidatorSupportedDenoms();
+  return supportedDenoms.includes(baseDenom) || supportedDenoms.includes(quoteDenom);
+};
+
+// src/constants/endpoints.ts
+function getRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL || "";
+}
+function getRpcURL() {
+  return process.env.NEXT_PUBLIC_RPC_URL || "";
+}
+function getArchwayRpcURL() {
+  return process.env.NEXT_PUBLIC_RPC_URL_ARCHWAY || "";
+}
+function getOsmosisRpcUrl() {
+  return process.env.NEXT_PUBLIC_RPC_URL_OSMOSIS || "";
+}
+function getNobleRpcUrl() {
+  return process.env.NEXT_PUBLIC_RPC_URL_NOBLE || "";
+}
+function getJackalRpcUrl() {
+  return process.env.NEXT_PUBLIC_RPC_URL_JACKAL || "";
+}
+function getOmniFlixRpcUrl() {
+  return process.env.NEXT_PUBLIC_RPC_URL_FLIX || "";
+}
+function getAtomOneRpcUrl() {
+  return process.env.NEXT_PUBLIC_RPC_URL_ATOMONE || "";
+}
+function getArchwayRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_ARCHWAY || "";
+}
+function getOsmosisRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_OSMOSIS || "";
+}
+function getNobleRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_NOBLE || "";
+}
+function getJackalRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_JACKAL || "";
+}
+function getOmniFlixRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_FLIX || "";
+}
+function getAtomOneRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_ATOMONE || "";
+}
+var getAggregatorHost = () => {
+  var _a2;
+  return (_a2 = process.env.NEXT_PUBLIC_AGG_API_HOST) != null ? _a2 : "https://getbze.com";
+};
+
+// src/constants/market.ts
+var EXCLUDED_MARKETS = {
+  "factory/bze1f0qgels0eu96ev6a67znu70q7rquy9eragn8nw/ucorey/factory/bze13gzq40che93tgfm9kzmkpjamah5nj0j73pyhqk/uvdl": true,
+  "factory/bze1f0qgels0eu96ev6a67znu70q7rquy9eragn8nw/ucorey/ubze": true
+};
+
+// src/constants/ecosystem.ts
+import { LuGlobe, LuCoins, LuChartColumn, LuFlame, LuFactory } from "react-icons/lu";
+var ECOSYSTEM_MENU_LABEL = "Other";
+var ALL_APPS = [
+  { name: "Website", href: "https://getbze.com", disabled: false, icon: LuGlobe },
+  { name: "Staking", href: "https://staking.getbze.com", disabled: false, icon: LuCoins },
+  { name: "DEX", href: "https://dex.getbze.com", disabled: false, icon: LuChartColumn },
+  { name: "Burner", href: "https://burner.getbze.com", disabled: false, icon: LuFlame },
+  { name: "Factory", href: "#", disabled: true, icon: LuFactory }
+];
+var getEcosystemApps = () => {
+  const currentHost = process.env.NEXT_PUBLIC_SITE_URL || "";
+  if (!currentHost) {
+    return ALL_APPS;
+  }
+  return ALL_APPS.filter((app) => app.href !== currentHost);
+};
+
+// src/constants/keplr.ts
+var MAINNET_CHAIN_INFO_FALLBACK = {
+  "chainId": "beezee-1",
+  "chainName": "BeeZee",
+  "chainSymbolImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/beezee/chain.png",
+  "rpc": "https://rpc.getbze.com",
+  "rest": "https://rest.getbze.com",
+  "nodeProvider": {
+    "name": "BZE Alpha Team",
+    "email": "alphateam@getbze.com",
+    "website": "https://getbze.com"
+  },
+  "stakeCurrency": {
+    "coinDenom": "BZE",
+    "coinMinimalDenom": "ubze",
+    "coinDecimals": 6,
+    "coinGeckoId": "bzedge",
+    "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/beezee/chain.png"
+  },
+  "bip44": {
+    "coinType": 118
+  },
+  "bech32Config": {
+    "bech32PrefixAccAddr": "bze",
+    "bech32PrefixAccPub": "bzepub",
+    "bech32PrefixValAddr": "bzevaloper",
+    "bech32PrefixValPub": "bzevaloperpub",
+    "bech32PrefixConsAddr": "bzevalcons",
+    "bech32PrefixConsPub": "bzevalconspub"
+  },
+  "currencies": [
+    {
+      "coinDenom": "BZE",
+      "coinMinimalDenom": "ubze",
+      "coinDecimals": 6,
+      "coinGeckoId": "bzedge",
+      "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/beezee/chain.png"
+    },
+    {
+      "coinDenom": "VDL",
+      "coinMinimalDenom": "factory/bze13gzq40che93tgfm9kzmkpjamah5nj0j73pyhqk/uvdl",
+      "coinDecimals": 6,
+      "coinGeckoId": "vidulum",
+      "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/beezee/factory/bze13gzq40che93tgfm9kzmkpjamah5nj0j73pyhqk/uvdl.png"
+    }
+  ],
+  "feeCurrencies": [{
+    "coinDenom": "BZE",
+    "coinMinimalDenom": "ubze",
+    "coinDecimals": 6,
+    "coinGeckoId": "bzedge",
+    "gasPriceStep": {
+      "low": 1e-3,
+      "average": 0.01,
+      "high": 0.1
+    },
+    "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/beezee/chain.png"
+  }],
+  "features": []
+};
+var TESTNET_CHAIN_INFO_FALLBACK = {
+  "chainId": "bzetestnet-3",
+  "chainName": "BeeZee Testnet 3",
+  "chainSymbolImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/bzetestnet/chain.png",
+  "rpc": "https://testnet-rpc.getbze.com",
+  "rest": "https://testnet.getbze.com",
+  "nodeProvider": {
+    "name": "BZE Alpha Team",
+    "email": "alphateam@getbze.com",
+    "website": "https://getbze.com"
+  },
+  "stakeCurrency": {
+    "coinDenom": "TBZE",
+    "coinMinimalDenom": "ubze",
+    "coinDecimals": 6,
+    "coinGeckoId": "bzedge",
+    "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/bzetestnet/chain.png"
+  },
+  "bip44": {
+    "coinType": 118
+  },
+  "bech32Config": {
+    "bech32PrefixAccAddr": "bze",
+    "bech32PrefixAccPub": "bzepub",
+    "bech32PrefixValAddr": "bzevaloper",
+    "bech32PrefixValPub": "bzevaloperpub",
+    "bech32PrefixConsAddr": "bzevalcons",
+    "bech32PrefixConsPub": "bzevalconspub"
+  },
+  "currencies": [
+    {
+      "coinDenom": "TBZE",
+      "coinMinimalDenom": "ubze",
+      "coinDecimals": 6,
+      "coinGeckoId": "bzedge",
+      "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/bzetestnet/chain.png"
+    },
+    {
+      "coinDenom": "TVDL",
+      "coinMinimalDenom": "factory/bze1z3mkcr2jz424w6m49frgjmy9uhlrx69phqwg3l/vidulum",
+      "coinDecimals": 6,
+      "coinGeckoId": "vidulum",
+      "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/bzetestnet/factory/testbz1z3mkcr2jz424w6m49frgjmy9uhlrx69p4cvrgf/vidulum.png"
+    }
+  ],
+  "feeCurrencies": [{
+    "coinDenom": "TBZE",
+    "coinMinimalDenom": "ubze",
+    "coinDecimals": 6,
+    "coinGeckoId": "bzedge",
+    "gasPriceStep": {
+      "low": 1e-3,
+      "average": 0.01,
+      "high": 0.1
+    },
+    "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/bzetestnet/chain.png"
+  }],
+  "features": []
+};
+
+// src/service/amm_router.ts
+var AmmRouter = class _AmmRouter {
+  constructor() {
+    this.routeCache = /* @__PURE__ */ new Map();
+    this.routeMap = /* @__PURE__ */ new Map();
+  }
+  static getInstance() {
+    if (!_AmmRouter.instance) {
+      _AmmRouter.instance = new _AmmRouter();
+    }
+    return _AmmRouter.instance;
+  }
+  updatePools(pools) {
+    this.routeMap = this.mapLiquidityPoolRoutes(pools);
+    this.clearCache();
+  }
+  mapLiquidityPoolRoutes(pools) {
+    const routeMap = /* @__PURE__ */ new Map();
+    for (const pool of pools) {
+      if (!routeMap.has(pool.base)) {
+        routeMap.set(pool.base, /* @__PURE__ */ new Map());
+      }
+      routeMap.get(pool.base).set(pool.quote, pool);
+      if (!routeMap.has(pool.quote)) {
+        routeMap.set(pool.quote, /* @__PURE__ */ new Map());
+      }
+      routeMap.get(pool.quote).set(pool.base, pool);
+    }
+    return routeMap;
+  }
+  findOptimalRoute(fromDenom, toDenom, amountIn, maxHops, useCache = true) {
+    const cacheKey = this.getCacheKey(fromDenom, toDenom, maxHops);
+    if (useCache) {
+      const cached = this.routeCache.get(cacheKey);
+      if (cached) {
+        return __spreadValues(__spreadValues({}, cached.result), this.calculateRouteOutput(cached.result.pools, cached.result.path, amountIn));
+      }
+    }
+    const result = this.findOptimalSwapRoute(fromDenom, toDenom, amountIn, maxHops);
+    if (result) {
+      this.routeCache.set(cacheKey, {
+        result,
+        timestamp: Date.now()
+      });
+    }
+    return result;
+  }
+  calculateRouteOutput(pools, path, amountIn) {
+    let currentAmount = amountIn;
+    const fees = [];
+    for (let i = 0; i < pools.length; i++) {
+      const pool = pools[i];
+      const currentDenom = path[i];
+      const isBaseToQuote = pool.base === currentDenom;
+      const { amountOut, fee } = this.calculateSwapOutput(pool, currentAmount, isBaseToQuote);
+      fees.push(fee);
+      currentAmount = amountOut;
+    }
+    const expectedOutput = currentAmount;
+    const theoretical = this.calculateTheoreticalOutputs(pools, path, amountIn);
+    const totalFees = theoretical.withoutFees.minus(theoretical.withFees);
+    const priceImpact = theoretical.withFees.isZero() ? toBigNumber(0) : theoretical.withFees.minus(expectedOutput).dividedBy(theoretical.withFees).multipliedBy(100);
+    return {
+      expectedOutput,
+      priceImpact,
+      totalFees,
+      feesPerHop: fees
+    };
+  }
+  clearCache(filter) {
+    if (!filter) {
+      this.routeCache.clear();
+      return;
+    }
+    for (const [key, cache] of this.routeCache.entries()) {
+      if (filter(key, cache)) {
+        this.routeCache.delete(key);
+      }
+    }
+  }
+  getCacheStats() {
+    return {
+      size: this.routeCache.size,
+      keys: Array.from(this.routeCache.keys())
+    };
+  }
+  calculateTheoreticalOutputs(pools, path, amountIn) {
+    let theoreticalOutputNoFees = amountIn;
+    let theoreticalOutputWithFees = amountIn;
+    for (let i = 0; i < pools.length; i++) {
+      const pool = pools[i];
+      const currentDenom = path[i];
+      const isBaseToQuote = pool.base === currentDenom;
+      const reserveIn = toBigNumber(isBaseToQuote ? pool.reserve_base : pool.reserve_quote);
+      const reserveOut = toBigNumber(isBaseToQuote ? pool.reserve_quote : pool.reserve_base);
+      const midPrice = reserveOut.dividedBy(reserveIn);
+      theoreticalOutputNoFees = theoreticalOutputNoFees.multipliedBy(midPrice);
+      const fee = toBigNumber(pool.fee);
+      theoreticalOutputWithFees = theoreticalOutputWithFees.multipliedBy(toBigNumber(1).minus(fee)).multipliedBy(midPrice);
+    }
+    return {
+      withoutFees: theoreticalOutputNoFees,
+      withFees: theoreticalOutputWithFees
+    };
+  }
+  calculateSwapOutput(pool, amountIn, isBaseToQuote) {
+    const fee = toBigNumber(pool.fee);
+    const reserveIn = toBigNumber(isBaseToQuote ? pool.reserve_base : pool.reserve_quote);
+    const reserveOut = toBigNumber(isBaseToQuote ? pool.reserve_quote : pool.reserve_base);
+    const feeAmount = amountIn.multipliedBy(fee);
+    const amountInAfterFee = amountIn.minus(feeAmount);
+    const amountOut = amountInAfterFee.multipliedBy(reserveOut).dividedBy(reserveIn.plus(amountInAfterFee));
+    return { amountOut, fee: feeAmount };
+  }
+  findOptimalSwapRoute(fromDenom, toDenom, amountIn, maxHops) {
+    if (fromDenom === toDenom) {
+      return null;
+    }
+    const queue = [{
+      denom: fromDenom,
+      amount: amountIn,
+      path: [fromDenom],
+      poolIds: [],
+      pools: [],
+      fees: [],
+      hops: 0
+    }];
+    const bestAmounts = /* @__PURE__ */ new Map();
+    bestAmounts.set(fromDenom, amountIn);
+    let bestRoute = null;
+    while (queue.length > 0) {
+      queue.sort((a, b) => {
+        var _a2;
+        return (_a2 = b.amount.comparedTo(a.amount)) != null ? _a2 : 0;
+      });
+      const current = queue.shift();
+      if (current.denom === toDenom) {
+        if (!bestRoute || current.amount.isGreaterThan(bestRoute.amount)) {
+          bestRoute = current;
+        }
+        continue;
+      }
+      if (current.hops >= maxHops) {
+        continue;
+      }
+      const neighbors = this.routeMap.get(current.denom);
+      if (!neighbors) continue;
+      for (const [nextDenom, pool] of neighbors.entries()) {
+        if (current.path.includes(nextDenom)) {
+          continue;
+        }
+        const isBaseToQuote = pool.base === current.denom;
+        const { amountOut, fee } = this.calculateSwapOutput(pool, current.amount, isBaseToQuote);
+        if (amountOut.lte(0)) {
+          continue;
+        }
+        const previousBest = bestAmounts.get(nextDenom);
+        if (previousBest && amountOut.lte(previousBest)) {
+          continue;
+        }
+        bestAmounts.set(nextDenom, amountOut);
+        queue.push({
+          denom: nextDenom,
+          amount: amountOut,
+          path: [...current.path, nextDenom],
+          poolIds: [...current.poolIds, pool.id],
+          pools: [...current.pools, pool],
+          fees: [...current.fees, fee],
+          hops: current.hops + 1
+        });
+      }
+    }
+    if (!bestRoute) {
+      return null;
+    }
+    const theoretical = this.calculateTheoreticalOutputs(bestRoute.pools, bestRoute.path, amountIn);
+    const totalFees = theoretical.withoutFees.minus(theoretical.withFees);
+    const priceImpact = theoretical.withFees.isZero() ? toBigNumber(0) : theoretical.withFees.minus(bestRoute.amount).dividedBy(theoretical.withFees).multipliedBy(100);
+    return {
+      route: bestRoute.poolIds,
+      path: bestRoute.path,
+      pools: bestRoute.pools,
+      expectedOutput: bestRoute.amount,
+      priceImpact,
+      totalFees,
+      feesPerHop: bestRoute.fees
+    };
+  }
+  getCacheKey(fromDenom, toDenom, maxHops) {
+    return `${fromDenom}_${toDenom}_${maxHops}`;
+  }
+};
+var ammRouter = AmmRouter.getInstance();
+
+// src/service/blockchain_event_manager.ts
+var BlockchainEventManager = class _BlockchainEventManager {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  static getInstance() {
+    if (!_BlockchainEventManager.instance) {
+      _BlockchainEventManager.instance = new _BlockchainEventManager();
+    }
+    return _BlockchainEventManager.instance;
+  }
+  subscribe(eventType, callback) {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(eventType).add(callback);
+    return () => {
+      const handlers = this.listeners.get(eventType);
+      if (handlers) {
+        handlers.delete(callback);
+        if (handlers.size === 0) {
+          this.listeners.delete(eventType);
+        }
+      }
+    };
+  }
+  emit(eventType, event) {
+    const generalListeners = this.listeners.get(eventType);
+    if (generalListeners) {
+      generalListeners.forEach((callback) => callback(event));
+    }
+    if (!event) {
+      return;
+    }
+    if (event.marketId) {
+      const marketListeners = this.listeners.get(getMarketEventKey(eventType, event.marketId));
+      if (marketListeners) {
+        marketListeners.forEach((callback) => callback(event));
+      }
+    }
+  }
+};
+var blockchainEventManager = BlockchainEventManager.getInstance();
+
+// src/query/supply.ts
+import { QueryDenomsMetadataRequest, QueryTotalSupplyRequest } from "@bze/bzejs/cosmos/bank/v1beta1/query";
+var { fromPartial: TotalSupplyRequest } = QueryTotalSupplyRequest;
+var { fromPartial: MetadataRequest } = QueryDenomsMetadataRequest;
+var DEFAULT_LIMIT = 200;
+var getAllSupply = async () => {
+  try {
+    const client = await getRestClient();
+    const resp = await client.cosmos.bank.v1beta1.totalSupply(
+      TotalSupplyRequest(
+        { pagination: getPageRequestWithLimit(DEFAULT_LIMIT) }
+      )
+    );
+    return resp.supply;
+  } catch (error) {
+    console.error("failed to get supply: ", error);
+  }
+  return void 0;
+};
+var getAllSupplyMetadata = async () => {
+  try {
+    const client = await getRestClient();
+    const resp = await client.cosmos.bank.v1beta1.denomsMetadata(MetadataRequest({
+      pagination: getPageRequestWithLimit(DEFAULT_LIMIT)
+    }));
+    return resp.metadatas;
+  } catch (error) {
+    console.error("failed to get supply metadata: ", error);
+  }
+  return void 0;
+};
+
+// src/service/assets_factory.ts
+import { getExponentByDenomFromAsset } from "@chain-registry/utils";
+
+// src/query/ibc.ts
+var TRACES_CACHE_KEY = "ibc:traces";
+var TRACES_CACHE_TTL = 5 * 60;
+var HASH_TRACE_CACHE_TTL = 0;
+var IBC_COUNTERPARTY_CACHE_TTL = 0;
+var DEFAULT_LIMIT2 = 1e3;
+var getDenomTracesUrl = (limit) => {
+  const settings = getSettings();
+  return `${settings.endpoints.restEndpoint}/ibc/apps/transfer/v1/denom_traces?pagination.limit=${limit}`;
+};
+var getHashDenomTracesUrl = (hash) => {
+  const settings = getSettings();
+  return `${settings.endpoints.restEndpoint}/ibc/apps/transfer/v1/denom_traces/${hash}`;
+};
+var getIBCTraces = async () => {
+  const cached = getFromLocalStorage(TRACES_CACHE_KEY);
+  if (cached) {
+    return JSON.parse(cached);
+  }
+  try {
+    const resp = await fetch(getDenomTracesUrl(DEFAULT_LIMIT2));
+    if (resp.status !== 200) {
+      console.error("failed to fetch denom traces. status: ", resp.status);
+      return [];
+    }
+    const responseJson = await resp.json();
+    if (!responseJson.denom_traces) {
+      return [];
+    }
+    setInLocalStorage(TRACES_CACHE_KEY, JSON.stringify(responseJson.denom_traces), TRACES_CACHE_TTL);
+    return responseJson.denom_traces;
+  } catch (e) {
+    console.error("[IBC] failed to fetch denom traces", e);
+    return [];
+  }
+};
+var createHashTraceCacheKey = (hash) => {
+  return `${TRACES_CACHE_KEY}:${hash}`;
+};
+var getHashIBCTrace = async (hash) => {
+  const cacheKey = createHashTraceCacheKey(hash);
+  const cached = getFromLocalStorage(cacheKey);
+  if (cached) {
+    return JSON.parse(cached);
+  }
+  try {
+    const resp = await fetch(getHashDenomTracesUrl(hash));
+    if (resp.status !== 200) {
+      console.error("failed to fetch hash denom trace. status: ", resp.status);
+      return;
+    }
+    const responseJson = await resp.json();
+    if (!responseJson.denom_trace) {
+      return;
+    }
+    setInLocalStorage(cacheKey, JSON.stringify(responseJson.denom_trace), HASH_TRACE_CACHE_TTL);
+    return responseJson.denom_trace;
+  } catch (e) {
+    console.error("[IBC] failed to fetch denom traces", e);
+  }
+  return;
+};
+var getChannelIdUrl = (channelId, portId) => {
+  const settings = getSettings();
+  return `${settings.endpoints.restEndpoint}/ibc/core/channel/v1/channels/${channelId}/ports/${portId}`;
+};
+var getConnectionIdUrl = (connectionId) => {
+  const settings = getSettings();
+  return `${settings.endpoints.restEndpoint}/ibc/core/connection/v1/connections/${connectionId}`;
+};
+var getClientStateUrl = (clientId) => {
+  const settings = getSettings();
+  return `${settings.endpoints.restEndpoint}/ibc/core/client/v1/client_states/${clientId}`;
+};
+var getIbcCounterpartyChainIdCacheKey = (channelId, portId) => {
+  return `ibc:counterparty:${channelId}:${portId}`;
+};
+var counterpartyChainForChannel = async (channelId, portId = "transfer") => {
+  var _a2, _b2, _c, _d, _e, _f, _g, _h;
+  const cacheKey = getIbcCounterpartyChainIdCacheKey(channelId, portId);
+  const cached = getFromLocalStorage(cacheKey);
+  if (cached) {
+    return JSON.parse(cached);
+  }
+  const result = {
+    chainId: "",
+    channelId: ""
+  };
+  try {
+    const chRes = await fetch(getChannelIdUrl(channelId, portId));
+    if (!chRes.ok) {
+      console.error(`[counterpartyChainForChannel] channel fetch failed: ${chRes.status} ${chRes.statusText}`);
+      return void 0;
+    }
+    const chJson = await chRes.json();
+    const connectionId = (_b2 = (_a2 = chJson == null ? void 0 : chJson.channel) == null ? void 0 : _a2.connection_hops) == null ? void 0 : _b2[0];
+    result.channelId = (_d = (_c = chJson == null ? void 0 : chJson.channel) == null ? void 0 : _c.counterparty) == null ? void 0 : _d.channel_id;
+    if (!connectionId || !result.channelId) {
+      console.error(`[counterpartyChainForChannel] no connection_hops for ${channelId}/${portId}`);
+      return void 0;
+    }
+    const connRes = await fetch(getConnectionIdUrl(connectionId));
+    if (!connRes.ok) {
+      console.error(`[counterpartyChainForChannel] connection fetch failed: ${connRes.status} ${connRes.statusText}`);
+      return void 0;
+    }
+    const connJson = await connRes.json();
+    const clientId = (_e = connJson == null ? void 0 : connJson.connection) == null ? void 0 : _e.client_id;
+    if (!clientId) {
+      console.error(`[counterpartyChainForChannel] no client_id on ${connectionId}`);
+      return void 0;
+    }
+    const csRes = await fetch(getClientStateUrl(clientId));
+    if (!csRes.ok) {
+      console.error(`[counterpartyChainForChannel] client_state fetch failed: ${csRes.status} ${csRes.statusText}`);
+      return void 0;
+    }
+    const csJson = await csRes.json();
+    const clientState = (_g = (_f = csJson == null ? void 0 : csJson.client_state) == null ? void 0 : _f.value) != null ? _g : csJson == null ? void 0 : csJson.client_state;
+    const chainId = (_h = clientState == null ? void 0 : clientState.chain_id) != null ? _h : clientState == null ? void 0 : clientState.chainId;
+    if (!chainId) {
+      console.error(`[counterpartyChainForChannel] chain_id missing in client_state for ${clientId}`);
+      return void 0;
+    }
+    result.chainId = chainId;
+    setInLocalStorage(cacheKey, JSON.stringify(result), IBC_COUNTERPARTY_CACHE_TTL);
+    return result;
+  } catch (err) {
+    console.error("[counterpartyChainForChannel] unexpected error:", err);
+    return void 0;
+  }
+};
+
+// src/service/assets_factory.ts
+var ORIGIN_CHAIN_PLACEHOLDER = "Unknown chain";
+var getChainAssets = async () => {
+  const [metadata, supply] = await Promise.all([getAllMetadataMap(), getAllSupply()]);
+  const result = {
+    assets: /* @__PURE__ */ new Map(),
+    ibcData: /* @__PURE__ */ new Map()
+  };
+  if (!metadata || !supply) {
+    return result;
+  }
+  const filtered = supply.filter((asset) => !EXCLUDED_ASSETS[asset.denom]);
+  const lpAssets = [];
+  for (const asset of filtered) {
+    const baseAsset = createAsset(asset.denom, BigInt(asset.amount));
+    if (isLpDenom(asset.denom)) {
+      lpAssets.push(baseAsset);
+      continue;
+    }
+    let finalAsset = await populateAssetFromChainRegistry(baseAsset);
+    if (!finalAsset) {
+      const metadataEntry = metadata[asset.denom];
+      finalAsset = populateAssetFromBlockchainMetadata(baseAsset, metadataEntry);
+    }
+    result.assets.set(finalAsset.denom, finalAsset);
+    if (isIbcDenom(finalAsset.denom) && finalAsset.IBCData && finalAsset.IBCData.chain.channelId !== "") {
+      result.ibcData.set(finalAsset.IBCData.chain.channelId, finalAsset.IBCData);
+    }
+  }
+  for (const lpAsset of lpAssets) {
+    const split = lpAsset.denom.split("_");
+    if (split.length !== 3) {
+      continue;
+    }
+    const baseAsset = result.assets.get(split[1]);
+    const quoteAsset = result.assets.get(split[2]);
+    if (!baseAsset || !quoteAsset) {
+      result.assets.set(lpAsset.denom, lpAsset);
+      continue;
+    }
+    lpAsset.name = `${baseAsset.ticker}/${quoteAsset.ticker} LP Shares`;
+    lpAsset.ticker = `${baseAsset.ticker}/${quoteAsset.ticker} LP`;
+    lpAsset.verified = true;
+    lpAsset.decimals = LP_ASSETS_DECIMALS;
+    result.assets.set(lpAsset.denom, lpAsset);
+  }
+  return result;
+};
+var populateIBCAsset = async (asset) => {
+  var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const ibcList = getIBCAssetList();
+  const ibcData2 = ibcList.find((item) => item.base === asset.denom);
+  if (ibcData2 && ibcData2.traces && ibcData2.traces.length > 0) {
+    const firstTrace = ibcData2.traces.find((t) => t.type === "ibc");
+    if (firstTrace) {
+      const ibcAssetChain = getChains().find((c) => c.chainName === firstTrace.counterparty.chain_name);
+      if (ibcAssetChain) {
+        asset.name = ibcData2.name;
+        asset.ticker = ibcData2.symbol.toUpperCase();
+        asset.decimals = (_a2 = getExponentByDenomFromAsset(ibcData2, ibcData2.display)) != null ? _a2 : 0;
+        asset.logo = (_e = (_d = (_b2 = ibcData2.logoURIs) == null ? void 0 : _b2.svg) != null ? _d : (_c = ibcData2.logoURIs) == null ? void 0 : _c.png) != null ? _e : TOKEN_LOGO_PLACEHOLDER;
+        asset.verified = true;
+        asset.IBCData = {
+          chain: {
+            channelId: firstTrace.chain.channel_id
+          },
+          counterparty: {
+            chainName: firstTrace.counterparty.chain_name,
+            channelId: firstTrace.counterparty.channel_id,
+            baseDenom: firstTrace.counterparty.base_denom,
+            chainPrettyName: (_f = ibcAssetChain.prettyName) != null ? _f : ibcAssetChain.chainName
+          }
+        };
+        return asset;
+      }
+    }
+  }
+  const ibcTrace = await getHashIBCTrace(asset.denom.replace("ibc/", ""));
+  if (!ibcTrace) {
+    return;
+  }
+  const splitPath = ibcTrace.path.split("/");
+  if (splitPath.length < 2) {
+    return;
+  }
+  asset.IBCData = {
+    chain: {
+      channelId: splitPath[1]
+    },
+    counterparty: {
+      chainName: "",
+      channelId: "",
+      baseDenom: "",
+      chainPrettyName: ORIGIN_CHAIN_PLACEHOLDER
+    }
+  };
+  const denomOnCounterparty = await denomOnFirstHopChainFromTrace(ibcTrace);
+  if (denomOnCounterparty) {
+    asset.IBCData.counterparty.baseDenom = denomOnCounterparty;
+  }
+  const counterPartyChain = await counterpartyChainForChannel(splitPath[1], splitPath[0]);
+  if (counterPartyChain) {
+    asset.IBCData.counterparty.channelId = counterPartyChain.channelId;
+    const fullChain = getChainByChainId(counterPartyChain.chainId);
+    if (fullChain) {
+      asset.IBCData.counterparty.chainName = fullChain.chainName;
+      asset.IBCData.counterparty.chainPrettyName = (_g = fullChain.prettyName) != null ? _g : fullChain.chainName;
+    }
+  }
+  const registryAssetChain = getAssetLists().find((item) => {
+    const a = item.assets.find((i) => i.base === ibcTrace.base_denom);
+    return !!a;
+  });
+  if (registryAssetChain) {
+    const registryAsset = registryAssetChain.assets.find((i) => i.base === ibcTrace.base_denom);
+    asset.name = registryAsset.name;
+    asset.ticker = registryAsset.symbol.toUpperCase();
+    asset.decimals = (_h = getExponentByDenomFromAsset(registryAsset, registryAsset.display)) != null ? _h : 0;
+    asset.logo = (_l = (_k = (_i = registryAsset.logoURIs) == null ? void 0 : _i.svg) != null ? _k : (_j = registryAsset.logoURIs) == null ? void 0 : _j.png) != null ? _l : TOKEN_LOGO_PLACEHOLDER;
+    asset.verified = true;
+    return asset;
+  }
+  const localAsset = await populateAssetFromBZEChainRegistryAssetList(asset);
+  if (localAsset) {
+    localAsset.verified = true;
+    return localAsset;
+  }
+  if (!ibcTrace.base_denom.includes("/")) {
+    let counterPartyDenom = ibcTrace.base_denom;
+    if (counterPartyDenom.length > 10) {
+      counterPartyDenom = truncateDenom(counterPartyDenom);
+    }
+    asset.name = counterPartyDenom;
+  }
+  asset.verified = false;
+  asset.decimals = 0;
+  return asset;
+};
+var populateAssetFromChainRegistry = async (asset) => {
+  if (isIbcDenom(asset.denom)) {
+    return populateIBCAsset(asset);
+  }
+  if (isNativeDenom(asset.denom) || isFactoryDenom(asset.denom)) {
+    return populateAssetFromBZEChainRegistryAssetList(asset);
+  }
+  return void 0;
+};
+var populateAssetFromBZEChainRegistryAssetList = async (asset) => {
+  var _a2, _b2, _c, _d, _e;
+  const data = getAssetLists().find((item) => item.chainName.toLowerCase() === getChainName().toLowerCase());
+  if (!data) {
+    return void 0;
+  }
+  const assetData = data.assets.find((item) => item.base === asset.denom);
+  if (!assetData) {
+    return void 0;
+  }
+  asset.decimals = (_a2 = getExponentByDenomFromAsset(assetData, assetData.display)) != null ? _a2 : 0;
+  asset.name = assetData.name;
+  asset.ticker = assetData.display.toUpperCase();
+  asset.logo = isNativeDenom(asset.denom) ? BZE_CIRCLE_LOGO : (_e = (_d = (_b2 = assetData.logoURIs) == null ? void 0 : _b2.svg) != null ? _d : (_c = assetData.logoURIs) == null ? void 0 : _c.png) != null ? _e : TOKEN_LOGO_PLACEHOLDER;
+  return asset;
+};
+var populateAssetFromBlockchainMetadata = (asset, meta) => {
+  if (!meta || meta.base !== asset.denom) {
+    return asset;
+  }
+  if (meta.name.length > 0) {
+    asset.name = meta.name;
+  }
+  if (meta.symbol.length > 0) {
+    asset.ticker = meta.symbol.toUpperCase();
+  }
+  if (meta.denom_units.length === 0) {
+    return asset;
+  }
+  meta.denom_units.map((unit) => {
+    if (unit.denom === meta.display) {
+      asset.decimals = unit.exponent;
+      asset.ticker = unit.denom.toUpperCase();
+    }
+  });
+  return asset;
+};
+var createAsset = (denom, supply) => {
+  var _a2, _b2;
+  return {
+    denom,
+    type: getDenomType(denom),
+    name: truncateDenom(denom),
+    ticker: truncateDenom(denom),
+    decimals: 0,
+    logo: TOKEN_LOGO_PLACEHOLDER,
+    stable: (_a2 = STABLE_COINS[denom]) != null ? _a2 : false,
+    verified: (_b2 = VERIFIED_ASSETS[denom]) != null ? _b2 : false,
+    supply
+  };
+};
+var getAllMetadataMap = async () => {
+  const allMetadata = await getAllSupplyMetadata();
+  if (!allMetadata) {
+    return {};
+  }
+  return allMetadata.reduce((acc, asset) => {
+    acc[asset.base] = asset;
+    return acc;
+  }, {});
+};
+
+// src/service/keplr.ts
+async function getKeplrMainnetChainInfo() {
+  const localKey = "ci:keplr:mainnet";
+  const cachedData = getFromLocalStorage(localKey);
+  if (cachedData) {
+    return JSON.parse(cachedData);
+  }
+  const url = "https://raw.githubusercontent.com/faneaatiku/keplr-chain-registry/main/cosmos/beezee.json";
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      console.error(`HTTP error when fetching mainnet keplr data. status: ${response.status}`);
+      return MAINNET_CHAIN_INFO_FALLBACK;
+    }
+    const json = await response.json();
+    setInLocalStorage(localKey, JSON.stringify(json), 60 * 60 * 24);
+    return json;
+  } catch (error) {
+    console.error(`Error fetching mainnet keplr data from ${url}:`, error);
+    return MAINNET_CHAIN_INFO_FALLBACK;
+  }
+}
+async function getKeplrTestnetChainInfo() {
+  const localKey = "ci:keplr:testnet";
+  const cachedData = getFromLocalStorage(localKey);
+  if (cachedData) {
+    return JSON.parse(cachedData);
+  }
+  const url = "https://raw.githubusercontent.com/faneaatiku/keplr-chain-registry/refs/heads/patch-2/cosmos/bzetestnet.json";
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      console.error(`HTTP error when fetching testnet keplr data. status: ${response.status}`);
+      return TESTNET_CHAIN_INFO_FALLBACK;
+    }
+    const json = await response.json();
+    setInLocalStorage(localKey, JSON.stringify(json), 60 * 60 * 24);
+    return json;
+  } catch (error) {
+    console.error(`Error fetching testnet keplr data from ${url}:`, error);
+    return TESTNET_CHAIN_INFO_FALLBACK;
+  }
+}
+async function getKeplrChainInfo(chainId) {
+  if (chainId !== "beezee") {
+    return getKeplrTestnetChainInfo();
+  }
+  return getKeplrMainnetChainInfo();
+}
+async function keplrSuggestChain(chainId) {
+  var _a2;
+  return await ((_a2 = window.keplr) == null ? void 0 : _a2.experimentalSuggestChain(await getKeplrChainInfo(chainId)));
+}
+
+// src/query/bank.ts
+async function getAddressBalances(address) {
+  try {
+    const client = await getRestClient();
+    const response = await client.cosmos.bank.v1beta1.spendableBalances({ address });
+    return response.balances;
+  } catch (e) {
+    console.error("failed to get balances", e);
+    return [];
+  }
+}
+async function getLockedBalances() {
+  try {
+    const lockerAddress = getLockerAddress();
+    if (!lockerAddress) {
+      console.warn("Locker address not configured");
+      return [];
+    }
+    return await getAddressBalances(lockerAddress);
+  } catch (e) {
+    console.error("failed to get locked balances", e);
+    return [];
+  }
+}
+
+// src/query/epoch.ts
+var EPOCH_HOUR = "hour";
+var EPOCH_DAY = "day";
+var EPOCH_WEEK = "week";
+var EPOCHS_INFO_CACHE_KEY = "epochs:info";
+var EPOCHS_INFO_CACHE_TTL = 60 * 60;
+async function getEpochsInfo() {
+  try {
+    const cachedData = getFromLocalStorage(EPOCHS_INFO_CACHE_KEY);
+    let shouldFetchFromEndpoint = false;
+    if (cachedData !== null) {
+      const cached = JSON.parse(cachedData);
+      const now = (/* @__PURE__ */ new Date()).getTime();
+      for (const epoch of cached.epochs) {
+        if (epoch.current_epoch_start_time) {
+          const startTime = new Date(epoch.current_epoch_start_time).getTime();
+          const duration = getEpochDurationByIdentifier(epoch.identifier);
+          const epochEndTime = startTime + duration - 15 * 1e3;
+          if (now >= epochEndTime) {
+            shouldFetchFromEndpoint = true;
+            break;
+          }
+        }
+      }
+      if (!shouldFetchFromEndpoint) {
+        return cached;
+      }
+    }
+    const client = await getRestClient();
+    const response = await client.bze.epochs.epochInfos();
+    setInLocalStorage(EPOCHS_INFO_CACHE_KEY, JSON.stringify(response), EPOCHS_INFO_CACHE_TTL);
+    return response;
+  } catch (e) {
+    console.error(e);
+    return { epochs: [] };
+  }
+}
+async function getCurrentEpoch(identifier) {
+  const all = await getEpochsInfo();
+  return all.epochs.find((item) => item.identifier === identifier);
+}
+async function getHourEpochInfo() {
+  return getCurrentEpoch(EPOCH_HOUR);
+}
+async function getWeekEpochInfo() {
+  return getCurrentEpoch(EPOCH_WEEK);
+}
+async function getCurrentWeekEpochEndTime() {
+  return getPeriodicEpochEndTime(EPOCH_WEEK);
+}
+async function getPeriodicWeekEpochEndTime(modWeek = 1) {
+  return getPeriodicEpochEndTime(EPOCH_WEEK, modWeek);
+}
+async function getPeriodicEpochEndTime(identifier, mod = 1) {
+  const epoch = await getCurrentEpoch(identifier);
+  if (!epoch || !epoch.current_epoch_start_time) {
+    return void 0;
+  }
+  const current = toBigNumber(epoch.current_epoch);
+  let remainingEpochs = mod - current.toNumber() % mod;
+  if (remainingEpochs === mod) {
+    remainingEpochs = 0;
+  }
+  const startAt = new Date(epoch.current_epoch_start_time);
+  const duration = getEpochDurationByIdentifier(identifier);
+  startAt.setTime(startAt.getTime() + duration + duration * remainingEpochs);
+  return startAt;
+}
+function getEpochDurationByIdentifier(identifier) {
+  const hourMs = 60 * 60 * 1e3;
+  switch (identifier) {
+    case EPOCH_HOUR:
+      return hourMs;
+    case EPOCH_DAY:
+      return hourMs * 24;
+    case EPOCH_WEEK:
+      return hourMs * 24 * 7;
+    default:
+      return hourMs;
+  }
+}
+
+// src/query/factory.ts
+async function getFactoryDenomAdminAddress(denom) {
+  var _a2, _b2;
+  try {
+    const client = await getRestClient();
+    const res = await client.bze.tokenfactory.denomAuthority({ denom });
+    return (_b2 = (_a2 = res.denomAuthority) == null ? void 0 : _a2.admin) != null ? _b2 : "";
+  } catch (e) {
+    console.error(e);
+    return "";
+  }
+}
+
+// src/query/liquidity_pools.ts
+import { QueryAllLiquidityPoolsRequest, QueryLiquidityPoolRequest } from "@bze/bzejs/bze/tradebin/query";
+var { fromPartial: AllLpsRequest } = QueryAllLiquidityPoolsRequest;
+var { fromPartial: LpRequest } = QueryLiquidityPoolRequest;
+var DEFAULT_LIMIT3 = 1e3;
+var getLiquidityPools = async () => {
+  try {
+    const client = await getRestClient();
+    const resp = await client.bze.tradebin.allLiquidityPools(
+      AllLpsRequest(
+        { pagination: getPageRequestWithLimit(DEFAULT_LIMIT3) }
+      )
+    );
+    return resp.list;
+  } catch (error) {
+    console.error("failed to get markets: ", error);
+  }
+  return [];
+};
+var getLiquidityPool = async (poolId) => {
+  try {
+    const client = await getRestClient();
+    const resp = await client.bze.tradebin.liquidityPool(LpRequest({
+      poolId
+    }));
+    return resp.pool;
+  } catch (error) {
+    console.error("failed to get markets: ", error);
+  }
+  return void 0;
+};
+
+// src/query/markets.ts
+import {
+  QueryAllMarketsRequest,
+  QueryMarketAggregatedOrdersRequest,
+  QueryMarketHistoryRequest,
+  QueryMarketOrderRequest,
+  QueryUserMarketOrdersRequest
+} from "@bze/bzejs/bze/tradebin/query";
+import { PageRequest as PageRequest3 } from "@bze/bzejs/cosmos/base/query/v1beta1/pagination";
+var { fromPartial: AllMarketsRequest } = QueryAllMarketsRequest;
+var { fromPartial: QueryMarketAggregatedOrdersRequestFromPartyal } = QueryMarketAggregatedOrdersRequest;
+var { fromPartial: QueryMarketHistoryRequestFromPartial } = QueryMarketHistoryRequest;
+var { fromPartial: QueryUserMarketOrdersRequestFromPartial } = QueryUserMarketOrdersRequest;
+var { fromPartial: QueryMarketOrderRequestFromPartial } = QueryMarketOrderRequest;
+var DEFAULT_LIMIT4 = 1e3;
+var getMarkets = async () => {
+  try {
+    const client = await getRestClient();
+    const resp = await client.bze.tradebin.allMarkets(
+      AllMarketsRequest(
+        { pagination: getPageRequestWithLimit(DEFAULT_LIMIT4) }
+      )
+    );
+    return resp.market;
+  } catch (error) {
+    console.error("failed to get markets: ", error);
+  }
+  return [];
+};
+async function getMarketBuyOrders(marketId) {
+  return getMarketOrders(marketId, ORDER_TYPE_BUY);
+}
+async function getMarketSellOrders(marketId) {
+  return getMarketOrders(marketId, ORDER_TYPE_SELL);
+}
+async function getMarketOrders(marketId, orderType) {
+  try {
+    const reversed = orderType === ORDER_TYPE_BUY;
+    const client = await getRestClient();
+    return client.bze.tradebin.marketAggregatedOrders(QueryMarketAggregatedOrdersRequestFromPartyal({
+      market: marketId,
+      orderType,
+      pagination: PageRequest3.fromPartial({ limit: BigInt(15), reverse: reversed })
+    }));
+  } catch (e) {
+    console.error(e);
+    return { list: [] };
+  }
+}
+async function getMarketHistory(marketId) {
+  try {
+    const client = await getRestClient();
+    return client.bze.tradebin.marketHistory(QueryMarketHistoryRequestFromPartial({
+      market: marketId,
+      pagination: PageRequest3.fromPartial({ limit: BigInt(50), reverse: true })
+    }));
+  } catch (e) {
+    console.error(e);
+    return { list: [] };
+  }
+}
+async function getAddressMarketOrders(marketId, address) {
+  try {
+    const client = await getRestClient();
+    return client.bze.tradebin.userMarketOrders(QueryUserMarketOrdersRequestFromPartial({
+      market: marketId,
+      address,
+      pagination: PageRequest3.fromPartial({ limit: BigInt(100), reverse: true })
+    }));
+  } catch (e) {
+    console.error(e);
+    return { list: [] };
+  }
+}
+async function getAddressFullMarketOrders(marketId, address) {
+  const addressOrders = await getAddressMarketOrders(marketId, address);
+  if (addressOrders.list.length === 0) {
+    return [];
+  }
+  const promises = [];
+  for (const reference of addressOrders.list) {
+    promises.push(getMarketOrder(reference.market_id, reference.order_type, reference.id));
+  }
+  const orders = await Promise.all(promises);
+  return orders.filter((item) => item !== void 0).map((resp) => resp.order);
+}
+async function getMarketOrder(marketId, orderType, orderId) {
+  try {
+    const client = await getRestClient();
+    return client.bze.tradebin.marketOrder(QueryMarketOrderRequestFromPartial({
+      market: marketId,
+      orderType,
+      orderId
+    }));
+  } catch (e) {
+    console.error(e);
+    return void 0;
+  }
+}
+
+// src/query/prices.ts
+var PRICE_PATH = "/api/prices";
+var usdPriceDenom = "usd";
+var usdPriceCacheKey = "price:usd";
+var priceCacheTtl = 5 * 60;
+var getPriceUrl = () => {
+  return `${getAggregatorHost()}${PRICE_PATH}`;
+};
+var getAssetPriceCacheKey = (asset) => {
+  return `${usdPriceCacheKey}:${asset.toLowerCase()};`;
+};
+var fetchAssetUsdPrice = async (asset) => {
+  const cacheKey = getAssetPriceCacheKey(asset);
+  const cached = getFromLocalStorage(cacheKey);
+  if (cached) {
+    return JSON.parse(cached);
+  }
+  try {
+    const resp = await fetch(getPriceUrl());
+    if (resp.status !== 200) {
+      return void 0;
+    }
+    const decodedResp = await resp.json();
+    const result = decodedResp.find((item) => item.denom.toLowerCase() === asset.toLowerCase() && item.price_denom.toLowerCase() === usdPriceDenom);
+    setInLocalStorage(cacheKey, JSON.stringify(result), priceCacheTtl);
+    return result;
+  } catch (e) {
+    console.log("error on getAssetUsdPrice: ", e);
+    return void 0;
+  }
+};
+var getBZEUSDPrice = async () => {
+  const usdPrice = await fetchAssetUsdPrice("bzedge");
+  if (!usdPrice) {
+    return 0;
+  }
+  return usdPrice.price;
+};
+
+// src/query/rewards.ts
+import { bze as bze3 } from "@bze/bzejs";
+import { PageRequest as PageRequest4 } from "@bze/bzejs/cosmos/base/query/v1beta1/pagination";
+import BigNumber6 from "bignumber.js";
+var { fromPartial: QueryAllStakingRewardRequestFromPartial } = bze3.rewards.QueryAllStakingRewardsRequest;
+var { fromPartial: QueryGetStakingRewardParticipantRequestFromPartial } = bze3.rewards.QueryStakingRewardParticipantRequest;
+var { fromPartial: QueryAllPendingUnlockParticipantRequestFromPartial } = bze3.rewards.QueryAllPendingUnlockParticipantsRequest;
+async function getStakingRewards(reverse = true) {
+  try {
+    const client = await getRestClient();
+    return await client.bze.rewards.allStakingRewards(QueryAllStakingRewardRequestFromPartial({
+      pagination: PageRequest4.fromPartial({
+        reverse,
+        limit: BigInt(1e3)
+      })
+    }));
+  } catch (e) {
+    console.error(e);
+    return { list: [] };
+  }
+}
+async function getAddressPendingUnlock(address) {
+  const all = await getPendingUnlockParticipants();
+  if (!all || all.list.length === 0) {
+    return [];
+  }
+  return all.list.filter((item) => item.address === address);
+}
+async function getPendingUnlockParticipants() {
+  try {
+    const client = await getRestClient();
+    return client.bze.rewards.allPendingUnlockParticipants(QueryAllPendingUnlockParticipantRequestFromPartial({
+      pagination: PageRequest4.fromPartial({ limit: BigInt(1e3) })
+    }));
+  } catch (e) {
+    console.error(e);
+    return { list: [] };
+  }
+}
+async function getStakingRewardParticipantByAddress(address) {
+  try {
+    const client = await getRestClient();
+    return client.bze.rewards.stakingRewardParticipant(QueryGetStakingRewardParticipantRequestFromPartial({
+      address,
+      pagination: PageRequest4.fromPartial({ limit: BigInt(500) })
+    }));
+  } catch (e) {
+    console.error(e);
+    return { list: [] };
+  }
+}
+async function getAddressStakingRewards(address) {
+  const result = {
+    address,
+    active: /* @__PURE__ */ new Map(),
+    unlocking: /* @__PURE__ */ new Map()
+  };
+  if (address === "") {
+    return result;
+  }
+  try {
+    const [participantRewards, pending] = await Promise.all([getStakingRewardParticipantByAddress(address), getAddressPendingUnlock(address)]);
+    [result.active, result.unlocking] = await Promise.all([mapParticipantRewards(participantRewards.list), mapPendingUnlock(pending)]);
+    return result;
+  } catch (e) {
+    console.error(e);
+    return result;
+  }
+}
+async function mapParticipantRewards(participantRewards) {
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < participantRewards.length; i++) {
+    result.set(participantRewards[i].reward_id, participantRewards[i]);
+  }
+  return result;
+}
+async function mapPendingUnlock(pending) {
+  var _a2;
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < pending.length; i++) {
+    const splitIndex = pending[i].index.split("/");
+    if (splitIndex.length !== 3) {
+      console.error("invalid pending unlock index", pending[i].index);
+      continue;
+    }
+    const item = __spreadProps(__spreadValues({}, pending[i]), {
+      rewardId: splitIndex[1],
+      unlockEpoch: new BigNumber6(splitIndex[0])
+    });
+    const allItems = (_a2 = result.get(item.rewardId)) != null ? _a2 : [];
+    allItems.push(item);
+    result.set(item.rewardId, allItems);
+  }
+  return result;
+}
+
+// src/query/staking.ts
+import { PageRequest as PageRequest5 } from "@bze/bzejs/cosmos/base/query/v1beta1/pagination";
+import BigNumber7 from "bignumber.js";
+var getAddressDelegations = async (address) => {
+  try {
+    const client = await getRestClient();
+    const response = await client.cosmos.staking.v1beta1.delegatorDelegations({
+      delegatorAddr: address,
+      pagination: PageRequest5.fromPartial({
+        limit: BigInt(1e3)
+      })
+    });
+    return response.delegation_responses;
+  } catch (e) {
+    console.error("failed to get address delegations", e);
+    return [];
+  }
+};
+var getAddressNativeDelegatedBalance = async (address) => {
+  const delegations = await getAddressDelegations(address);
+  const total = delegations.reduce((acc, delegation) => {
+    if (!delegation.balance) return acc;
+    if (delegation.balance.denom !== getChainNativeAssetDenom()) return acc;
+    return acc.plus(delegation.balance.amount);
+  }, new BigNumber7(0));
+  return {
+    denom: getChainNativeAssetDenom(),
+    amount: total
+  };
+};
+var getAddressUnbondingDelegations = async (address) => {
+  try {
+    const client = await getRestClient();
+    const resp = await client.cosmos.staking.v1beta1.delegatorUnbondingDelegations({
+      delegatorAddr: address,
+      pagination: PageRequest5.fromPartial({
+        limit: BigInt(1e3)
+      })
+    });
+    return resp.unbonding_responses;
+  } catch (e) {
+    console.error("failed to get address delegations", e);
+    return [];
+  }
+};
+var getAddressUnbondingDelegationsSummary = async (address) => {
+  const unbondingDelegations = await getAddressUnbondingDelegations(address);
+  let totalAmount = new BigNumber7(0);
+  let firstUnlockDate = void 0;
+  let firstUnlock = void 0;
+  unbondingDelegations.map((delegation) => {
+    delegation.entries.forEach((entry) => {
+      totalAmount = totalAmount.plus(entry.balance);
+      const entryDate = new Date(entry.completion_time);
+      if (!firstUnlockDate || entryDate < firstUnlockDate) {
+        firstUnlockDate = entryDate;
+        firstUnlock = {
+          amount: new BigNumber7(entry.balance),
+          denom: getChainNativeAssetDenom()
+        };
+      }
+    });
+  });
+  return {
+    total: {
+      amount: totalAmount,
+      denom: getChainNativeAssetDenom()
+    },
+    firstUnlock: {
+      amount: firstUnlock,
+      unlockTime: firstUnlockDate
+    }
+  };
+};
+var getAddressRewards = async (address) => {
+  try {
+    const client = await getRestClient();
+    return await client.cosmos.distribution.v1beta1.delegationTotalRewards({ delegatorAddress: address });
+  } catch (e) {
+    console.error("failed to get address rewards", e);
+    return {
+      rewards: [],
+      total: []
+    };
+  }
+};
+var getAddressNativeTotalRewards = async (address) => {
+  const rewards = await getAddressRewards(address);
+  const total = rewards.total.find((r) => r.denom === getChainNativeAssetDenom());
+  if (!total) {
+    return {
+      total: {
+        denom: getChainNativeAssetDenom(),
+        amount: new BigNumber7(0)
+      },
+      validators: []
+    };
+  }
+  const validators = [];
+  rewards.rewards.map((r) => {
+    var _a2, _b2;
+    const rewards2 = new BigNumber7((_b2 = (_a2 = r.reward.find((r2) => r2.denom === getChainNativeAssetDenom())) == null ? void 0 : _a2.amount) != null ? _b2 : "0").integerValue();
+    if (!rewards2.gt(0)) {
+      return;
+    }
+    validators.push(r.validator_address);
+  });
+  return {
+    total: {
+      denom: getChainNativeAssetDenom(),
+      amount: new BigNumber7(total.amount).integerValue()
+    },
+    validators
+  };
+};
+var getAnnualProvisions = async () => {
+  try {
+    const client = await getRestClient();
+    const resp = await client.cosmos.mint.v1beta1.annualProvisions();
+    return new BigNumber7(resp.annual_provisions).integerValue();
+  } catch (e) {
+    console.error("failed to get annual provisions", e);
+    return new BigNumber7(0);
+  }
+};
+var getDistributionParams = async () => {
+  try {
+    const client = await getRestClient();
+    const resp = await client.cosmos.distribution.v1beta1.params();
+    return resp.params;
+  } catch (e) {
+    console.error("failed to get distribution params", e);
+    return {
+      community_tax: "0.05",
+      base_proposer_reward: "0.1",
+      bonus_proposer_reward: "0.2",
+      withdraw_addr_enabled: true
+    };
+  }
+};
+var getStakingParams = async () => {
+  try {
+    const client = await getRestClient();
+    const resp = await client.cosmos.staking.v1beta1.params();
+    return resp.params;
+  } catch (e) {
+    console.error("failed to get distribution params", e);
+    return {
+      unbonding_time: "1814400s",
+      max_validators: 100,
+      max_entries: 7,
+      historical_entries: 0,
+      bond_denom: "ubze"
+    };
+  }
+};
+var getStakingPool = async () => {
+  try {
+    const client = await getRestClient();
+    const resp = await client.cosmos.staking.v1beta1.pool();
+    return resp.pool;
+  } catch (e) {
+    console.error("failed to get staking pool", e);
+    return {
+      not_bonded_tokens: "0",
+      bonded_tokens: "0"
+    };
+  }
+};
+
+// src/query/aggregator.ts
+var getAllTickersUrl = () => {
+  return `${getAggregatorHost()}/api/dex/tickers`;
+};
+var getHistoryUrl = () => {
+  return `${getAggregatorHost()}/api/dex/history`;
+};
+async function getAllTickers() {
+  try {
+    const resp = await fetch(getAllTickersUrl());
+    if (resp.status !== 200) {
+      console.error("failed to fetch tickers. status: ", resp.status);
+      return [];
+    }
+    return await resp.json();
+  } catch (e) {
+    console.error("[AGG] failed to fetch tickers", e);
+    return [];
+  }
+}
+async function getMarketOrdersHistory(marketId, limit = 1) {
+  try {
+    const url = `${getHistoryUrl()}?market_id=${marketId}&limit=${limit}`;
+    const resp = await fetch(url);
+    if (resp.status !== 200) {
+      return [];
+    }
+    return await resp.json();
+  } catch (e) {
+    console.error("[AGG] failed to fetch market orders", e);
+    return [];
+  }
+}
+async function getAddressHistory(address, market) {
+  try {
+    const url = `${getHistoryUrl()}?address=${address}&market_id=${market}&limit=100`;
+    const resp = await fetch(url);
+    if (resp.status !== 200) {
+      return [];
+    }
+    return await resp.json();
+  } catch (e) {
+    console.error("failed to fetch address orders", e);
+    return [];
+  }
+}
+async function getTradingViewIntervals(market, minutes, limit) {
+  try {
+    const url = `${getAggregatorHost()}/api/dex/intervals?market_id=${market}&minutes=${minutes}&limit=${limit}&format=tv`;
+    const resp = await fetch(url);
+    if (resp.status !== 200) {
+      return [];
+    }
+    const jsonResponse = await resp.json();
+    if (!jsonResponse) {
+      return [];
+    }
+    return jsonResponse;
+  } catch (e) {
+    console.error("failed to fetch trading view intervals", e);
+    return [];
+  }
+}
+async function getAddressSwapHistory(address) {
+  try {
+    const url = `${getAggregatorHost()}/api/dex/swaps?address=${address}`;
+    const resp = await fetch(url);
+    if (resp.status !== 200) {
+      console.error("failed to fetch swap history. status: ", resp.status);
+      return [];
+    }
+    return await resp.json();
+  } catch (e) {
+    console.error("[AGG] failed to fetch swap history", e);
+    return [];
+  }
+}
+
+// src/contexts/assets_context.ts
+import { createContext } from "react";
+var AssetsContext = createContext(void 0);
+
+// src/hooks/useAssets.ts
+import { useCallback, useContext, useMemo } from "react";
+function useAssetsContext() {
+  const context = useContext(AssetsContext);
+  if (context === void 0) {
+    throw new Error("useAssets must be used within an AssetsProvider");
+  }
+  return context;
+}
+function useAssets() {
+  const { assetsMap, isLoading } = useAssetsContext();
+  const nativeAsset = useMemo(
+    () => assetsMap.get(getChainNativeAssetDenom()),
+    [assetsMap]
+  );
+  const assets = useMemo(
+    () => Array.from(assetsMap.values()),
+    [assetsMap]
+  );
+  const isVerifiedAsset = useCallback((denom) => {
+    const asset = assetsMap.get(denom);
+    if (!asset) {
+      return false;
+    }
+    return asset.verified;
+  }, [assetsMap]);
+  const denomTicker = useCallback((denom) => {
+    const asset = assetsMap.get(denom);
+    if (!asset) {
+      return truncateDenom(denom);
+    }
+    return asset.ticker;
+  }, [assetsMap]);
+  const denomDecimals = useCallback((denom) => {
+    const asset = assetsMap.get(denom);
+    if (!asset) {
+      return 0;
+    }
+    return asset.decimals;
+  }, [assetsMap]);
+  const getAsset = useCallback((denom) => {
+    return assetsMap.get(denom);
+  }, [assetsMap]);
+  const assetsLpExcluded = useMemo(() => {
+    return assets == null ? void 0 : assets.filter((item) => !isLpDenom(item.denom));
+  }, [assets]);
+  return {
+    assets,
+    isLoading,
+    nativeAsset,
+    isVerifiedAsset,
+    denomTicker,
+    denomDecimals,
+    getAsset,
+    assetsLpExcluded
+  };
+}
+function useAsset(denom) {
+  const { assetsMap, isLoading } = useAssetsContext();
+  const asset = useMemo(
+    () => assetsMap.get(denom),
+    [assetsMap, denom]
+  );
+  return {
+    asset,
+    isLoading
+  };
+}
+function useAssetsManager() {
+  const { updateAssets, isLoading } = useAssetsContext();
+  return {
+    updateAssets,
+    isLoading
+  };
+}
+function useIBCChains() {
+  const { ibcChains, isLoading } = useAssetsContext();
+  return {
+    ibcChains,
+    isLoading
+  };
+}
+
+// src/hooks/useConnectionType.ts
+function useConnectionType() {
+  const { connectionType, updateConnectionType } = useAssetsContext();
+  return {
+    connectionType,
+    updateConnectionType
+  };
+}
+
+// src/hooks/useSigningClient.ts
+import {
+  getSigningBzeClient,
+  getSigningCosmosClient,
+  getSigningIbcClient
+} from "@bze/bzejs";
+import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo3, useRef, useState as useState2 } from "react";
+import { useChain } from "@interchain-kit/react";
+
+// src/hooks/useSettings.ts
+import { useState, useEffect, useCallback as useCallback2, useMemo as useMemo2 } from "react";
+function useSettings() {
+  const [settings, setSettingsState] = useState(DEFAULT_SETTINGS);
+  const [isLoaded, setIsLoaded] = useState(false);
+  useEffect(() => {
+    setSettingsState(getSettings());
+    setIsLoaded(true);
+  }, []);
+  const saveSettings = useCallback2((newSettings) => {
+    setSettings(newSettings);
+    setSettingsState(newSettings);
+    return true;
+  }, []);
+  const updateEndpoints = useCallback2((endpoints) => {
+    const newSettings = __spreadProps(__spreadValues({}, settings), { endpoints });
+    return saveSettings(newSettings);
+  }, [settings, saveSettings]);
+  const updatePreferredFeeDenom = useCallback2((preferredFeeDenom) => {
+    const newSettings = __spreadProps(__spreadValues({}, settings), { preferredFeeDenom });
+    return saveSettings(newSettings);
+  }, [settings, saveSettings]);
+  const resetToDefaults = useCallback2(() => {
+    saveSettings(DEFAULT_SETTINGS);
+    return true;
+  }, [saveSettings]);
+  const getEndpoints = useCallback2(() => {
+    return settings.endpoints;
+  }, [settings.endpoints]);
+  const defaultSettings = useMemo2(() => DEFAULT_SETTINGS, []);
+  const feeDenom = useMemo2(() => settings.preferredFeeDenom || getChainNativeAssetDenom(), [settings.preferredFeeDenom]);
+  return {
+    settings,
+    isLoaded,
+    saveSettings,
+    updateEndpoints,
+    updatePreferredFeeDenom,
+    resetToDefaults,
+    getEndpoints,
+    defaultSettings,
+    feeDenom
+  };
+}
+
+// src/hooks/useSigningClient.ts
+var useSigningClient = ({ chainName, isIbc, isCosmos }) => {
+  const { getSigningClient, signingClientError, wallet, chain } = useChain(chainName != null ? chainName : getChainName());
+  const [signingClient, setSigningClient] = useState2(null);
+  const [isSigningClientReady, setIsSigningClientReady] = useState2(false);
+  const { settings } = useSettings();
+  const hasInitialized = useRef(false);
+  const defaultChainName = useMemo3(() => getChainName(), []);
+  const createSigningClient = useCallback3(async () => {
+    var _a2;
+    const signingResult = await getSigningClient();
+    const offlineSigner = signingResult == null ? void 0 : signingResult.offlineSigner;
+    const rpcEndpoint = settings.endpoints.rpcEndpoint.replace("wss://", "https://").replace("ws://", "http://");
+    if (!offlineSigner) {
+      return;
+    }
+    let clientFn = getSigningBzeClient;
+    if (isIbc) {
+      clientFn = getSigningIbcClient;
+    } else if (isCosmos) {
+      clientFn = getSigningCosmosClient;
+    }
+    const signer = (_a2 = offlineSigner == null ? void 0 : offlineSigner.offlineSigner) != null ? _a2 : offlineSigner;
+    const getRpcForChain = (name) => {
+      switch (name) {
+        case "archway":
+          return getArchwayRpcURL();
+        case "osmosis":
+          return getOsmosisRpcUrl();
+        case "noble":
+          return getNobleRpcUrl();
+        case "jackal":
+          return getJackalRpcUrl();
+        case "omniflixhub":
+          return getOmniFlixRpcUrl();
+        case "atomone":
+          return getAtomOneRpcUrl();
+        default:
+          return rpcEndpoint;
+      }
+    };
+    const endpoint = chainName && chainName !== defaultChainName ? getRpcForChain(chainName) : rpcEndpoint;
+    return clientFn({ rpcEndpoint: endpoint, signer });
+  }, [getSigningClient, settings.endpoints.rpcEndpoint, isIbc, isCosmos, chainName, defaultChainName]);
+  useEffect2(() => {
+    if (!wallet || !chain || hasInitialized.current) {
+      return;
+    }
+    const load = async () => {
+      const client = await createSigningClient();
+      if (client) {
+        setSigningClient(client);
+        setIsSigningClientReady(true);
+        hasInitialized.current = true;
+      }
+    };
+    load();
+  }, [wallet, chain, createSigningClient]);
+  return {
+    signingClientError,
+    signingClient,
+    isSigningClientReady
+  };
+};
+
+// src/hooks/usePrices.ts
+import { useCallback as useCallback4, useMemo as useMemo4 } from "react";
+function useAssetPrice(denom) {
+  const { usdPricesMap, marketsDataMap, isLoadingPrices } = useAssetsContext();
+  const usdDenom = useMemo4(() => getUSDCDenom(), []);
+  const bzeDenom = useMemo4(() => getChainNativeAssetDenom(), []);
+  const change = useMemo4(() => {
+    const marketData = marketsDataMap.get(createMarketId(denom, usdDenom));
+    if (marketData) {
+      return marketData.change;
+    }
+    const marketData2 = marketsDataMap.get(createMarketId(denom, bzeDenom));
+    if (marketData2) {
+      return marketData2.change;
+    }
+    return 0;
+  }, [marketsDataMap, denom, usdDenom, bzeDenom]);
+  const price = useMemo4(() => {
+    const zeroBN = toBigNumber(0);
+    if (denom === "") return zeroBN;
+    if (denom === usdDenom) return toBigNumber(1);
+    return usdPricesMap.get(denom) || zeroBN;
+  }, [usdPricesMap, denom, usdDenom]);
+  const totalUsdValue = useCallback4((amount) => {
+    return price.multipliedBy(amount);
+  }, [price]);
+  const uAmountUsdValue = useCallback4((amount, decimals) => {
+    return totalUsdValue(uAmountToBigNumberAmount(amount, decimals));
+  }, [totalUsdValue]);
+  const isUSDC = useMemo4(() => denom === usdDenom, [denom, usdDenom]);
+  const hasPrice = useMemo4(() => price.gt(0), [price]);
+  return {
+    price,
+    change,
+    totalUsdValue,
+    uAmountUsdValue,
+    isLoading: isLoadingPrices,
+    hasPrice,
+    isUSDC
+  };
+}
+
+// src/hooks/useBalances.ts
+import BigNumber8 from "bignumber.js";
+import { useMemo as useMemo5, useCallback as useCallback5 } from "react";
+function useBalances() {
+  const { balancesMap, isLoading, assetsMap, usdPricesMap } = useAssetsContext();
+  const balances = useMemo5(() => Array.from(balancesMap.values()), [balancesMap]);
+  const getBalanceByDenom = useCallback5((denom) => {
+    return balancesMap.get(denom) || { denom, amount: BigNumber8(0) };
+  }, [balancesMap]);
+  const assetsBalances = useMemo5(() => {
+    const result = [];
+    balances.map((bal) => {
+      const asset = assetsMap.get(bal.denom);
+      if (!asset) {
+        return;
+      }
+      let usdPrice = usdPricesMap.get(bal.denom);
+      if (!usdPrice) {
+        usdPrice = BigNumber8(0);
+      }
+      if (asset.denom === getUSDCDenom()) {
+        usdPrice = BigNumber8(1);
+      }
+      result.push(__spreadProps(__spreadValues({}, asset), {
+        amount: bal.amount,
+        USDValue: uAmountToBigNumberAmount(bal.amount, asset.decimals).multipliedBy(usdPrice)
+      }));
+    });
+    return result;
+  }, [balances, assetsMap, usdPricesMap]);
+  return {
+    isLoading,
+    balances,
+    assetsBalances,
+    getBalanceByDenom
+  };
+}
+function useBalance(denom) {
+  const { balancesMap, isLoading } = useAssetsContext();
+  const balance = useMemo5(
+    () => balancesMap.get(denom) || {
+      denom,
+      amount: BigNumber8(0)
+    },
+    [balancesMap, denom]
+  );
+  const hasAmount = useCallback5((amount) => {
+    return balance.amount.gte(amount);
+  }, [balance]);
+  return {
+    balance,
+    isLoading,
+    hasAmount
+  };
+}
+
+// src/hooks/useEpochs.ts
+import { useMemo as useMemo6 } from "react";
+var EPOCH_HOUR2 = "hour";
+var EPOCH_DAY2 = "day";
+var EPOCH_WEEK2 = "week";
+function useEpochs() {
+  const { epochs, isLoading, updateEpochs } = useAssetsContext();
+  const hourEpochInfo = useMemo6(() => {
+    return epochs.get(EPOCH_HOUR2);
+  }, [epochs]);
+  const dayEpochInfo = useMemo6(() => {
+    return epochs.get(EPOCH_DAY2);
+  }, [epochs]);
+  const weekEpochInfo = useMemo6(() => {
+    return epochs.get(EPOCH_WEEK2);
+  }, [epochs]);
+  return {
+    epochs,
+    hourEpochInfo,
+    dayEpochInfo,
+    weekEpochInfo,
+    isLoading,
+    updateEpochs
+  };
+}
+
+// src/hooks/useLiquidityPools.ts
+import { useCallback as useCallback6, useMemo as useMemo7 } from "react";
+function useLiquidityPools() {
+  const { poolsMap, poolsDataMap, updateLiquidityPools, isLoading, assetsMap } = useAssetsContext();
+  const pools = useMemo7(() => {
+    return Array.from(poolsMap.values());
+  }, [poolsMap]);
+  const getPoolByLpDenom = (lpDenom) => {
+    const poolId = poolIdFromPoolDenom(lpDenom);
+    return poolsMap.get(poolId);
+  };
+  const getDenomsPool = useCallback6((denomA, denomB) => {
+    const poolId = createPoolId(denomA, denomB);
+    return poolsMap.get(poolId);
+  }, [poolsMap]);
+  const liquidAssets = useMemo7(() => {
+    if (!assetsMap || assetsMap.size === 0) return [];
+    const result = /* @__PURE__ */ new Map();
+    pools.forEach((pool) => {
+      result.set(pool.base, assetsMap.get(pool.base));
+      result.set(pool.quote, assetsMap.get(pool.quote));
+    });
+    return Array.from(result.values()).filter((asset) => asset !== void 0);
+  }, [assetsMap, pools]);
+  return {
+    pools,
+    poolsMap,
+    poolsDataMap,
+    isLoading,
+    updateLiquidityPools,
+    getPoolByLpDenom,
+    getDenomsPool,
+    liquidAssets
+  };
+}
+function useAssetLiquidityPools(denom) {
+  const { poolsMap, poolsDataMap } = useAssetsContext();
+  const assetPools = useMemo7(() => {
+    return Array.from(poolsMap.values()).filter(
+      (pool) => pool.base === denom || pool.quote === denom
+    );
+  }, [poolsMap, denom]);
+  return {
+    assetPools,
+    poolsDataMap
+  };
+}
+
+// src/hooks/useAssetsValue.ts
+import { useMemo as useMemo8 } from "react";
+function useAssetsValue() {
+  const { assetsMap, usdPricesMap, balancesMap, isLoading } = useAssetsContext();
+  const totalUsdValue = useMemo8(() => {
+    let total = toBigNumber(0);
+    balancesMap.forEach((balance, denom) => {
+      const price = usdPricesMap.get(denom);
+      if (!price || !price.gt(0)) return;
+      const asset = assetsMap.get(denom);
+      if (!asset) return;
+      total = total.plus(price.multipliedBy(uAmountToBigNumberAmount(balance.amount, asset.decimals)));
+    });
+    return total;
+  }, [balancesMap, usdPricesMap, assetsMap]);
+  const denomUsdValue = (denom, uAmount) => {
+    const price = usdPricesMap.get(denom);
+    if (!price || !price.gt(0)) return toBigNumber(0);
+    const asset = assetsMap.get(denom);
+    if (!asset) return toBigNumber(0);
+    return price.multipliedBy(uAmountToBigNumberAmount(uAmount, asset.decimals));
+  };
+  return {
+    totalUsdValue,
+    denomUsdValue,
+    isLoading
+  };
+}
+
+// src/hooks/useFeeTokens.ts
+import { useMemo as useMemo9 } from "react";
+var MIN_LIQUIDITY_FOR_FEE_TOKEN = 5e10;
+function useFeeTokens() {
+  const { pools, isLoading: poolsLoading } = useLiquidityPools();
+  const { assetsMap, isLoading: assetsLoading } = useAssetsContext();
+  const nativeDenom = getChainNativeAssetDenom();
+  const feeTokens = useMemo9(() => {
+    if (poolsLoading || assetsLoading) {
+      return [];
+    }
+    const feeTokenDenoms = /* @__PURE__ */ new Set();
+    pools.forEach((pool) => {
+      if (pool.base === nativeDenom && toBigNumber(pool.reserve_base).gt(MIN_LIQUIDITY_FOR_FEE_TOKEN)) {
+        feeTokenDenoms.add(pool.quote);
+      } else if (pool.quote === nativeDenom && toBigNumber(pool.reserve_quote).gt(MIN_LIQUIDITY_FOR_FEE_TOKEN)) {
+        feeTokenDenoms.add(pool.base);
+      }
+    });
+    const tokens = Array.from(feeTokenDenoms).map((denom) => assetsMap.get(denom)).filter((asset) => asset !== void 0).sort((a, b) => {
+      if (!a || !b) return 0;
+      return a.denom.localeCompare(b.denom);
+    });
+    const bzeAsset = assetsMap.get(nativeDenom);
+    if (!bzeAsset) {
+      return tokens;
+    }
+    return [bzeAsset, ...tokens];
+  }, [pools, poolsLoading, assetsLoading, nativeDenom, assetsMap]);
+  return {
+    feeTokens,
+    isLoading: poolsLoading || assetsLoading,
+    nativeDenom
+  };
+}
+
+// src/hooks/useMarkets.ts
+import { useMemo as useMemo10 } from "react";
+function useMarkets() {
+  const { marketsMap, marketsDataMap, updateMarkets, isLoading } = useAssetsContext();
+  const markets = useMemo10(() => {
+    return Array.from(marketsMap.values());
+  }, [marketsMap]);
+  return {
+    markets,
+    marketsMap,
+    marketsDataMap,
+    isLoading,
+    updateMarkets
+  };
+}
+function useAssetMarkets(denom) {
+  const { marketsMap } = useAssetsContext();
+  const assetMarkets = useMemo10(() => {
+    return Array.from(marketsMap.values()).filter(
+      (market) => market.base === denom || market.quote === denom
+    );
+  }, [marketsMap, denom]);
+  return {
+    assetMarkets
+  };
+}
+function useMarket(base, quote) {
+  const { marketsMap, marketsDataMap, assetsMap, isLoading } = useAssetsContext();
+  const marketId = useMemo10(() => createMarketId(base, quote), [base, quote]);
+  const market = useMemo10(() => {
+    return marketsMap.get(marketId);
+  }, [marketsMap, marketId]);
+  const marketData = useMemo10(() => {
+    return marketsDataMap.get(marketId);
+  }, [marketsDataMap, marketId]);
+  const marketExists = useMemo10(() => !!market, [market]);
+  const volume24h = useMemo10(() => {
+    if (!marketData) return toBigNumber(0);
+    const quoteAsset = assetsMap.get(quote);
+    if (!quoteAsset) return toBigNumber(0);
+    return uAmountToBigNumberAmount(toBigNumber(marketData.quote_volume), quoteAsset.decimals);
+  }, [marketData, assetsMap, quote]);
+  return {
+    market,
+    marketData,
+    marketExists,
+    volume24h,
+    isLoading
+  };
+}
+
+// src/hooks/useToast.tsx
+import { useCallback as useCallback8, useMemo as useMemo11 } from "react";
+
+// src/components/toaster.tsx
+import {
+  Toaster as ChakraToaster,
+  Portal,
+  Spinner,
+  Stack,
+  Toast,
+  createToaster
+} from "@chakra-ui/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var toaster = createToaster({
+  placement: "top-end",
+  pauseOnPageIdle: true
+});
+var Toaster = () => {
+  return /* @__PURE__ */ jsx(Portal, { children: /* @__PURE__ */ jsx(ChakraToaster, { toaster, insetInline: { mdDown: "4" }, children: (toast) => /* @__PURE__ */ jsxs(Toast.Root, { width: { md: "sm" }, children: [
+    toast.type === "loading" ? /* @__PURE__ */ jsx(Spinner, { size: "sm", color: "blue.solid" }) : /* @__PURE__ */ jsx(Toast.Indicator, {}),
+    /* @__PURE__ */ jsxs(Stack, { gap: "1", flex: "1", maxWidth: "100%", children: [
+      toast.title && /* @__PURE__ */ jsx(Toast.Title, { children: toast.title }),
+      toast.description && /* @__PURE__ */ jsx(Toast.Description, { children: toast.description })
+    ] }),
+    toast.action && /* @__PURE__ */ jsx(Toast.ActionTrigger, { children: toast.action.label }),
+    toast.closable && /* @__PURE__ */ jsx(Toast.CloseTrigger, {})
+  ] }) }) });
+};
+
+// src/hooks/useToast.tsx
+var useToast = () => {
+  const clickableSuccess = useCallback8((title, actionFn, actionLabel, description, duration = 5e3) => {
+    toaster.create({
+      title,
+      description,
+      type: "success",
+      duration,
+      closable: true,
+      action: {
+        label: actionLabel != null ? actionLabel : "",
+        onClick: actionFn
+      }
+    });
+  }, []);
+  const success = useCallback8((title, description, duration = 5e3) => {
+    toaster.create({
+      title,
+      description,
+      type: "success",
+      duration,
+      closable: true
+    });
+  }, []);
+  const error = useCallback8((title, description, duration = 8e3) => {
+    toaster.create({
+      title,
+      description,
+      type: "error",
+      duration,
+      closable: true
+    });
+  }, []);
+  const warning = useCallback8((title, description, duration = 6e3) => {
+    toaster.create({
+      title,
+      description,
+      type: "warning",
+      duration,
+      closable: true
+    });
+  }, []);
+  const info = useCallback8((title, description, duration = 5e3) => {
+    toaster.create({
+      title,
+      description,
+      type: "info",
+      duration,
+      closable: true
+    });
+  }, []);
+  const loading = useCallback8((title, description) => {
+    return toaster.create({
+      title,
+      description,
+      type: "loading",
+      closable: false
+    });
+  }, []);
+  const dismiss = useCallback8((id) => {
+    toaster.dismiss(id);
+  }, []);
+  const toast = useMemo11(() => ({
+    clickableSuccess,
+    success,
+    error,
+    warning,
+    info,
+    loading,
+    dismiss
+  }), [clickableSuccess, success, error, warning, info, loading, dismiss]);
+  return { toast };
+};
+
+// src/hooks/useTx.tsx
+import { coins, isDeliverTxSuccess } from "@cosmjs/stargate";
+import { useChain as useChain2 } from "@interchain-kit/react";
+import BigNumber9 from "bignumber.js";
+import { useCallback as useCallback9, useMemo as useMemo12, useState as useState3 } from "react";
+var TxStatus = /* @__PURE__ */ ((TxStatus2) => {
+  TxStatus2["Failed"] = "Transaction Failed";
+  TxStatus2["Successful"] = "Transaction Successful";
+  TxStatus2["Broadcasting"] = "Transaction Pending";
+  return TxStatus2;
+})(TxStatus || {});
+var defaultFee = {
+  amount: coins(2e4, getChainNativeAssetDenom()),
+  gas: "500000"
+};
+var useSDKTx = (chainName) => {
+  const { tx, progressTrack } = useTx(chainName != null ? chainName : getChainName(), true, false);
+  return {
+    tx,
+    progressTrack
+  };
+};
+var useBZETx = () => {
+  const { tx, progressTrack } = useTx(getChainName(), false, false);
+  return {
+    tx,
+    progressTrack
+  };
+};
+var useIBCTx = (chainName) => {
+  const { tx, progressTrack } = useTx(chainName != null ? chainName : getChainName(), false, true);
+  return {
+    tx,
+    progressTrack
+  };
+};
+var useTx = (chainName, isCosmos, isIBC) => {
+  const { address, disconnect } = useChain2(chainName);
+  const { toast } = useToast();
+  const { signingClient, isSigningClientReady, signingClientError } = useSigningClient({ chainName, isCosmos, isIbc: isIBC });
+  const [progressTrack, setProgressTrack] = useState3("");
+  const { getDenomsPool } = useLiquidityPools();
+  const { feeDenom } = useSettings();
+  const defaultChainName = useMemo12(() => getChainName(), []);
+  const canUseClient = useCallback9(async () => {
+    if (!isSigningClientReady) {
+      console.error("waiting for signing client to be ready", signingClientError);
+      await sleep(1e3);
+    }
+    return isSigningClientReady;
+  }, [isSigningClientReady, signingClientError]);
+  const simulateFee = useCallback9(async (messages, memo) => {
+    const gasPrice = 0.02;
+    const nativeDenom = getChainNativeAssetDenom();
+    const gasEstimated = await signingClient.simulate(address, messages, memo);
+    const gasAmount = BigNumber9(gasEstimated).multipliedBy(1.5);
+    const gasPayment = gasAmount.multipliedBy(gasPrice);
+    const nativeFee = {
+      amount: coins(gasPayment.toFixed(0).toString(), nativeDenom),
+      gas: gasAmount.toFixed(0)
+    };
+    if (feeDenom === nativeDenom) {
+      return nativeFee;
+    }
+    const pool = getDenomsPool(feeDenom, nativeDenom);
+    if (!pool) {
+      return nativeFee;
+    }
+    let expectedAmount = calculatePoolOppositeAmount(pool, gasPayment, pool.base === nativeDenom);
+    if (!expectedAmount.isPositive()) {
+      return nativeFee;
+    }
+    expectedAmount = expectedAmount.multipliedBy(1.5).integerValue(BigNumber9.ROUND_FLOOR);
+    if (expectedAmount.multipliedBy(pool.fee).lt(1)) {
+      expectedAmount = toBigNumber(1).dividedBy(pool.fee).integerValue(BigNumber9.ROUND_CEIL);
+    }
+    return {
+      amount: coins(expectedAmount.toFixed(0).toString(), feeDenom),
+      gas: gasAmount.multipliedBy(1.5).toFixed(0)
+    };
+  }, [signingClient, address, feeDenom, getDenomsPool]);
+  const getFee = useCallback9(async (messages, options) => {
+    try {
+      if (options == null ? void 0 : options.fee) {
+        return options.fee;
+      } else {
+        setProgressTrack("Simulating transaction");
+        return await simulateFee(messages, options == null ? void 0 : options.memo);
+      }
+    } catch (e) {
+      console.error("could not get fee: ", e);
+      if (options == null ? void 0 : options.fallbackOnSimulate) {
+        return defaultFee;
+      } else {
+        throw e;
+      }
+    }
+  }, [simulateFee]);
+  const tx = useCallback9(async (msgs, options) => {
+    var _a2;
+    if (!address) {
+      toast.error("Transaction Failed" /* Failed */, "Please connect the wallet");
+      return;
+    }
+    if (!await canUseClient()) {
+      toast.error("Transaction Failed" /* Failed */, "Can not find suitable signing client. Make sure your wallet is installed, connected and unlocked.");
+      disconnect();
+      return;
+    }
+    setProgressTrack("Getting fee");
+    const broadcastToastId = toast.loading("Transaction Pending" /* Broadcasting */, "Waiting for transaction to be signed and included in block");
+    if (signingClient) {
+      try {
+        const fee = await getFee(msgs, options);
+        setProgressTrack("Signing transaction");
+        const resp = await signingClient.signAndBroadcast(address, msgs, fee, (_a2 = options == null ? void 0 : options.memo) != null ? _a2 : DEFAULT_TX_MEMO);
+        if (isDeliverTxSuccess(resp)) {
+          setProgressTrack("Transaction sent");
+          toast.clickableSuccess("Transaction Successful" /* Successful */, () => {
+            openExternalLink(`${getChainExplorerURL(chainName != null ? chainName : defaultChainName)}/tx/${resp.transactionHash}`);
+          }, "View in Explorer");
+          if (options == null ? void 0 : options.onSuccess) {
+            options.onSuccess(resp);
+          }
+        } else {
+          setProgressTrack("Transaction failed");
+          toast.error("Transaction Failed" /* Failed */, prettyError(resp == null ? void 0 : resp.rawLog));
+          if (options == null ? void 0 : options.onFailure) {
+            options.onFailure(prettyError(resp == null ? void 0 : resp.rawLog) || "Unknown error");
+          }
+        }
+      } catch (e) {
+        console.error(e);
+        if (e.message.includes("Failed to retrieve account from signer")) {
+          disconnect();
+        }
+        toast.error("Transaction Failed" /* Failed */, prettyError(e == null ? void 0 : e.message));
+        if (options == null ? void 0 : options.onFailure) {
+          options.onFailure(prettyError(e == null ? void 0 : e.message) || "Unknown error");
+        }
+      }
+    }
+    toast.dismiss(broadcastToastId);
+    setTimeout(() => {
+      setProgressTrack("");
+    }, (options == null ? void 0 : options.progressTrackerTimeout) || 5e3);
+  }, [address, canUseClient, toast, signingClient, disconnect, getFee, chainName, defaultChainName]);
+  return {
+    tx,
+    progressTrack
+  };
+};
+
+// src/components/highlight.tsx
+import { Text } from "@chakra-ui/react";
+import { useEffect as useEffect3, useRef as useRef2, useState as useState4 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var HighlightText = (_a2) => {
+  var _b2 = _a2, {
+    duration = 200,
+    highlightOnMount = false,
+    highlightColor = "blue.500",
+    highlightIntensity = "subtle",
+    children
+  } = _b2, textProps = __objRest(_b2, [
+    "duration",
+    "highlightOnMount",
+    "highlightColor",
+    "highlightIntensity",
+    "children"
+  ]);
+  const [isHighlighted, setIsHighlighted] = useState4(false);
+  const isMountedRef = useRef2(false);
+  const timeoutRef = useRef2(void 0);
+  const childrenString = String(children);
+  const previousValueRef = useRef2(childrenString);
+  const highlightOpacity = highlightIntensity === "subtle" ? "15" : "50";
+  const boxShadowStrength = highlightIntensity === "subtle" ? "10" : "25";
+  useEffect3(() => {
+    if (!isMountedRef.current) {
+      isMountedRef.current = true;
+      if (highlightOnMount) {
+        setIsHighlighted(true);
+        timeoutRef.current = setTimeout(() => {
+          setIsHighlighted(false);
+        }, duration);
+      }
+      previousValueRef.current = childrenString;
+      return;
+    }
+    if (previousValueRef.current !== childrenString) {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      setIsHighlighted(true);
+      timeoutRef.current = setTimeout(() => {
+        setIsHighlighted(false);
+      }, duration);
+      previousValueRef.current = childrenString;
+    }
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, [childrenString, duration, highlightOnMount]);
+  return /* @__PURE__ */ jsx2(
+    Text,
+    __spreadProps(__spreadValues({}, textProps), {
+      transition: `all ${duration}ms ease-out`,
+      bg: isHighlighted ? `${highlightColor}/${highlightOpacity}` : "transparent",
+      boxShadow: isHighlighted ? `0 0 0 ${highlightIntensity === "evident" ? "4px" : "3px"} ${highlightColor}/${boxShadowStrength}` : "none",
+      borderRadius: "md",
+      px: isHighlighted ? "2" : "0",
+      transform: isHighlighted && highlightIntensity === "evident" ? "scale(1.02)" : "scale(1)",
+      fontWeight: isHighlighted && highlightIntensity === "evident" ? "semibold" : textProps.fontWeight,
+      children
+    })
+  );
+};
+
+// src/components/sidebar/sidebar.tsx
+import { Icon, IconButton, Portal as Portal2 } from "@chakra-ui/react";
+import { LuX } from "react-icons/lu";
+import { useState as useState5 } from "react";
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var Sidebar = ({ children, trigger, ariaLabel }) => {
+  const [isOpen, setIsOpen] = useState5(false);
+  const handleTriggerClick = () => {
+    setIsOpen(true);
+  };
+  const handleClose = () => {
+    setIsOpen(false);
+  };
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    /* @__PURE__ */ jsx3("div", { onClick: handleTriggerClick, style: { cursor: "pointer" }, children: trigger }),
+    isOpen && /* @__PURE__ */ jsxs2(Portal2, { children: [
+      /* @__PURE__ */ jsx3(
+        "div",
+        {
+          style: {
+            position: "fixed",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0,
+            backgroundColor: "rgba(0, 0, 0, 0.5)",
+            zIndex: "3",
+            display: "block"
+          },
+          onClick: (e) => {
+            if (e.target === e.currentTarget) {
+              handleClose();
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxs2(
+        "div",
+        {
+          id: "sidebar-content",
+          style: {
+            position: "fixed",
+            top: 0,
+            right: 0,
+            bottom: 0,
+            width: window.innerWidth < 768 ? "100vw" : "20vw",
+            minWidth: window.innerWidth < 768 ? "100vw" : "300px",
+            maxWidth: window.innerWidth < 768 ? "100vw" : "400px",
+            backgroundColor: "var(--chakra-colors-bg-panel)",
+            borderLeft: "1px solid var(--chakra-colors-border-subtle)",
+            boxShadow: window.innerWidth >= 768 ? "-4px 0 12px rgba(0, 0, 0, 0.15)" : "none",
+            zIndex: "99",
+            display: "flex",
+            flexDirection: "column",
+            overflow: "hidden"
+          },
+          children: [
+            /* @__PURE__ */ jsxs2(
+              "div",
+              {
+                style: {
+                  display: "flex",
+                  justifyContent: "space-between",
+                  alignItems: "center",
+                  padding: "1rem",
+                  borderBottom: "1px solid var(--chakra-colors-border-subtle)",
+                  backgroundColor: "var(--chakra-colors-bg-panel)",
+                  flexShrink: 0
+                },
+                children: [
+                  /* @__PURE__ */ jsx3(
+                    "h3",
+                    {
+                      style: {
+                        fontSize: "1.125rem",
+                        fontWeight: "600",
+                        margin: 0,
+                        color: "var(--chakra-colors-fg)"
+                      },
+                      children: ariaLabel
+                    }
+                  ),
+                  /* @__PURE__ */ jsx3(
+                    IconButton,
+                    {
+                      "aria-label": "Close sidebar",
+                      variant: "ghost",
+                      size: "sm",
+                      onClick: handleClose,
+                      children: /* @__PURE__ */ jsx3(Icon, { size: "md", children: /* @__PURE__ */ jsx3(LuX, {}) })
+                    }
+                  )
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx3(
+              "div",
+              {
+                style: {
+                  padding: "1rem",
+                  flex: 1,
+                  overflowY: "auto",
+                  backgroundColor: "var(--chakra-colors-bg-panel)",
+                  position: "relative"
+                },
+                children
+              }
+            )
+          ]
+        }
+      )
+    ] })
+  ] });
+};
+
+// src/components/sidebar/settings-sidebar.tsx
+import {
+  VStack,
+  HStack,
+  Text as Text2,
+  Switch,
+  Button,
+  Separator,
+  Box,
+  Input,
+  Badge,
+  createListCollection
+} from "@chakra-ui/react";
+import { Select, Portal as Portal3 } from "@chakra-ui/react";
+import { useTheme } from "next-themes";
+import { useState as useState6, useEffect as useEffect4, useMemo as useMemo13, useCallback as useCallback10 } from "react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var SettingsSidebarContent = ({ accentColor = "blue" }) => {
+  const { setTheme, resolvedTheme } = useTheme();
+  const { toast } = useToast();
+  const { settings, isLoaded, updateEndpoints, updatePreferredFeeDenom, defaultSettings } = useSettings();
+  const { connectionType } = useConnectionType();
+  const { feeTokens, isLoading: feeTokensLoading } = useFeeTokens();
+  const [restEndpoint, setRestEndpoint] = useState6("");
+  const [rpcEndpoint, setRpcEndpoint] = useState6("");
+  const [isValidating, setIsValidating] = useState6(false);
+  const [validationResults, setValidationResults] = useState6({});
+  const [preferredFeeDenom, setPreferredFeeDenom] = useState6(void 0);
+  useEffect4(() => {
+    if (isLoaded) {
+      setRestEndpoint(settings.endpoints.restEndpoint);
+      setRpcEndpoint(settings.endpoints.rpcEndpoint);
+      setPreferredFeeDenom(settings.preferredFeeDenom || getChainNativeAssetDenom());
+    }
+  }, [isLoaded, settings]);
+  const handleValidateEndpoints = useCallback10(async (rest, rpc) => {
+    setIsValidating(true);
+    setValidationResults({});
+    try {
+      const results = await validateEndpoints(rest, rpc);
+      setValidationResults({
+        rest: results.rest,
+        rpc: results.rpc
+      });
+    } catch (error) {
+      console.error(error);
+      setValidationResults({
+        rest: { isValid: false, error: "Validation failed" },
+        rpc: { isValid: false, error: "Validation failed" }
+      });
+    } finally {
+      setIsValidating(false);
+      setTimeout(() => setValidationResults({}), 1e4);
+    }
+  }, []);
+  const handleSaveSettings = useCallback10(async (rest, rpc, feeDenom) => {
+    setValidationResults({});
+    const results = await validateEndpoints(rest, rpc);
+    if (!results.isValid) {
+      setValidationResults({
+        rest: results.rest,
+        rpc: results.rpc
+      });
+      setTimeout(() => setValidationResults({}), 1e4);
+      return;
+    }
+    const endpointsSuccess = updateEndpoints({
+      restEndpoint: rest.trim(),
+      rpcEndpoint: convertToWebSocketUrl(rpc.trim())
+    });
+    const feeTokenSuccess = updatePreferredFeeDenom(feeDenom);
+    if (endpointsSuccess && feeTokenSuccess) {
+      toast.success("Success!", "Settings have been saved.");
+    }
+  }, []);
+  const handleResetToDefaults = useCallback10(() => {
+    setRestEndpoint(defaultSettings.endpoints.restEndpoint);
+    setRpcEndpoint(defaultSettings.endpoints.rpcEndpoint);
+    setPreferredFeeDenom(defaultSettings.preferredFeeDenom);
+    setValidationResults({});
+  }, []);
+  const connectionStatusText = useMemo13(() => {
+    switch (connectionType) {
+      case CONNECTION_TYPE_NONE:
+        return "Failed";
+      case CONNECTION_TYPE_POLLING:
+        return "Polling";
+      case CONNECTION_TYPE_WS:
+        return "Connected";
+    }
+  }, [connectionType]);
+  const connectionStatusBadgeColor = useMemo13(() => {
+    switch (connectionType) {
+      case CONNECTION_TYPE_NONE:
+        return "red";
+      case CONNECTION_TYPE_POLLING:
+        return "orange";
+      case CONNECTION_TYPE_WS:
+        return "green";
+    }
+  }, [connectionType]);
+  const feeTokensCollection = useMemo13(() => createListCollection({
+    items: feeTokens.map((token) => ({
+      label: token.ticker || token.name,
+      value: token.denom,
+      name: token.ticker || token.name
+    }))
+  }), [feeTokens]);
+  const handleFeeTokenChange = useCallback10((denom) => {
+    setPreferredFeeDenom(denom || void 0);
+  }, []);
+  const hasUnsavedChanges = restEndpoint !== settings.endpoints.restEndpoint || rpcEndpoint !== settings.endpoints.rpcEndpoint || preferredFeeDenom !== settings.preferredFeeDenom;
+  return /* @__PURE__ */ jsxs3(VStack, { gap: "6", align: "stretch", children: [
+    /* @__PURE__ */ jsxs3(Box, { children: [
+      /* @__PURE__ */ jsx4(Text2, { fontSize: "sm", fontWeight: "medium", mb: "3", children: "Appearance" }),
+      /* @__PURE__ */ jsx4(VStack, { gap: "3", align: "stretch", children: /* @__PURE__ */ jsxs3(HStack, { justify: "space-between", children: [
+        /* @__PURE__ */ jsx4(Text2, { fontSize: "sm", children: "Dark Mode" }),
+        /* @__PURE__ */ jsxs3(
+          Switch.Root,
+          {
+            checked: resolvedTheme === "dark",
+            onCheckedChange: (details) => {
+              const newTheme = details.checked ? "dark" : "light";
+              setTheme(newTheme);
+            },
+            children: [
+              /* @__PURE__ */ jsx4(Switch.HiddenInput, {}),
+              /* @__PURE__ */ jsx4(Switch.Control, { children: /* @__PURE__ */ jsx4(Switch.Thumb, {}) })
+            ]
+          }
+        )
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx4(Separator, {}),
+    /* @__PURE__ */ jsxs3(Box, { children: [
+      /* @__PURE__ */ jsx4(Text2, { fontSize: "sm", fontWeight: "medium", mb: "3", children: "Fee Token Preference" }),
+      /* @__PURE__ */ jsx4(VStack, { gap: "3", align: "stretch", children: /* @__PURE__ */ jsxs3(Box, { children: [
+        /* @__PURE__ */ jsxs3(
+          Select.Root,
+          {
+            collection: feeTokensCollection,
+            size: "sm",
+            value: preferredFeeDenom ? [preferredFeeDenom] : [""],
+            onValueChange: (details) => handleFeeTokenChange(details.value[0] || ""),
+            disabled: feeTokensLoading,
+            children: [
+              /* @__PURE__ */ jsx4(Select.Label, { children: "Preferred Fee Token" }),
+              /* @__PURE__ */ jsx4(Select.HiddenSelect, {}),
+              /* @__PURE__ */ jsxs3(Select.Control, { children: [
+                /* @__PURE__ */ jsx4(Select.Trigger, { children: /* @__PURE__ */ jsx4(Select.ValueText, { placeholder: "Native Token (default)" }) }),
+                /* @__PURE__ */ jsx4(Select.IndicatorGroup, { children: /* @__PURE__ */ jsx4(Select.Indicator, {}) })
+              ] }),
+              /* @__PURE__ */ jsx4(Portal3, { children: /* @__PURE__ */ jsx4(Select.Positioner, { children: /* @__PURE__ */ jsx4(Select.Content, { children: feeTokensCollection.items.map((item) => /* @__PURE__ */ jsxs3(Select.Item, { item, children: [
+                /* @__PURE__ */ jsx4(Text2, { children: item.label }),
+                /* @__PURE__ */ jsx4(Select.ItemIndicator, {})
+              ] }, item.value)) }) }) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx4(Text2, { fontSize: "xs", color: "fg.muted", mt: "2", children: "Select your preferred token for paying transaction fees. Only tokens with liquidity pools paired with the native token are available." })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx4(Separator, {}),
+    /* @__PURE__ */ jsxs3(Box, { children: [
+      /* @__PURE__ */ jsx4(Text2, { fontSize: "sm", fontWeight: "medium", mb: "3", children: "BeeZee Endpoints" }),
+      /* @__PURE__ */ jsxs3(VStack, { gap: "4", align: "stretch", children: [
+        /* @__PURE__ */ jsx4(Box, { children: /* @__PURE__ */ jsxs3(HStack, { gap: "2", align: "center", justify: "space-between", children: [
+          /* @__PURE__ */ jsx4(Text2, { fontSize: "sm", mb: "1", children: "Status: " }),
+          /* @__PURE__ */ jsx4(Badge, { colorPalette: connectionStatusBadgeColor, children: connectionStatusText })
+        ] }) }),
+        /* @__PURE__ */ jsxs3(Box, { children: [
+          /* @__PURE__ */ jsx4(Text2, { fontSize: "sm", mb: "1", children: "REST Endpoint" }),
+          /* @__PURE__ */ jsx4(Text2, { fontSize: "xs", color: "fg.muted", mb: "2", children: "Note: Endpoint must have CORS enabled to work in browser" }),
+          /* @__PURE__ */ jsx4(
+            Input,
+            {
+              size: "sm",
+              placeholder: "https://rest.getbze.com",
+              value: restEndpoint,
+              onChange: (e) => setRestEndpoint(e.target.value)
+            }
+          ),
+          validationResults.rest && /* @__PURE__ */ jsx4(
+            Box,
+            {
+              mt: "2",
+              p: "3",
+              bgGradient: "to-br",
+              gradientFrom: validationResults.rest.isValid ? "green.500/15" : "red.500/15",
+              gradientTo: validationResults.rest.isValid ? "green.600/15" : "red.600/15",
+              borderWidth: "1px",
+              borderColor: validationResults.rest.isValid ? "green.500/30" : "red.500/30",
+              borderRadius: "md",
+              children: /* @__PURE__ */ jsx4(Text2, { fontSize: "sm", color: validationResults.rest.isValid ? "green.700" : "red.700", _dark: { color: validationResults.rest.isValid ? "green.300" : "red.300" }, children: validationResults.rest.error || "REST endpoint is valid" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs3(Box, { children: [
+          /* @__PURE__ */ jsx4(Text2, { fontSize: "sm", mb: "1", children: "RPC Endpoint" }),
+          /* @__PURE__ */ jsx4(Text2, { fontSize: "xs", color: "fg.muted", mb: "2", children: "Note: Must support WebSocket (WS/WSS) connections" }),
+          /* @__PURE__ */ jsx4(
+            Input,
+            {
+              size: "sm",
+              placeholder: "wss://rpc.getbze.com",
+              value: rpcEndpoint,
+              onChange: (e) => setRpcEndpoint(e.target.value)
+            }
+          ),
+          validationResults.rpc && /* @__PURE__ */ jsx4(
+            Box,
+            {
+              mt: "2",
+              p: "3",
+              bgGradient: "to-br",
+              gradientFrom: validationResults.rpc.isValid ? "green.500/15" : "red.500/15",
+              gradientTo: validationResults.rpc.isValid ? "green.600/15" : "red.600/15",
+              borderWidth: "1px",
+              borderColor: validationResults.rpc.isValid ? "green.500/30" : "red.500/30",
+              borderRadius: "md",
+              children: /* @__PURE__ */ jsx4(Text2, { fontSize: "sm", color: validationResults.rpc.isValid ? "green.700" : "red.700", _dark: { color: validationResults.rpc.isValid ? "green.300" : "red.300" }, children: validationResults.rpc.error || "RPC endpoint is valid" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx4(
+          Button,
+          {
+            size: "sm",
+            variant: "outline",
+            onClick: () => handleValidateEndpoints(restEndpoint, rpcEndpoint),
+            loading: isValidating,
+            disabled: !restEndpoint.trim() || !rpcEndpoint.trim(),
+            children: isValidating ? "Validating..." : "Validate Endpoints"
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(Box, { children: /* @__PURE__ */ jsxs3(VStack, { gap: "3", children: [
+      /* @__PURE__ */ jsx4(
+        Button,
+        {
+          size: "sm",
+          width: "full",
+          onClick: () => handleSaveSettings(restEndpoint, rpcEndpoint, preferredFeeDenom),
+          colorPalette: accentColor,
+          disabled: !hasUnsavedChanges,
+          children: "Save Settings"
+        }
+      ),
+      /* @__PURE__ */ jsx4(
+        Button,
+        {
+          size: "sm",
+          width: "full",
+          variant: "outline",
+          onClick: handleResetToDefaults,
+          children: "Reset to Defaults"
+        }
+      )
+    ] }) })
+  ] });
+};
+
+// src/components/sidebar/wallet-sidebar.tsx
+import "@interchain-kit/react/styles.css";
+import { InterchainWalletModal, useChain as useChain3 } from "@interchain-kit/react";
+import {
+  Badge as Badge2,
+  Box as Box2,
+  Button as Button2,
+  createListCollection as createListCollection2,
+  Field,
+  Group,
+  HStack as HStack2,
+  Image,
+  Input as Input2,
+  Portal as Portal4,
+  Select as Select2,
+  Separator as Separator2,
+  Text as Text3,
+  Textarea,
+  VStack as VStack2
+} from "@chakra-ui/react";
+import { LuCopy, LuExternalLink, LuX as LuX2 } from "react-icons/lu";
+import { useCallback as useCallback11, useEffect as useEffect5, useMemo as useMemo14, useRef as useRef3, useState as useState7 } from "react";
+import { WalletState } from "@interchain-kit/core";
+import BigNumber10 from "bignumber.js";
+import { cosmos } from "@bze/bzejs";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var validateAmount = (amount, coin, onError) => {
+  if (!coin) return;
+  if (amount === "") return;
+  const amountNumber = BigNumber10(amount);
+  if (amountNumber.isNaN()) {
+    onError("Invalid amount");
+    return;
+  }
+  const coinBalance = uAmountToBigNumberAmount(coin.amount, coin.decimals);
+  if (coinBalance.isLessThan(amount)) {
+    onError("Insufficient balance");
+  } else {
+    onError("");
+  }
+};
+var BalanceItem = ({ asset, onClick, accentColor }) => {
+  const [showSendButton, setShowSendButton] = useState7(false);
+  const formattedBalanceAmount = useMemo14(() => {
+    var _a2;
+    return prettyAmount(uAmountToBigNumberAmount(asset.amount, (_a2 = asset.decimals) != null ? _a2 : 0));
+  }, [asset.amount, asset.decimals]);
+  const formattedBalanceUSDValue = useMemo14(() => {
+    return shortNumberFormat(asset.USDValue);
+  }, [asset.USDValue]);
+  return /* @__PURE__ */ jsxs4(
+    Box2,
+    {
+      p: "3",
+      bgGradient: "to-br",
+      gradientFrom: `${accentColor}.500/5`,
+      gradientTo: `${accentColor}.600/5`,
+      borderRadius: "md",
+      borderWidth: "1px",
+      borderColor: `${accentColor}.500/15`,
+      _hover: {
+        gradientFrom: `${accentColor}.500/10`,
+        gradientTo: `${accentColor}.600/10`,
+        borderColor: `${accentColor}.500/25`
+      },
+      transition: "all 0.2s",
+      onMouseLeave: () => setShowSendButton(false),
+      onMouseEnter: () => setShowSendButton(true),
+      children: [
+        /* @__PURE__ */ jsxs4(HStack2, { justify: "space-between", mb: "2", children: [
+          /* @__PURE__ */ jsxs4(HStack2, { children: [
+            /* @__PURE__ */ jsx5(
+              Image,
+              {
+                src: asset.logo,
+                alt: asset.ticker,
+                width: "20px",
+                height: "20px",
+                borderRadius: "full"
+              }
+            ),
+            /* @__PURE__ */ jsx5(Text3, { fontSize: "sm", fontWeight: "medium", children: asset.ticker }),
+            /* @__PURE__ */ jsx5(Text3, { fontSize: "xs", color: "fg.muted", children: asset.name }),
+            isIbcDenom(asset.denom) && /* @__PURE__ */ jsx5(Badge2, { size: "xs", colorPalette: accentColor, children: "IBC" })
+          ] }),
+          showSendButton && /* @__PURE__ */ jsx5(HStack2, { justify: "end", children: /* @__PURE__ */ jsx5(Button2, { size: "2xs", variant: "outline", onClick, children: "Send" }) })
+        ] }),
+        /* @__PURE__ */ jsxs4(HStack2, { justify: "space-between", children: [
+          /* @__PURE__ */ jsx5(HighlightText, { fontSize: "sm", fontFamily: "mono", children: formattedBalanceAmount }),
+          /* @__PURE__ */ jsxs4(HighlightText, { fontSize: "sm", color: "fg.muted", children: [
+            "$",
+            formattedBalanceUSDValue
+          ] })
+        ] })
+      ]
+    }
+  );
+};
+var SendForm = ({ balances, onClose, selectedTicker, accentColor }) => {
+  const [isLoading, setIsLoading] = useState7(false);
+  const [selectedCoin, setSelectedCoin] = useState7();
+  const [sendAmount, setSendAmount] = useState7("");
+  const [sendAmountError, setSendAmountError] = useState7("");
+  const [recipient, setRecipient] = useState7("");
+  const [recipientError, setRecipientError] = useState7("");
+  const [memo, setMemo] = useState7("");
+  const [memoError, setMemoError] = useState7("");
+  const { toast } = useToast();
+  const { status, address } = useChain3(getChainName());
+  const { tx } = useSDKTx(getChainName());
+  const coinsCollection = createListCollection2({
+    items: balances.map((item) => {
+      var _a2;
+      return {
+        label: `${item.ticker} - ${shortNumberFormat(uAmountToBigNumberAmount(item.amount, (_a2 = item == null ? void 0 : item.decimals) != null ? _a2 : 0))}`,
+        value: item.ticker,
+        logo: item.logo
+      };
+    })
+  });
+  const isValidForm = useMemo14(() => {
+    return selectedCoin && memoError === "" && recipientError === "" && sendAmountError === "" && sendAmount !== "" && recipient !== "";
+  }, [selectedCoin, memoError, recipientError, sendAmountError, sendAmount, recipient]);
+  const resetSendForm = useCallback11(() => {
+    setSelectedCoin(void 0);
+    setSendAmount("");
+    setRecipient("");
+    setMemo("");
+  }, []);
+  const handleSend = useCallback11(async () => {
+    var _a2, _b2;
+    if (!isValidForm) {
+      toast.error("Can not send coins!", "Please check the input data.");
+      return;
+    }
+    if (status !== WalletState.Connected) {
+      toast.error("Wallet not connected!", "Please connect your wallet first.");
+      return;
+    }
+    const { send } = cosmos.bank.v1beta1.MessageComposer.withTypeUrl;
+    const msg = send({
+      fromAddress: address,
+      toAddress: recipient,
+      amount: [{
+        denom: (_a2 = selectedCoin == null ? void 0 : selectedCoin.denom) != null ? _a2 : "",
+        amount: amountToUAmount(sendAmount, (_b2 = selectedCoin == null ? void 0 : selectedCoin.decimals) != null ? _b2 : 0)
+      }]
+    });
+    setIsLoading(true);
+    await tx([msg], { memo: memo.length > 0 ? memo : void 0 });
+    resetSendForm();
+    setIsLoading(false);
+    onClose();
+  }, [address, memo, onClose, recipient, selectedCoin, sendAmount, status]);
+  const handleCancel = useCallback11(() => {
+    resetSendForm();
+    onClose();
+  }, [onClose, resetSendForm]);
+  const onRecipientChange = useCallback11((recipient2) => {
+    setRecipient(recipient2);
+    if (recipient2.length === 0) {
+      setRecipientError("");
+      return;
+    }
+    const validate = validateBZEBech32Address(recipient2);
+    if (validate.isValid) {
+      setRecipientError("");
+    } else {
+      setRecipientError(validate.message);
+    }
+  }, []);
+  const onAmountChange = useCallback11((amount) => {
+    setSendAmount(sanitizeNumberInput(amount));
+    setSendAmountError("");
+  }, []);
+  const onCoinSelectChange = useCallback11((ticker) => {
+    if (ticker === "") return;
+    const selectedCoin2 = balances.find((item) => item.ticker === ticker);
+    if (selectedCoin2) {
+      setSelectedCoin(selectedCoin2);
+      validateAmount(sendAmount, selectedCoin2, setSendAmountError);
+    }
+  }, [sendAmount, balances]);
+  const setMaxAmount = useCallback11(() => {
+    if (!selectedCoin) return;
+    const maxAmount = uAmountToBigNumberAmount(selectedCoin.amount, selectedCoin.decimals);
+    onAmountChange(maxAmount.toString());
+    validateAmount(maxAmount.toString(), selectedCoin, setSendAmountError);
+  }, [selectedCoin, onAmountChange]);
+  const onMemoChange = useCallback11((memo2) => {
+    setMemo(memo2);
+    if (memo2.length > 256) {
+      setMemoError("Memo must be less than or equal to 256 characters");
+    } else {
+      setMemoError("");
+    }
+  }, []);
+  useEffect5(() => {
+    if (selectedTicker !== "") {
+      onCoinSelectChange(selectedTicker);
+    }
+  }, [onCoinSelectChange, selectedTicker]);
+  return /* @__PURE__ */ jsxs4(VStack2, { gap: "4", align: "stretch", children: [
+    /* @__PURE__ */ jsxs4(HStack2, { justify: "space-between", align: "center", children: [
+      /* @__PURE__ */ jsx5(Text3, { fontSize: "sm", fontWeight: "medium", children: "Send Coins" }),
+      /* @__PURE__ */ jsx5(
+        Button2,
+        {
+          size: "xs",
+          variant: "ghost",
+          onClick: handleCancel,
+          disabled: isLoading,
+          children: /* @__PURE__ */ jsx5(LuX2, { size: "14" })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs4(Box2, { children: [
+      /* @__PURE__ */ jsxs4(
+        Select2.Root,
+        {
+          collection: coinsCollection,
+          size: "sm",
+          value: (selectedCoin == null ? void 0 : selectedCoin.ticker) ? [selectedCoin.ticker] : [],
+          onValueChange: (details) => onCoinSelectChange(details.value[0] || ""),
+          children: [
+            /* @__PURE__ */ jsx5(Select2.Label, { children: "Coin" }),
+            /* @__PURE__ */ jsx5(Select2.HiddenSelect, {}),
+            /* @__PURE__ */ jsxs4(Select2.Control, { children: [
+              /* @__PURE__ */ jsx5(Select2.Trigger, { children: /* @__PURE__ */ jsx5(Select2.ValueText, { placeholder: "Select coin" }) }),
+              /* @__PURE__ */ jsx5(Select2.IndicatorGroup, { children: /* @__PURE__ */ jsx5(Select2.Indicator, {}) })
+            ] }),
+            /* @__PURE__ */ jsx5(Portal4, { children: /* @__PURE__ */ jsx5(Select2.Positioner, { children: /* @__PURE__ */ jsx5(Select2.Content, { children: coinsCollection.items.map((item) => /* @__PURE__ */ jsxs4(Select2.Item, { item, children: [
+              /* @__PURE__ */ jsxs4(HStack2, { gap: "2", children: [
+                /* @__PURE__ */ jsx5(
+                  Image,
+                  {
+                    src: item.logo,
+                    alt: item.value,
+                    width: "16px",
+                    height: "16px",
+                    borderRadius: "full"
+                  }
+                ),
+                /* @__PURE__ */ jsx5(Text3, { children: item.label })
+              ] }),
+              /* @__PURE__ */ jsx5(Select2.ItemIndicator, {})
+            ] }, item.value)) }) }) })
+          ]
+        }
+      ),
+      selectedCoin && /* @__PURE__ */ jsx5(
+        Box2,
+        {
+          mt: "2",
+          p: "3",
+          bgGradient: "to-br",
+          gradientFrom: `${accentColor}.500/10`,
+          gradientTo: `${accentColor}.600/10`,
+          borderRadius: "md",
+          borderWidth: "1px",
+          borderColor: `${accentColor}.500/30`,
+          children: /* @__PURE__ */ jsxs4(HStack2, { justify: "space-between", children: [
+            /* @__PURE__ */ jsx5(Text3, { fontSize: "xs", color: "fg.muted", children: "Available:" }),
+            /* @__PURE__ */ jsxs4(VStack2, { gap: "0", align: "end", children: [
+              /* @__PURE__ */ jsxs4(Text3, { fontSize: "sm", fontWeight: "medium", children: [
+                uAmountToAmount(selectedCoin.amount, selectedCoin.decimals),
+                " ",
+                selectedCoin.ticker
+              ] }),
+              selectedCoin.USDValue.gt(0) && /* @__PURE__ */ jsxs4(Text3, { fontSize: "xs", color: "fg.muted", children: [
+                "\u2248 $",
+                shortNumberFormat(selectedCoin.USDValue)
+              ] })
+            ] })
+          ] })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx5(Box2, { children: /* @__PURE__ */ jsxs4(Field.Root, { invalid: sendAmountError !== "", children: [
+      /* @__PURE__ */ jsx5(Field.Label, { children: "Amount" }),
+      /* @__PURE__ */ jsxs4(Group, { attached: true, w: "full", maxW: "sm", children: [
+        /* @__PURE__ */ jsx5(
+          Input2,
+          {
+            size: "sm",
+            placeholder: "Amount to send",
+            value: sendAmount,
+            onChange: (e) => onAmountChange(e.target.value),
+            onBlur: () => validateAmount(sendAmount, selectedCoin, setSendAmountError)
+          }
+        ),
+        /* @__PURE__ */ jsx5(Button2, { variant: "outline", size: "sm", onClick: setMaxAmount, disabled: isLoading, children: "Max" })
+      ] }),
+      /* @__PURE__ */ jsx5(Field.ErrorText, { children: sendAmountError })
+    ] }) }),
+    /* @__PURE__ */ jsx5(Box2, { children: /* @__PURE__ */ jsxs4(Field.Root, { invalid: recipientError !== "", children: [
+      /* @__PURE__ */ jsx5(Field.Label, { children: "Recipient Address" }),
+      /* @__PURE__ */ jsx5(
+        Input2,
+        {
+          size: "sm",
+          placeholder: "bze...2a1b",
+          value: recipient,
+          onChange: (e) => onRecipientChange(e.target.value)
+        }
+      ),
+      /* @__PURE__ */ jsx5(Field.ErrorText, { children: recipientError })
+    ] }) }),
+    /* @__PURE__ */ jsx5(Box2, { children: /* @__PURE__ */ jsxs4(Field.Root, { invalid: memoError !== "", children: [
+      /* @__PURE__ */ jsxs4(Field.Label, { children: [
+        "Memo",
+        /* @__PURE__ */ jsx5(
+          Field.RequiredIndicator,
+          {
+            fallback: /* @__PURE__ */ jsx5(Badge2, { size: "xs", variant: "surface", children: "Optional" })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx5(
+        Textarea,
+        {
+          size: "sm",
+          placeholder: "Transaction memo",
+          rows: 3,
+          value: memo,
+          onChange: (e) => onMemoChange(e.target.value),
+          resize: "none"
+        }
+      ),
+      /* @__PURE__ */ jsx5(Field.ErrorText, { children: memoError })
+    ] }) }),
+    /* @__PURE__ */ jsxs4(HStack2, { gap: "2", children: [
+      /* @__PURE__ */ jsx5(
+        Button2,
+        {
+          size: "sm",
+          flex: "1",
+          onClick: handleSend,
+          colorPalette: accentColor,
+          disabled: !isValidForm || isLoading,
+          loading: isLoading,
+          loadingText: "Sending...",
+          children: "Send"
+        }
+      ),
+      /* @__PURE__ */ jsx5(
+        Button2,
+        {
+          size: "sm",
+          flex: "1",
+          variant: "outline",
+          onClick: handleCancel,
+          disabled: isLoading,
+          children: "Cancel"
+        }
+      )
+    ] })
+  ] });
+};
+var WalletSidebarContent = ({ accentColor = "blue" }) => {
+  const [viewState, setViewState] = useState7("balances");
+  const [isDisconnecting, setIsDisconnecting] = useState7(false);
+  const [showCopiedTooltip, setShowCopiedTooltip] = useState7(false);
+  const [clickedBalance, setClickedBalance] = useState7("");
+  const copyButtonRef = useRef3(null);
+  const {
+    status,
+    username,
+    address,
+    disconnect,
+    connect
+  } = useChain3(getChainName());
+  const { assetsBalances, isLoading: assetsLoading } = useBalances();
+  const balancesWithoutLps = useMemo14(() => {
+    if (assetsLoading) return [];
+    return assetsBalances.filter((asset) => !isLpDenom(asset.denom));
+  }, [assetsLoading, assetsBalances]);
+  const nativeDenom = getChainNativeAssetDenom();
+  const sortedBalances = useMemo14(() => {
+    return balancesWithoutLps.sort((a, b) => {
+      if (a.denom === nativeDenom) return -1;
+      if (b.denom === nativeDenom) return 1;
+      if (a.verified && !b.verified) return -1;
+      if (!a.verified && b.verified) return 1;
+      const aHasBalance = a.amount.gt(0);
+      const bHasBalance = b.amount.gt(0);
+      if (aHasBalance && !bHasBalance) return -1;
+      if (!aHasBalance && bHasBalance) return 1;
+      if (aHasBalance && bHasBalance) {
+        return a.USDValue.gt(b.USDValue) ? -1 : 1;
+      }
+      return 0;
+    });
+  }, [balancesWithoutLps]);
+  const walletAddress = useMemo14(() => stringTruncateFromCenter(address != null ? address : "", 16), [address]);
+  const handleCopyAddress = () => {
+    navigator.clipboard.writeText(address);
+    setShowCopiedTooltip(true);
+    setTimeout(() => setShowCopiedTooltip(false), 2e3);
+  };
+  const handleCancel = useCallback11(() => {
+    setViewState("balances");
+    setClickedBalance("");
+  }, []);
+  const onBalanceClick = useCallback11((ticker) => {
+    setClickedBalance(ticker);
+    setViewState("send");
+  }, []);
+  const handleDisconnectAll = useCallback11(async () => {
+    setIsDisconnecting(true);
+    try {
+      console.log("Disconnected from all chains");
+    } catch (error) {
+      console.error("Error disconnecting:", error);
+    } finally {
+      disconnect();
+      setIsDisconnecting(false);
+    }
+  }, [disconnect]);
+  const renderBalancesView = () => /* @__PURE__ */ jsxs4(VStack2, { gap: "6", align: "stretch", children: [
+    /* @__PURE__ */ jsxs4(Box2, { children: [
+      /* @__PURE__ */ jsx5(Text3, { fontSize: "sm", fontWeight: "medium", mb: "3", children: "Balances" }),
+      /* @__PURE__ */ jsx5(VStack2, { gap: "2", align: "stretch", children: sortedBalances.map((bal) => /* @__PURE__ */ jsx5(BalanceItem, { asset: bal, onClick: () => onBalanceClick(bal.ticker), accentColor }, bal.denom)) })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box2, { children: [
+      /* @__PURE__ */ jsx5(Text3, { fontSize: "sm", fontWeight: "medium", mb: "3", children: "Quick Actions" }),
+      /* @__PURE__ */ jsxs4(VStack2, { gap: "2", align: "stretch", children: [
+        /* @__PURE__ */ jsx5(
+          Button2,
+          {
+            size: "sm",
+            variant: "outline",
+            onClick: () => setViewState("send"),
+            w: "full",
+            disabled: assetsLoading,
+            children: "Send"
+          }
+        ),
+        /* @__PURE__ */ jsxs4(
+          Button2,
+          {
+            size: "sm",
+            variant: "outline",
+            w: "full",
+            onClick: () => openExternalLink("https://go.skip.build/?src_chain=1&src_asset=ethereum-native&dest_chain=beezee-1&dest_asset=ubze"),
+            children: [
+              /* @__PURE__ */ jsx5(LuExternalLink, {}),
+              "Cross-chain Deposit"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs4(
+          Button2,
+          {
+            size: "sm",
+            variant: "outline",
+            w: "full",
+            onClick: () => openExternalLink(`${getChainExplorerURL(getChainName())}/account/${address}`),
+            children: [
+              /* @__PURE__ */ jsx5(LuExternalLink, {}),
+              "View on Explorer"
+            ]
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx5(Box2, { children: /* @__PURE__ */ jsx5(
+      Button2,
+      {
+        size: "sm",
+        width: "full",
+        variant: "outline",
+        colorPalette: "red",
+        onClick: handleDisconnectAll,
+        loading: isDisconnecting,
+        loadingText: "Disconnecting...",
+        children: "Disconnect Wallet"
+      }
+    ) })
+  ] });
+  const statusColor = useMemo14(() => {
+    switch (status) {
+      case WalletState.Connected:
+        return "green";
+      case WalletState.Connecting:
+        return "yellow";
+      case WalletState.Disconnected:
+        return "red";
+      default:
+        return "gray";
+    }
+  }, [status]);
+  return /* @__PURE__ */ jsxs4(VStack2, { gap: "6", align: "stretch", children: [
+    /* @__PURE__ */ jsxs4(Box2, { children: [
+      /* @__PURE__ */ jsx5(InterchainWalletModal, {}),
+      /* @__PURE__ */ jsxs4(HStack2, { justify: "space-between", mb: "3", children: [
+        /* @__PURE__ */ jsx5(Text3, { fontSize: "sm", fontWeight: "medium", children: "Wallet Status" }),
+        /* @__PURE__ */ jsx5(Badge2, { colorPalette: statusColor, size: "sm", children: status })
+      ] }),
+      status === WalletState.Connected && /* @__PURE__ */ jsxs4(
+        Box2,
+        {
+          p: "3",
+          bgGradient: "to-br",
+          gradientFrom: `${accentColor}.500/8`,
+          gradientTo: `${accentColor}.600/8`,
+          borderRadius: "md",
+          borderWidth: "1px",
+          borderColor: `${accentColor}.500/20`,
+          children: [
+            /* @__PURE__ */ jsx5(Text3, { fontSize: "xs", color: "fg.muted", mb: "1", children: username != null ? username : "Address" }),
+            /* @__PURE__ */ jsxs4(HStack2, { justify: "space-between", children: [
+              /* @__PURE__ */ jsx5(Text3, { fontSize: "sm", fontFamily: "mono", children: walletAddress }),
+              /* @__PURE__ */ jsxs4(Box2, { position: "relative", children: [
+                /* @__PURE__ */ jsx5(
+                  Button2,
+                  {
+                    ref: copyButtonRef,
+                    size: "xs",
+                    variant: "ghost",
+                    onClick: handleCopyAddress,
+                    children: /* @__PURE__ */ jsx5(LuCopy, {})
+                  }
+                ),
+                showCopiedTooltip && /* @__PURE__ */ jsx5(
+                  Box2,
+                  {
+                    position: "absolute",
+                    top: "-35px",
+                    right: "0",
+                    bgGradient: "to-br",
+                    gradientFrom: `${accentColor}.500`,
+                    gradientTo: `${accentColor}.600`,
+                    color: "white",
+                    px: "3",
+                    py: "1.5",
+                    borderRadius: "md",
+                    fontSize: "xs",
+                    fontWeight: "semibold",
+                    whiteSpace: "nowrap",
+                    zIndex: "tooltip",
+                    shadow: "md",
+                    children: "Copied!"
+                  }
+                )
+              ] })
+            ] })
+          ]
+        }
+      ),
+      status !== WalletState.Connected && /* @__PURE__ */ jsx5(
+        Button2,
+        {
+          size: "sm",
+          variant: "solid",
+          w: "full",
+          onClick: connect,
+          children: "Connect Wallet"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx5(Separator2, {}),
+    status === WalletState.Connected && viewState === "balances" && renderBalancesView(),
+    status === WalletState.Connected && viewState === "send" && /* @__PURE__ */ jsx5(SendForm, { balances: sortedBalances, onClose: handleCancel, selectedTicker: clickedBalance, accentColor })
+  ] });
+};
+
+// src/components/settings-toggle.tsx
+import { Button as Button3 } from "@chakra-ui/react";
+import { LuSettings } from "react-icons/lu";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function SettingsToggle({ accentColor }) {
+  return /* @__PURE__ */ jsx6(
+    Sidebar,
+    {
+      ariaLabel: "Settings",
+      trigger: /* @__PURE__ */ jsx6(Button3, { variant: "subtle", size: { base: "sm", md: "md" }, children: /* @__PURE__ */ jsx6(LuSettings, {}) }),
+      children: /* @__PURE__ */ jsx6(SettingsSidebarContent, { accentColor })
+    }
+  );
+}
+export {
+  ASSET_TYPE_FACTORY,
+  ASSET_TYPE_IBC,
+  ASSET_TYPE_LP,
+  ASSET_TYPE_NATIVE,
+  AssetsContext,
+  BZE_CIRCLE_LOGO,
+  BZE_TESTNET_2_SUGGEST_CHAIN,
+  BZE_TESTNET_NETWORK,
+  CHART_1D,
+  CHART_1Y,
+  CHART_30D,
+  CHART_4H,
+  CHART_7D,
+  CONNECTION_TYPE_NONE,
+  CONNECTION_TYPE_POLLING,
+  CONNECTION_TYPE_WS,
+  CURRENT_WALLET_BALANCE_EVENT,
+  DEFAULT_SETTINGS,
+  DEFAULT_TX_MEMO,
+  ECOSYSTEM_MENU_LABEL,
+  EPOCH_START_EVENT,
+  EXCLUDED_ASSETS,
+  EXCLUDED_MARKETS,
+  HighlightText,
+  LOCK_CHANGED_EVENT,
+  LP_ASSETS_DECIMALS,
+  MAINNET_CHAIN_INFO_FALLBACK,
+  NEXT_BURN_CHANGED_EVENT,
+  ORDER_BOOK_CHANGED_EVENT,
+  ORDER_EXECUTED_EVENT,
+  ORDER_TYPE_BUY,
+  ORDER_TYPE_SELL,
+  RAFFLE_CHANGED_EVENT,
+  SETTINGS_STORAGE_KEY,
+  STABLE_COINS,
+  SUPPLY_CHANGED_EVENT,
+  SWAP_EXECUTED_EVENT,
+  SettingsSidebarContent,
+  SettingsToggle,
+  Sidebar,
+  TESTNET_CHAIN_INFO_FALLBACK,
+  TOKEN_LOGO_PLACEHOLDER,
+  TTL_NO_EXPIRY,
+  Toaster,
+  TxStatus,
+  VALIDATION_ERRORS,
+  VERIFIED_ASSETS,
+  WalletSidebarContent,
+  addDebounce,
+  addMultipleDebounce,
+  ammRouter,
+  amountToBigNumberUAmount,
+  amountToUAmount,
+  blockchainEventManager,
+  calcNativeStakingApr,
+  calculateAmountFromPrice,
+  calculatePoolOppositeAmount,
+  calculatePoolPrice,
+  calculatePricePerUnit,
+  calculateRewardsStakingApr,
+  calculateRewardsStakingPendingRewards,
+  calculateTotalAmount,
+  calculateUserPoolData,
+  canDepositFromIBC,
+  canSendToIBC,
+  cancelDebounce,
+  convertToWebSocketUrl,
+  counterpartyChainForChannel,
+  createMarketId,
+  createPoolId,
+  createRestClient,
+  denomOnFirstHopChainFromTrace,
+  formatDate,
+  formatTimeRemaining,
+  formatTimeRemainingFromEpochs,
+  formatUsdAmount,
+  getAddressBalances,
+  getAddressDelegations,
+  getAddressFullMarketOrders,
+  getAddressHistory,
+  getAddressMarketOrders,
+  getAddressNativeDelegatedBalance,
+  getAddressNativeTotalRewards,
+  getAddressPendingUnlock,
+  getAddressRewards,
+  getAddressStakingRewards,
+  getAddressSwapHistory,
+  getAddressUnbondingDelegations,
+  getAddressUnbondingDelegationsSummary,
+  getAggregatorHost,
+  getAllBurnedCoins,
+  getAllSupply,
+  getAllSupplyMetadata,
+  getAllTickers,
+  getAnnualProvisions,
+  getAppName,
+  getArchwayRestURL,
+  getArchwayRpcURL,
+  getAssetLists,
+  getAtomOneRestURL,
+  getAtomOneRpcUrl,
+  getBZEUSDPrice,
+  getBurnerParams,
+  getBurnerParamsWithClient,
+  getChainAddressPrefix,
+  getChainAssets,
+  getChainByChainId,
+  getChainByName,
+  getChainExplorerURL,
+  getChainId,
+  getChainName,
+  getChainNativeAssetDenom,
+  getChains,
+  getChartIntervalsLimit,
+  getChartMinutes,
+  getCurrentEpoch,
+  getCurrentWeekEpochEndTime,
+  getDefaultTxMemo,
+  getDenomType,
+  getDistributionParams,
+  getEcosystemApps,
+  getEpochDurationByIdentifier,
+  getEpochsInfo,
+  getFactoryDenomAdminAddress,
+  getFromLocalStorage,
+  getHashIBCTrace,
+  getHourEpochInfo,
+  getIBCAssetList,
+  getIBCTraces,
+  getIbcTransferTimeout,
+  getJackalRestURL,
+  getJackalRpcUrl,
+  getKeyExpiry,
+  getLiquidityPool,
+  getLiquidityPools,
+  getLockedBalances,
+  getLockerAddress,
+  getMarketBuyOrders,
+  getMarketEventKey,
+  getMarketHistory,
+  getMarketOrder,
+  getMarketOrderBookChangedEvent,
+  getMarketOrders,
+  getMarketOrdersHistory,
+  getMarketSellOrders,
+  getMarkets,
+  getMinAmount,
+  getNoOfIntervalsNeeded,
+  getNobleRestURL,
+  getNobleRpcUrl,
+  getOmniFlixRestURL,
+  getOmniFlixRpcUrl,
+  getOsmosisRestURL,
+  getOsmosisRpcUrl,
+  getPageRequestWithLimit,
+  getPendingUnlockParticipants,
+  getPeriodicEpochEndTime,
+  getPeriodicWeekEpochEndTime,
+  getRestClient,
+  getRestURL,
+  getRpcURL,
+  getSettings,
+  getStakingParams,
+  getStakingPool,
+  getStakingRewardParticipantByAddress,
+  getStakingRewards,
+  getTradingViewIntervals,
+  getUSDCDenom,
+  getValidatorPageUrl,
+  getValidatorSupportedDenoms,
+  getWalletChainsNames,
+  getWeekEpochInfo,
+  intlDateFormat,
+  isFactoryDenom,
+  isIbcAsset,
+  isIbcDenom,
+  isLpDenom,
+  isNativeDenom,
+  isPoolSupportedByValidator,
+  isTestnetChain,
+  keplrSuggestChain,
+  mapEventAttributes,
+  openExternalLink,
+  parseUnbondingDays,
+  poolIdFromPoolDenom,
+  prettyAmount,
+  prettyError,
+  priceToBigNumberUPrice,
+  priceToUPrice,
+  removeFromLocalStorage,
+  removeLeadingZeros,
+  sanitizeIntegerInput,
+  sanitizeNumberInput,
+  setDefaultTxMemo,
+  setInLocalStorage,
+  setKeyExpiry,
+  setSettings,
+  setStorageKeyVersion,
+  shortNumberFormat,
+  sleep,
+  stringTruncateFromCenter,
+  toBigNumber,
+  toPercentage,
+  truncateAddress,
+  truncateDenom,
+  uAmountToAmount,
+  uAmountToBigNumberAmount,
+  uPriceToBigNumberPrice,
+  uPriceToPrice,
+  useAsset,
+  useAssetLiquidityPools,
+  useAssetMarkets,
+  useAssetPrice,
+  useAssets,
+  useAssetsContext,
+  useAssetsManager,
+  useAssetsValue,
+  useBZETx,
+  useBalance,
+  useBalances,
+  useConnectionType,
+  useEpochs,
+  useFeeTokens,
+  useIBCChains,
+  useIBCTx,
+  useLiquidityPools,
+  useMarket,
+  useMarkets,
+  useSDKTx,
+  useSettings,
+  useSigningClient,
+  useToast,
+  validateBZEBech32Address,
+  validateBech32Address,
+  validateEndpoints,
+  validateRestEndpoint,
+  validateRpcEndpoint
+};
+//# sourceMappingURL=index.mjs.map