@agg-build/hooks 1.0.0

package/dist/deposit.js

@@ -0,0 +1,1563 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/deposit/index.ts
+var deposit_exports = {};
+__export(deposit_exports, {
+  DEFAULT_SOLANA_RPC_ENDPOINT: () => DEFAULT_SOLANA_RPC_ENDPOINT,
+  SVM_CHAIN_IDS: () => SVM_CHAIN_IDS,
+  normalizeWalletError: () => normalizeWalletError,
+  useDepositAddresses: () => useDepositAddresses,
+  useDepositFlow: () => useDepositFlow,
+  useSyncBalances: () => useSyncBalances,
+  useWalletSendToken: () => useWalletSendToken,
+  useWalletTokenBalance: () => useWalletTokenBalance,
+  useWalletTransactionStatus: () => useWalletTransactionStatus
+});
+module.exports = __toCommonJS(deposit_exports);
+
+// src/deposit/normalize-wallet-error.ts
+function normalizeWalletError(error, supportedChains) {
+  var _a, _b;
+  const message = error instanceof Error ? error.message : String(error);
+  const lower = message.toLowerCase();
+  if (lower.includes("user rejected") || lower.includes("user denied") || lower.includes("rejected the request") || lower.includes("denied transaction signature")) {
+    return { message: "Wallet request rejected.", tone: "error" };
+  }
+  const chainMismatch = message.includes("does not match the target chain") || message.includes("Expected Chain ID:");
+  if (chainMismatch) {
+    const match = message.match(/Expected Chain ID:\s*(\d+)/i);
+    const targetChainId = match ? Number(match[1]) : void 0;
+    const targetChainName = (_b = (_a = supportedChains == null ? void 0 : supportedChains.find((chain) => chain.chainId === targetChainId)) == null ? void 0 : _a.name) != null ? _b : targetChainId ? `chain ${targetChainId}` : "the selected chain";
+    return {
+      message: `Wallet chain does not match. Please switch your wallet to ${targetChainName}.`,
+      tone: "warning"
+    };
+  }
+  return { message, tone: "error" };
+}
+
+// src/deposit/use-wallet-token-balance.ts
+var import_react3 = require("react");
+var import_react_query = require("@tanstack/react-query");
+var import_viem = require("viem");
+var import_wagmi = require("wagmi");
+var import_wallet_adapter_react = require("@solana/wallet-adapter-react");
+var import_web3 = require("@solana/web3.js");
+
+// ../common/src/utils/auth.ts
+function getWalletAddressFromUserProfile(user) {
+  var _a, _b, _c, _d, _e;
+  const oauthWallet = (_b = (_a = user == null ? void 0 : user.accounts) == null ? void 0 : _a.find(
+    (a) => a.type === "oauth" /* oauth */ && String(a.provider).toLowerCase() === "wallet"
+  )) != null ? _b : null;
+  if (oauthWallet == null ? void 0 : oauthWallet.providerAccountId) return oauthWallet.providerAccountId;
+  const siweAccount = (_d = (_c = user == null ? void 0 : user.accounts) == null ? void 0 : _c.find((a) => a.type === "siwe" /* siwe */)) != null ? _d : null;
+  return (_e = siweAccount == null ? void 0 : siweAccount.providerAccountId) != null ? _e : void 0;
+}
+
+// src/core/providers/contexts.ts
+var import_react = require("react");
+
+// src/core/ui-config/labels.ts
+var enUsLabels = {
+  common: {
+    close: "Close",
+    loading: "Loading",
+    retry: "Retry",
+    errorPrefix: "Error",
+    tabsAria: "Tabs",
+    hiddenTabsAria: "Hidden tabs",
+    selectAria: "Select",
+    lineChartAria: "Line chart",
+    candlestickChartAria: "Candlestick chart",
+    lineChartSeriesSwitchAria: "Chart series switch",
+    lineChartSeriesOptionAria: (seriesLabel) => `Show ${seriesLabel} series`,
+    chartTypeSwitchAria: "Chart type switch",
+    lineChartType: "Line",
+    candlestickChartType: "Candlestick"
+  },
+  venues: {
+    polymarket: "Polymarket",
+    kalshi: "Kalshi",
+    opinion: "Opinion",
+    predict: "Predict",
+    limitless: "Limitless",
+    probable: "Probable",
+    myriad: "Myriad",
+    hyperliquid: "Hyperliquid"
+  },
+  auth: {
+    connect: (connectorName) => connectorName ? `Sign in with ${connectorName}` : "Sign in",
+    signIn: "Sign in",
+    signingIn: "Signing in...",
+    signInStatement: "Sign in to AGG",
+    emailAddress: "Email address",
+    continue: "Continue",
+    emailUnavailable: "Email sign-in is currently unavailable.",
+    signInWithMethod: (methodLabel) => `Sign in with ${methodLabel}`,
+    socialWalletNotice: "A wallet will automatically be created for you when signing up with a social account.",
+    learnMore: "Learn more",
+    dividerOr: "OR",
+    connectWallet: "Connect wallet",
+    terms: "Terms",
+    privacyPolicy: "Privacy Policy",
+    legalNoticePrefix: "By signing in, you agree to our",
+    legalNoticeSeparator: "&",
+    deposit: "Deposit",
+    depositGeoBlocked: "Deposits are not available in your region.",
+    balances: "Balances",
+    viewAll: "View All",
+    loadingBalances: "Loading balances...",
+    myProfile: "My Profile",
+    withdraw: "Withdraw",
+    disconnect: "Disconnect",
+    claimWinnings: "Claim Now",
+    claimableWinningsBadge: (count) => `${count} claimable winning${count === 1 ? "" : "s"}`,
+    claimableWinningsTooltip: (count) => `${count} position${count === 1 ? "" : "s"} ready to claim`,
+    walletMenuFor: (profileLabel) => `Profile menu for ${profileLabel}`
+  },
+  deposit: {
+    title: "Deposit",
+    back: "Go back",
+    balancePrefix: "Balance:",
+    balanceLabel: "Balance",
+    done: "Done",
+    methods: {
+      walletTitle: (walletLabel) => `Use your wallet (${walletLabel})`,
+      walletDescription: "Deposit instantly from your connected wallet",
+      cryptoTitle: "Send crypto",
+      cryptoDescription: "Transfer from any wallet or exchange",
+      cardTitle: "Deposit with card",
+      cardDescription: "Buy crypto instantly with your card"
+    },
+    walletFlow: {
+      title: "Use your wallet",
+      tokenLabel: "Token",
+      networkLabel: "Network",
+      amountLabel: "Amount",
+      max: "Max",
+      feePrefix: "Fee ~",
+      confirm: "Confirm Deposit"
+    },
+    sendCrypto: {
+      title: "Send crypto",
+      tokenLabel: "Supported token",
+      networkLabel: "Supported network",
+      depositAddressLabel: "Your deposit address",
+      copy: "Copy",
+      copied: "Copied!",
+      minDepositPrefix: "Min deposit",
+      warning: "Send only the selected token on the selected network. Wrong token or network may results in permanently lost funds.",
+      qrPlaceholder: "QR code placeholder",
+      addressLoadingTitle: "Preparing your deposit address...",
+      addressLoadingDescription: "We're generating your address, this usually takes a few seconds."
+    },
+    cardFlow: {
+      title: "Buy crypto",
+      amountLabel: "Amount",
+      currencyLabel: "Currency",
+      tokenLabel: "Token",
+      networkLabel: "Network",
+      destinationWalletLabel: "Destination wallet",
+      getQuotes: "Get Quotes",
+      minRequired: (amount) => `Min required: ${amount}`,
+      minAmountError: (amount) => `Enter at least ${amount} to continue`,
+      selectProviderTitle: "Select provider",
+      feeLabel: "Fee",
+      providerBadges: {
+        best: "BEST",
+        lowKyc: "LOW KYC"
+      },
+      successTitle: "Purchase complete",
+      successDescription: "Your USDC has been successfully added to your balance.",
+      pendingTitle: (provider) => `Complete your payment on ${provider}`,
+      pendingDescription: "Once your transaction is finished, your balance may take a few minutes to update. The deposit will appear in your activity once it's successful.",
+      viewActivity: "View Activity",
+      chooseAnotherProvider: "Choose another provider",
+      summary: {
+        provider: "Provider",
+        fees: "Fees"
+      },
+      loadingQuotes: "Finding the best rates...",
+      errorLoadingQuotesTitle: "Failed to load quotes",
+      errorLoadingQuotesDescription: "Please try again.",
+      retry: "Retry",
+      noQuotes: "No quotes available for this configuration.",
+      widgetTitle: "Complete Purchase"
+    },
+    processingTitle: "Processing deposit",
+    processingSteps: {
+      submitting: "Waiting for wallet confirmation",
+      submitted: "Wallet confirmed",
+      confirming: "Processing transaction\u2026",
+      updatingBalance: "Updating balance",
+      fundsAvailable: "Funds available"
+    },
+    successTitle: "Deposit complete",
+    successDescription: "Your USDC has been successfully added to your balance.",
+    summary: {
+      amountReceived: "Amount received",
+      network: "Network",
+      fromWallet: "From wallet",
+      gasFee: "Gas fee"
+    }
+  },
+  withdraw: {
+    title: "Withdraw",
+    back: "Go back",
+    done: "Done",
+    balancePrefix: "Balance:",
+    methods: {
+      cardTitle: "Withdraw with card",
+      cardDescription: "Withdraw funds to your card"
+    },
+    cardFlow: {
+      title: "Sell crypto",
+      amountLabel: "Amount",
+      currencyLabel: "Currency",
+      tokenLabel: "Token",
+      networkLabel: "Network",
+      destinationWalletLabel: "Destination wallet",
+      getQuotes: "Get Quotes",
+      selectProviderTitle: "Select provider",
+      feeLabel: "Fee",
+      providerBadges: {
+        best: "BEST",
+        lowKyc: "LOW KYC"
+      },
+      successTitle: "Withdrawal complete",
+      successDescription: "Your USDC has been successfully sent to your wallet.",
+      summary: {
+        provider: "Provider",
+        toWallet: "To wallet",
+        fees: "Fees"
+      }
+    },
+    summary: {
+      amountReceived: "Amount received",
+      network: "Network"
+    }
+  },
+  markets: {
+    emptyNoOpen: "No open markets available.",
+    emptyResolved: "This event has been resolved."
+  },
+  home: {
+    trending: "Trending",
+    topMarkets: "Top Markets",
+    newMarkets: "New Markets",
+    categoryTabsAria: "Home page category tabs"
+  },
+  userProfile: {
+    activity: {
+      depositType: "Deposit",
+      withdrawalType: "Withdraw",
+      depositTitles: {
+        connectedWallet: "Deposit from connected wallet",
+        externalWallet: "Deposit from external wallet",
+        card: "Deposit with card"
+      },
+      withdrawalTitle: (tokenSymbol) => `Withdraw ${tokenSymbol}`
+    },
+    positions: {
+      totalTradedHeader: "Total traded",
+      amountWonHeader: "Amount won",
+      claimHeader: "Claim",
+      claim: "Claim",
+      claimed: "Claimed",
+      pending: "Pending",
+      won: "Won",
+      lost: "Lost",
+      resolved: "Resolved",
+      marketClosed: "Market closed",
+      closed: "Closed"
+    }
+  },
+  eventList: {
+    matchedTab: "Matched",
+    loading: (title) => `Loading ${title}`,
+    tabsAria: (title) => `${title} tabs`,
+    emptyAria: "No events found",
+    emptyTitle: "No Events Found",
+    emptyDescription: "We couldn't find any events matching your filters.\nTry adjusting them or check back later.",
+    empty: "No events found for this tab.",
+    errorTitle: "Something went wrong",
+    errorDescription: "We're having trouble loading data right now.\nTry refreshing or check back later.",
+    viewResolved: "View resolved",
+    hideResolved: "Hide resolved"
+  },
+  search: {
+    placeholder: "Search...",
+    inputAria: "Search markets",
+    resultsAria: "Search results",
+    resultAria: (title) => `View ${title}`,
+    resultsSummary: (countLabel, query) => `${countLabel} search results for "${query}"`,
+    seeAllResults: "See all results",
+    loadingResults: "Loading search results",
+    noResultsTitle: "No markets found",
+    noResultsDescription: "Check your spelling or try a broader search term."
+  },
+  eventItem: {
+    loading: "Loading market tile",
+    unavailableAria: "Market tile unavailable",
+    unavailableTitle: "Market unavailable",
+    unavailableDescription: "We could not load this market right now.",
+    arbitrage: "Arbitrage",
+    priceGap: "Price Gap",
+    volumeSuffix: "Vol.",
+    marketSingular: "Market",
+    marketPlural: "Markets",
+    venueSingular: "Venue",
+    venuePlural: "Venues"
+  },
+  eventItemDetails: {
+    loading: "Loading market details",
+    unavailableAria: "Market details unavailable",
+    unavailableTitle: "Market details unavailable",
+    unavailableDescription: "We could not load this market right now.",
+    notFoundAria: "Event not found",
+    notFoundTitle: "Event Not Found",
+    notFoundDescription: "We couldn't find this event or it may no longer exist.",
+    chartUnavailableAria: "Chart unavailable",
+    chartUnavailableTitle: "Chart Unavailable",
+    chartUnavailableDescription: "We couldn't load live chart data for this event.",
+    historicalLineChartAria: (title) => `${title} historical line chart`,
+    outcomeSelectorAria: "Outcome selector",
+    yes: "Yes",
+    no: "No",
+    allTimeRange: "All",
+    volumeSuffix: "Vol.",
+    marketSelectPlaceholder: "Select market",
+    marketSelectSearchPlaceholder: "Search markets...",
+    marketSelectEmpty: "No markets found"
+  },
+  settlementSummary: {
+    title: "Settlement",
+    readFullDetails: "Read full details",
+    showLess: "Show less"
+  },
+  marketDetails: {
+    loading: "Loading market details",
+    unavailableAria: "Market details unavailable",
+    unavailableTitle: "Market details unavailable",
+    unavailableDescription: "We could not load this market right now.",
+    notFoundAria: "Market not found",
+    notFoundTitle: "Market Not Found",
+    notFoundDescription: "We couldn't find this market or it may no longer exist.",
+    chartUnavailableAria: "Chart unavailable",
+    chartUnavailableTitle: "Chart Unavailable",
+    chartUnavailableDescription: "We couldn't load live chart data for this market.",
+    orderBookEmptyAria: "No orders yet",
+    orderBookEmptyTitle: "No orders yet",
+    orderBookEmptyDescription: "Be the first to set the price on this market.",
+    orderBookResolvedAria: "Market resolved",
+    orderBookResolvedTitle: "Market Resolved",
+    orderBookResolvedDescription: "This market has been resolved and is no longer trading.",
+    orderBookUnavailableAria: "Orderbook unavailable",
+    orderBookUnavailableTitle: "Orderbook Unavailable",
+    orderBookUnavailableDescription: "We couldn't load live order data for this market.",
+    marketOutcomesAria: "Market outcomes",
+    tabsAria: "Market details tabs",
+    toggleOpenDetailsAria: (title) => `Open details for ${title}`,
+    toggleCloseDetailsAria: (title) => `Close details for ${title}`,
+    loadingOrderbookAria: "Loading orderbook",
+    loadingOrderbookLabel: "Loading orderbook...",
+    asks: "Asks",
+    bids: "Bids",
+    spread: "Spread",
+    midPrice: "Mid",
+    tradePrefix: "Trade",
+    priceColumn: "Price",
+    sharesColumn: "Shares",
+    totalColumn: "Total",
+    lastPrice: "Last",
+    graphAria: (title) => `${title} price history`,
+    outcomeSelectorAria: "Outcome selector",
+    showOutcomeAria: (label) => `Show ${label} outcome`,
+    viewResolved: "View resolved",
+    hideResolved: "Hide resolved",
+    volumeUnavailable: "Volume unavailable",
+    tabs: {
+      orderBook: "Order Book",
+      graph: "Graph",
+      other: "Other"
+    },
+    meta: {
+      status: "Status",
+      created: "Created",
+      opens: "Opens",
+      closes: "Closes",
+      markets: "Markets",
+      unknown: "Unknown",
+      venueSingular: "Venue",
+      venuePlural: "Venues",
+      volumeSuffix: "Vol."
+    }
+  },
+  trading: {
+    settlementSection: "Settlement",
+    settlementDifferencesTitle: "Key differences across venues",
+    settlementLoading: "Loading settlement",
+    settlementDetailsAria: (venueLabel) => `${venueLabel} settlement details`,
+    settlementShowMoreAria: (ctaLabel, venueLabel) => `${ctaLabel} for ${venueLabel}`,
+    settlementDescriptionLabel: "Description",
+    settlementRulesPrimaryLabel: "Resolution rules",
+    settlementRulesSecondaryLabel: "Additional rules",
+    disclaimer: "By trading, you agree to the Terms of Use of each exchange.",
+    geoBlockTermsLink: "Terms of Use",
+    geoBlockGenericMessage: "Trading is not available in your region. See ",
+    geoBlockVenueMessage: (venueLabel) => `Trading on ${venueLabel} is not available in your region. See `,
+    geoBlockMessageSuffix: " for more information.",
+    geoBlockModalAriaLabel: "Geo-restricted location",
+    geoBlockModalTitle: "Trading is not available in your current location",
+    geoBlockModalDescription: "You appear to be located in a restricted jurisdiction. You can still browse markets in view-only mode or return when you're in a supported region.",
+    geoBlockModalConfirm: "Confirm",
+    averagePrice: (value) => `${(value * 100).toLocaleString("en-US", {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 2
+    })}\xA2 avg. price`,
+    balance: (value) => `Balance ${value}`,
+    shares: (value) => `${value.toLocaleString("en-US", {
+      minimumFractionDigits: Number.isInteger(value) ? 0 : 2,
+      maximumFractionDigits: 6
+    })} shares`,
+    slippage: (value) => `Slippage: ${value}%`,
+    editSlippage: (value) => `Edit ${value}`,
+    collapseSlippage: (value) => `Collapse ${value}`,
+    resetSlippage: "Auto",
+    slippageWarning: (value) => `Slippage below ${value}% may prevent your order from executing.`,
+    slippageLow: (value) => `Slippage below ${value}% may prevent your order from executing.`,
+    slippageHigh: (value) => `Slippage above ${value}% increases the chance of an unfavorable trade.`,
+    showAdditionalVenues: (count) => `Show ${count} more venue${count === 1 ? "" : "s"}`,
+    hideAdditionalVenues: "Hide additional venues",
+    quoteExpired: "Quote expired. Please refresh.",
+    orderSubmitted: "Order submitted",
+    orderPending: "Your order is being processed...",
+    orderFailed: "Order failed. Please try again.",
+    orderDisabledEventResolved: "This event has been resolved.",
+    orderDisabledEventClosed: "This event is no longer accepting orders.",
+    orderDisabledEventPaused: "Trading is temporarily paused for this event.",
+    orderDisabledEventUnopened: "Trading has not opened yet for this event.",
+    orderDisabledEventUnavailable: "Trading is currently unavailable.",
+    orderDisabledMarketResolved: "This market has been resolved.",
+    orderDisabledMarketClosed: "This market is no longer accepting orders.",
+    orderDisabledMarketPaused: "Trading is temporarily paused for this market.",
+    orderDisabledMarketUnopened: "Trading has not opened yet for this market.",
+    orderDisabledMarketUnavailable: "Trading is currently unavailable for this market.",
+    orderDisabledNoMarket: "Select a market to place an order.",
+    orderDisabledNoOutcome: "Select an outcome to place an order.",
+    orderDisabledNoEvent: "No event selected.",
+    insufficientBalance: "Insufficient balance",
+    refreshQuote: "Refresh Quote",
+    confirmOrder: "Confirm Order",
+    withdrawSubmitted: "Withdrawal submitted",
+    withdrawProcessing: "Your withdrawal is being processed...",
+    estimatedCost: (value) => `Est. cost ${value}`,
+    partialFill: (filledSize, requestedSize) => `Only ${filledSize} of ${requestedSize} shares available at this price.`,
+    insufficientLiquidity: "Not enough liquidity available for this order size.",
+    noMarketSelected: "Select a market to place an order.",
+    noOrderbooks: "No live orderbooks are available for this market right now.",
+    quoteUnavailable: "Quote temporarily unavailable. Please try again.",
+    selectedVenueUnavailable: "The venue you selected is no longer available on this route. Review the updated options and try again.",
+    engineUnavailable: "The routing engine is temporarily unavailable. Please try again in a moment.",
+    insufficientInputAmount: "Trade amount is too small to cover bridging and execution costs. Increase your spend or deposit funds on the destination chain.",
+    minOrderSizeViolated: "Order size is below the venue minimum. Increase your spend.",
+    minimumOrderAmount: (amount) => `Minimum order is $${amount}`,
+    insufficientPosition: (totalShares) => `You only have ${totalShares} shares available to sell.`,
+    insufficientPositionGeneric: "You don't have enough shares to sell.",
+    insufficientSellDepth: "Not enough bid liquidity on the matched venues for this sell amount.",
+    noBidsAboveMinPrice: "No venue bids above the minimum price.",
+    signInRequired: "Sign in to get a routed quote",
+    kycRequired: "Verify to trade Kalshi",
+    kycNotVerifiedTooltip: "You have not been verified yet",
+    kycVerifyModalTitle: "Verify Your Identity",
+    kycVerifyModalDescription: "To start trading on Kalshi, you'll need to complete identity verification through dFlow. It only takes a few minutes and helps us stay compliant with regulations.",
+    kycStartVerification: "Start Verification",
+    kycDoItLater: "Do It Later",
+    kycSuccessTitle: "Verification successful",
+    kycSuccessDescription: "Your identity has been confirmed and you now have full access to trade on Kalshi markets.",
+    kycSuccessDone: "Done",
+    outcome: (label) => `Outcome: ${label}`,
+    smartRouting: "Smart Routing",
+    orderSplitting: "Order Splitting",
+    splitOrderDescription: "We split your order for the best price:",
+    viewAllRoutes: (count) => `View all (${count})`,
+    hideRoutes: "Hide routes",
+    venueUnavailableInRegion: "Unavailable in your region",
+    toWin: (tab) => tab === "buy" ? "To win" : "Payout",
+    buyingOutcome: (label) => `Buying ${label}`,
+    sellingOutcome: (label) => `Selling ${label}`,
+    findingBestRoute: "Finding the best route...",
+    submittingOrderProgress: "Submitting order...",
+    orderSubmittedProgress: (orderId) => `Order #${orderId.replace(/^#/, "")} submitted`,
+    executingOnVenue: (venueLabel) => `Executing on ${venueLabel}...`,
+    confirmTransactionInWallet: "Confirm the transaction in your wallet",
+    executionConfirmed: "Execution confirmed",
+    orderSuccessTitle: "Order placed",
+    orderSuccessDescription: "Your order has been submitted successfully.",
+    orderFailureTitle: "Order failed",
+    orderFailureDescription: (message) => message || "Something went wrong. Please try again.",
+    orderDone: "Done",
+    orderNewTrade: "New Trade",
+    orderShare: "Share",
+    orderRetry: "Try again",
+    orderContinue: "Continue",
+    orderDismiss: "Dismiss",
+    orderRetryVenue: (venueLabel) => `Retry ${venueLabel}`,
+    orderPartialFillStatus: (venueLabel) => `${venueLabel} order partially filled`,
+    orderVenueUnavailableStatus: (venueLabel) => `${venueLabel} unavailable, your funds have not been charged.`,
+    orderMarketResolvedStatus: (venueLabel) => `Market resolved on ${venueLabel} and is no longer accepting orders.`,
+    orderSummaryShares: "Shares",
+    orderSummaryAvgPrice: "Avg. price",
+    orderSummaryEstCost: "Est. cost",
+    orderSummaryVenue: "Venue",
+    orderComplete: "Order complete",
+    orderFilledAtPrice: (venueLabel, priceLabel) => `${venueLabel} order filled at ${priceLabel}`,
+    orderFilledAtPriceWithAmount: (venueLabel, priceLabel, amountLabel) => `${venueLabel} order filled at ${priceLabel} (${amountLabel})`,
+    orderPartiallyFilledAtPriceWithAmount: (venueLabel, priceLabel, amountLabel) => `${venueLabel} order partially filled at ${priceLabel} (${amountLabel})`,
+    orderSkip: "Skip",
+    orderRetryRemaining: "Retry remaining",
+    resolvedEarningsTitle: "Your Earnings",
+    resolvedSharesLabel: "Shares",
+    resolvedTotalPayoutLabel: "Total payout",
+    claimWinnings: "Claim Winnings",
+    boughtOutcomeAtPrice: (label, priceLabel) => `Bought ${label} at ${priceLabel}`,
+    soldOutcomeAtPrice: (label, priceLabel) => `Sold ${label} at ${priceLabel}`,
+    potentialReturnBonus: (value) => `+${value} Better Payout`,
+    withSmartRouting: "with Smart Routing",
+    buy: "Buy",
+    sell: "Sell",
+    amount: (side) => `${side === "buy" ? "Amount" : "Shares"}`
+  },
+  onboarding: {
+    modal: {
+      title: "Onboarding",
+      stepHowItWorks: "How it works",
+      stepProfileSetup: "Set up your profile",
+      stepConnectAccounts: "Connect accounts"
+    },
+    howItWorks: {
+      title: "How it works",
+      continue: "Continue",
+      features: {
+        createAccount: {
+          title: "Create Your Account",
+          description: "Add a few basic details to set up your account and personalize your experience on the platform."
+        },
+        linkAccounts: {
+          title: "Link Trading Accounts",
+          description: "Connect supported exchanges to unlock additional markets and liquidity. Trade across decentralized markets in one interface."
+        },
+        bestPrices: {
+          title: "Best Prices Always",
+          description: "Our real-time aggregated orderbook lets you shop lines across exchanges and automatically splits predictions to optimize trades."
+        },
+        stayInControl: {
+          title: "You Stay in Control",
+          description: "All trades are executed on the original platform. We never custody funds or move money on your behalf."
+        }
+      }
+    },
+    profileSetup: {
+      title: "Set up your profile",
+      uploadProfilePictureAria: "Upload profile picture",
+      profilePreviewAlt: "Profile preview",
+      usernameLabel: "Username",
+      usernamePlaceholder: "e.g. CryptoJohn",
+      continue: "Continue"
+    },
+    connectAccounts: {
+      title: "Connect Accounts",
+      connect: "Connect",
+      connectAccount: "Connect Account",
+      continue: "Continue",
+      onchainTitle: "Onchain exchanges",
+      onchainMobileTitle: (additionalVenueCount) => `Polymarket +${additionalVenueCount} venues`,
+      onchainDescription: "Trade multiple venues with one signature.",
+      onchainMobileDescription: "Trade multiple exchanges with one signature",
+      kalshiTitle: "US regulated exchanges",
+      kalshiMobileTitle: "Kalshi",
+      kalshiDescription: "Trade on regulated markets via Kalshi.",
+      kalshiMobileDescription: "Connect your Kalshi account"
+    },
+    connectOnchainModal: {
+      ariaLabel: "Connect Onchain Exchanges",
+      title: "Connect Onchain Exchanges",
+      description: "Sign in with your wallet to trade across supported\nonchain prediction markets.",
+      supportedVenuesLabel: "Supported venues:",
+      connect: "Sign In with Wallet",
+      cancel: "Cancel",
+      fallbackError: "Signature declined. Please try again."
+    },
+    connectKalshiModal: {
+      ariaLabel: "Connect Kalshi Account",
+      title: "Connect Kalshi Account",
+      description: "You'll generate an API key in Kalshi profile and add it to connect your account. These keys are used only to execute trades on your behalf.",
+      stepOne: {
+        label: "Step 1",
+        title: "Generate a Read/Write API Key in Kalshi",
+        instructions: {
+          signIn: "1. Sign in to your Kalshi account.",
+          goToProfilePrefix: "2. Go to your",
+          profileText: "Profile",
+          goToProfileSeparator: ":",
+          profileUrl: "https://kalshi.com/account/profile",
+          clickCreateKeyPrefix: "3. Click",
+          createKeyText: "Create Key",
+          clickCreateKeySuffix: ".",
+          selectPermissionsPrefix: "4. Select",
+          readWriteText: "Read/Write",
+          selectPermissionsSuffix: " permissions.",
+          createKey: "5. Create the key."
+        },
+        footerLineOne: "Kalshi will display your API Key ID and Private Key.",
+        footerLineTwo: "You'll need both for the next step."
+      },
+      stepTwo: {
+        label: "Step 2",
+        title: "Paste Your Kalshi API Credentials",
+        description: "These credentials are encrypted and used only to execute trades on your behalf. We can't access your funds directly.",
+        apiKeyIdLabel: "API Key ID",
+        apiKeyIdPlaceholder: "a3f9c1b2-7d4e-4c91-9f2a-8b6e1d3c5a77",
+        privateKeyLabel: "Private Key",
+        privateKeyPlaceholder: "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASC..."
+      },
+      help: {
+        label: "Having trouble?",
+        docsLinkLabel: "View Kalshi docs",
+        tutorialLinkLabel: "Watch tutorial video"
+      },
+      actions: {
+        cancel: "Cancel",
+        verifyConnection: "Verify Connection"
+      },
+      fallbackError: "Verification failed. Please check your credentials and try again."
+    }
+  },
+  eventMarketPage: {
+    unavailableAria: "Event market page unavailable",
+    unavailableTitle: "Something went wrong",
+    unavailableDescription: "We're having trouble loading this event right now.\nTry refreshing or check back later.",
+    loadingSettlementQuestion: "Loading settlement",
+    loadingSettlementDifferencesTitle: "Loading settlement",
+    loadingSettlementPlaceholder: "Loading",
+    tradingResolvedBadge: "Resolved",
+    tradingResolvedTitle: "Market resolved",
+    tradingResolvedDescription: "Trading has ended for this event. You can review the final result.",
+    tradingClosedBadge: "Closed",
+    tradingClosedTitle: "Trading closed",
+    tradingClosedDescription: "This event is no longer accepting new orders.",
+    tradingPausedBadge: "Paused",
+    tradingPausedTitle: "Trading paused",
+    tradingPausedDescription: "Trading is temporarily unavailable for this event.",
+    tradingUnopenedBadge: "Upcoming",
+    tradingUnopenedTitle: "Trading not open yet",
+    tradingUnopenedDescription: "This event is listed, but trading has not opened yet.",
+    tradingUnavailableBadge: "Unavailable",
+    tradingUnavailableTitle: "Trading unavailable",
+    tradingUnavailableDescription: "Trading is currently unavailable for this event.",
+    resolvedAt: (dateLabel) => `Resolved ${dateLabel}`,
+    closedAt: (dateLabel) => `Closed ${dateLabel}`,
+    opensAt: (dateLabel) => `Opens ${dateLabel}`,
+    winningOutcome: (label) => `Winning outcome: ${label}`,
+    resolvedOutcome: (label) => `Resolved: ${label}`,
+    marketDetailsAriaByDate: (dateLabel) => `Market details for ${dateLabel}`,
+    marketDetailsAriaByQuestion: (question) => `Market details for ${question}`
+  },
+  header: {
+    bannerAria: "Site header",
+    logoAria: "Home"
+  }
+};
+var defaultAggUiLabelsByLocale = {
+  "en-US": enUsLabels,
+  en: enUsLabels
+};
+var resolveAggUiLabels = (locale) => {
+  var _a;
+  if (defaultAggUiLabelsByLocale[locale]) {
+    return defaultAggUiLabelsByLocale[locale];
+  }
+  const baseLocale = locale.split("-")[0];
+  return (_a = defaultAggUiLabelsByLocale[baseLocale]) != null ? _a : enUsLabels;
+};
+
+// src/core/ui-config/utils.ts
+var DEFAULT_LOCALE = "en-US";
+var createFormatters = (locale) => {
+  const number = new Intl.NumberFormat(locale, {
+    maximumFractionDigits: 2
+  });
+  const percent = new Intl.NumberFormat(locale, {
+    style: "percent",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0
+  });
+  const currency = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: "USD",
+    maximumFractionDigits: 2
+  });
+  const compactCurrency = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: "USD",
+    notation: "compact",
+    maximumFractionDigits: 0
+  });
+  const date = new Intl.DateTimeFormat(locale, {
+    month: "long",
+    day: "numeric",
+    year: "numeric"
+  });
+  return {
+    formatNumber: (value) => number.format(value),
+    formatPercent: (value) => percent.format(value),
+    formatCurrency: (value) => currency.format(value),
+    formatCompactCurrency: (value) => compactCurrency.format(value),
+    formatDate: (value) => date.format(value)
+  };
+};
+var defaultFormatters = createFormatters(DEFAULT_LOCALE);
+var defaultAggUiSearchConfig = {
+  value: "",
+  result: null,
+  isShowingAllResults: false
+};
+var defaultAggUiConfig = {
+  enableLogs: false,
+  enableWebsocketsLogs: false,
+  general: {
+    locale: DEFAULT_LOCALE,
+    theme: "light",
+    rootClassName: "",
+    labels: resolveAggUiLabels(DEFAULT_LOCALE)
+  },
+  features: {
+    enableAnimations: true,
+    enableLiveUpdates: true,
+    enableGradients: false
+  },
+  market: {
+    arbitrageThreshold: 0
+  },
+  chart: {
+    defaultChartTimeRange: "1D",
+    selectedChartTimeRange: "1D",
+    setSelectedChartTimeRange: () => {
+    }
+  },
+  formatting: defaultFormatters,
+  search: defaultAggUiSearchConfig
+};
+
+// src/core/providers/contexts.ts
+var AggClientContext = (0, import_react.createContext)(null);
+var AggUiContext = (0, import_react.createContext)(defaultAggUiConfig);
+var AggLabelsContext = (0, import_react.createContext)(defaultAggUiConfig.general.labels);
+var AggAuthContext = (0, import_react.createContext)(null);
+var AggBalanceContext = (0, import_react.createContext)(null);
+
+// src/execution/query-keys.ts
+var executionKeys = {
+  all: () => ["execution"],
+  balances: () => ["execution", "balances"],
+  positions: (cursor, limit, status) => ["execution", "positions", cursor != null ? cursor : null, limit != null ? limit : null, status != null ? status : null],
+  positionsPrefix: () => ["execution", "positions"],
+  claimableClosedPositionsCount: () => ["execution", "positions", "claimable-count"],
+  orders: (status, cursor, limit) => ["execution", "orders", status != null ? status : null, cursor != null ? cursor : null, limit != null ? limit : null],
+  ordersPrefix: () => ["execution", "orders"],
+  depositAddresses: () => ["execution", "deposit-addresses"]
+};
+
+// src/execution/balance-invalidation.ts
+var balanceQueryKeys = {
+  execution: () => executionKeys.balances(),
+  // Kept as an alias for backward compatibility with existing callers.
+  // The balance provider now uses the same canonical execution balances key.
+  provider: () => executionKeys.balances(),
+  venue: (venuesKey) => ["venue-balances", venuesKey],
+  venuePrefix: () => ["venue-balances"]
+};
+var invalidateBalanceQueries = (queryClient, options) => {
+  var _a;
+  const refetchType = (_a = options == null ? void 0 : options.refetchType) != null ? _a : "active";
+  const executionKey = balanceQueryKeys.execution();
+  const providerKey = balanceQueryKeys.provider();
+  queryClient.invalidateQueries({
+    queryKey: executionKey,
+    refetchType
+  });
+  const isProviderKeyDistinct = providerKey.length !== executionKey.length || providerKey.some((segment, index) => segment !== executionKey[index]);
+  if (isProviderKeyDistinct) {
+    queryClient.invalidateQueries({
+      queryKey: providerKey,
+      refetchType
+    });
+  }
+  queryClient.invalidateQueries({
+    queryKey: balanceQueryKeys.venuePrefix(),
+    refetchType
+  });
+};
+
+// src/core/providers/hooks.ts
+var import_react2 = require("react");
+var useAggClient = () => {
+  const client = (0, import_react2.useContext)(AggClientContext);
+  if (!client) {
+    throw new Error("useAggClient must be used within an <AggProvider>");
+  }
+  return client;
+};
+var useAggUiConfig = () => {
+  return (0, import_react2.useContext)(AggUiContext);
+};
+var useAggAuthContext = () => {
+  const context = (0, import_react2.useContext)(AggAuthContext);
+  if (!context) {
+    throw new Error("useAggAuthContext must be used within an <AggProvider>");
+  }
+  return context;
+};
+var useAggAuthState = useAggAuthContext;
+var useAggBalanceContext = () => {
+  const context = (0, import_react2.useContext)(AggBalanceContext);
+  if (!context) {
+    throw new Error("useAggBalanceContext must be used within an <AggProvider>");
+  }
+  return context;
+};
+var useAggBalanceState = useAggBalanceContext;
+
+// src/deposit/constants.ts
+var DEFAULT_SOLANA_RPC_ENDPOINT = "https://solana-rpc.publicnode.com";
+var SVM_CHAIN_IDS = /* @__PURE__ */ new Set([792703809]);
+
+// src/deposit/use-wallet-token-balance.ts
+var ERC20_BALANCE_OF_ABI = [
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+function getPhantomProvider() {
+  var _a, _b;
+  if (typeof window === "undefined") return void 0;
+  const w = window;
+  return (_b = (_a = w.phantom) == null ? void 0 : _a.solana) != null ? _b : w.solana;
+}
+function useWalletTokenBalance({
+  isOpen = true,
+  chainId,
+  tokenAddress,
+  decimals,
+  svmAddress
+}) {
+  var _a, _b, _c;
+  const { solanaRpcUrl } = useAggUiConfig();
+  const rpcEndpoint = solanaRpcUrl != null ? solanaRpcUrl : DEFAULT_SOLANA_RPC_ENDPOINT;
+  const isSvm = chainId !== void 0 && SVM_CHAIN_IDS.has(chainId);
+  const { address: evmAddress } = (0, import_wagmi.useAccount)();
+  const evmEnabled = isOpen && !isSvm && !!chainId && !!tokenAddress && !!evmAddress && decimals !== void 0;
+  const { data: rawEvmBalance, isLoading: evmLoading } = (0, import_wagmi.useReadContract)({
+    address: tokenAddress,
+    chainId,
+    abi: ERC20_BALANCE_OF_ABI,
+    functionName: "balanceOf",
+    args: evmAddress ? [evmAddress] : void 0,
+    query: { enabled: evmEnabled, staleTime: 0, refetchOnMount: true }
+  });
+  const { publicKey: adapterPublicKey } = (0, import_wallet_adapter_react.useWallet)();
+  const [phantomAddress, setPhantomAddress] = (0, import_react3.useState)(void 0);
+  (0, import_react3.useEffect)(() => {
+    var _a2;
+    if (!isSvm) return;
+    const provider = getPhantomProvider();
+    if (!provider) return;
+    const existing = (_a2 = provider.publicKey) == null ? void 0 : _a2.toBase58();
+    if (existing) {
+      setPhantomAddress(existing);
+      return;
+    }
+    provider.connect({ onlyIfTrusted: true }).then((res) => setPhantomAddress(res.publicKey.toString())).catch(() => {
+    });
+  }, [isSvm]);
+  const resolvedSvmAddress = (_b = (_a = adapterPublicKey == null ? void 0 : adapterPublicKey.toBase58()) != null ? _a : phantomAddress) != null ? _b : svmAddress;
+  const connection = (0, import_react3.useMemo)(() => new import_web3.Connection(rpcEndpoint), [rpcEndpoint]);
+  const svmEnabled = isOpen && isSvm && !!resolvedSvmAddress && !!tokenAddress;
+  const svmQuery = (0, import_react_query.useQuery)({
+    queryKey: ["svm-token-balance", resolvedSvmAddress != null ? resolvedSvmAddress : null, tokenAddress != null ? tokenAddress : null, isOpen],
+    enabled: svmEnabled,
+    staleTime: 0,
+    queryFn: () => __async(null, null, function* () {
+      var _a2;
+      if (!resolvedSvmAddress || !tokenAddress) return 0;
+      const owner = new import_web3.PublicKey(resolvedSvmAddress);
+      const mint = new import_web3.PublicKey(tokenAddress);
+      const accounts = yield connection.getTokenAccountsByOwner(owner, { mint });
+      if (accounts.value.length === 0) return 0;
+      const first = accounts.value[0];
+      if (!first) return 0;
+      const balance = yield connection.getTokenAccountBalance(first.pubkey);
+      return (_a2 = balance.value.uiAmount) != null ? _a2 : 0;
+    })
+  });
+  if (isSvm) {
+    const awaitingSelection2 = isOpen && !!chainId && !tokenAddress;
+    return {
+      balance: (_c = svmQuery.data) != null ? _c : 0,
+      isLoading: awaitingSelection2 || svmQuery.isLoading || svmQuery.isFetching
+    };
+  }
+  const evmBalance = rawEvmBalance !== void 0 && decimals !== void 0 ? Number((0, import_viem.formatUnits)(rawEvmBalance, decimals)) : 0;
+  const awaitingSelection = isOpen && !!chainId && !tokenAddress;
+  return { balance: evmBalance, isLoading: awaitingSelection || evmLoading };
+}
+
+// src/deposit/use-wallet-send-token.ts
+var import_react4 = require("react");
+var import_viem2 = require("viem");
+var import_wagmi2 = require("wagmi");
+var import_wallet_adapter_react2 = require("@solana/wallet-adapter-react");
+var import_web32 = require("@solana/web3.js");
+function getPhantomProvider2() {
+  var _a, _b;
+  if (typeof window === "undefined") return void 0;
+  const w = window;
+  return (_b = (_a = w.phantom) == null ? void 0 : _a.solana) != null ? _b : w.solana;
+}
+var ERC20_TRANSFER_ABI = [
+  {
+    constant: false,
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "transfer",
+    outputs: [{ name: "", type: "bool" }],
+    type: "function"
+  }
+];
+function useWalletSendToken() {
+  const { solanaRpcUrl } = useAggUiConfig();
+  const rpcEndpoint = solanaRpcUrl != null ? solanaRpcUrl : DEFAULT_SOLANA_RPC_ENDPOINT;
+  const { writeContractAsync } = (0, import_wagmi2.useWriteContract)();
+  const { publicKey, sendTransaction } = (0, import_wallet_adapter_react2.useWallet)();
+  return (0, import_react4.useCallback)(
+    (params) => __async(null, null, function* () {
+      var _a, _b;
+      const isSvm = SVM_CHAIN_IDS.has(params.chainId);
+      if (!isSvm) {
+        const tokenAddress = params.token.address;
+        if (!tokenAddress) {
+          throw new Error("Missing ERC-20 token address for EVM transfer");
+        }
+        const value = (0, import_viem2.parseUnits)(params.amount || "0", params.token.decimals);
+        const txHash = yield writeContractAsync({
+          chainId: params.chainId,
+          address: tokenAddress,
+          abi: ERC20_TRANSFER_ABI,
+          functionName: "transfer",
+          args: [params.to, value]
+        });
+        return { txId: txHash };
+      }
+      if (!params.token.address) {
+        throw new Error("Missing SPL token mint address for Solana transfer");
+      }
+      const phantom = getPhantomProvider2();
+      let ownerBase58 = publicKey == null ? void 0 : publicKey.toBase58();
+      if (!ownerBase58 && phantom) {
+        try {
+          const res = yield phantom.connect();
+          ownerBase58 = res.publicKey.toString();
+        } catch (err) {
+          throw new Error(
+            `Failed to connect Phantom: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      if (!ownerBase58) {
+        throw new Error("No Solana wallet connected");
+      }
+      const sendConnection = new import_web32.Connection(rpcEndpoint, "confirmed");
+      const TOKEN_PROGRAM_ID = new import_web32.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+      const ASSOCIATED_TOKEN_PROGRAM_ID = new import_web32.PublicKey(
+        "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+      );
+      const owner = new import_web32.PublicKey(ownerBase58);
+      const mint = new import_web32.PublicKey(params.token.address);
+      const destinationOwner = new import_web32.PublicKey(params.to);
+      const getAta = (walletPk, mintPk) => {
+        const [ata] = import_web32.PublicKey.findProgramAddressSync(
+          [walletPk.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mintPk.toBuffer()],
+          ASSOCIATED_TOKEN_PROGRAM_ID
+        );
+        return ata;
+      };
+      const sourceAta = getAta(owner, mint);
+      const destinationAta = getAta(destinationOwner, mint);
+      const tx = new import_web32.Transaction();
+      let destinationTokenAccountSigner = null;
+      const destinationOwnerInfo = yield sendConnection.getAccountInfo(destinationOwner);
+      const destinationInfo = yield sendConnection.getAccountInfo(destinationAta);
+      let destinationTokenAccount = destinationAta;
+      if (!destinationInfo) {
+        const rentExemptLamports = yield sendConnection.getMinimumBalanceForRentExemption(165);
+        const payerLamports = yield sendConnection.getBalance(owner, "confirmed");
+        const feeBufferLamports = 1e4;
+        const requiredLamports = rentExemptLamports + feeBufferLamports;
+        if (payerLamports < requiredLamports) {
+          const requiredSol = (requiredLamports / 1e9).toFixed(6);
+          const currentSol = (payerLamports / 1e9).toFixed(6);
+          throw new Error(
+            `This Solana deposit needs about ${requiredSol} SOL to create the destination token account, but the connected wallet only has ${currentSol} SOL available.`
+          );
+        }
+        const canCreateAta = (_b = (_a = destinationOwnerInfo == null ? void 0 : destinationOwnerInfo.owner) == null ? void 0 : _a.equals(import_web32.SystemProgram.programId)) != null ? _b : false;
+        if (canCreateAta) {
+          const createIx = new import_web32.TransactionInstruction({
+            programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+            keys: [
+              { pubkey: owner, isSigner: true, isWritable: true },
+              { pubkey: destinationAta, isSigner: false, isWritable: true },
+              { pubkey: destinationOwner, isSigner: false, isWritable: false },
+              { pubkey: mint, isSigner: false, isWritable: false },
+              { pubkey: import_web32.SystemProgram.programId, isSigner: false, isWritable: false },
+              { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }
+            ],
+            data: Buffer.alloc(0)
+          });
+          tx.add(createIx);
+        } else {
+          destinationTokenAccountSigner = import_web32.Keypair.generate();
+          destinationTokenAccount = destinationTokenAccountSigner.publicKey;
+          tx.add(
+            import_web32.SystemProgram.createAccount({
+              fromPubkey: owner,
+              newAccountPubkey: destinationTokenAccount,
+              lamports: rentExemptLamports,
+              space: 165,
+              programId: TOKEN_PROGRAM_ID
+            })
+          );
+          const initAccountData = Buffer.concat([
+            Buffer.from([18]),
+            // InitializeAccount3
+            destinationOwner.toBuffer()
+          ]);
+          tx.add(
+            new import_web32.TransactionInstruction({
+              programId: TOKEN_PROGRAM_ID,
+              keys: [
+                { pubkey: destinationTokenAccount, isSigner: false, isWritable: true },
+                { pubkey: mint, isSigner: false, isWritable: false }
+              ],
+              data: initAccountData
+            })
+          );
+        }
+      }
+      let factor = BigInt(1);
+      for (let i = 0; i < params.token.decimals; i += 1) {
+        factor *= BigInt(10);
+      }
+      const amountRaw = BigInt(Math.trunc(Number(params.amount || "0") * Number(factor)));
+      const data = new Uint8Array(10);
+      data[0] = 12;
+      let remaining = amountRaw;
+      const mask = BigInt(255);
+      for (let i = 0; i < 8; i += 1) {
+        data[1 + i] = Number(remaining & mask);
+        remaining >>= BigInt(8);
+      }
+      data[9] = params.token.decimals;
+      const transferIx = new import_web32.TransactionInstruction({
+        programId: TOKEN_PROGRAM_ID,
+        keys: [
+          { pubkey: sourceAta, isSigner: false, isWritable: true },
+          { pubkey: mint, isSigner: false, isWritable: false },
+          { pubkey: destinationTokenAccount, isSigner: false, isWritable: true },
+          { pubkey: owner, isSigner: true, isWritable: false }
+        ],
+        data: Buffer.from(data)
+      });
+      tx.add(transferIx);
+      tx.feePayer = owner;
+      const { blockhash } = yield sendConnection.getLatestBlockhash("confirmed");
+      tx.recentBlockhash = blockhash;
+      if (destinationTokenAccountSigner) {
+        tx.partialSign(destinationTokenAccountSigner);
+      }
+      let signature;
+      if (publicKey && sendTransaction) {
+        signature = yield sendTransaction(tx, sendConnection);
+      } else if (phantom) {
+        const res = yield phantom.signAndSendTransaction(tx);
+        signature = res.signature;
+      } else {
+        throw new Error("No Solana signer available");
+      }
+      return { txId: signature };
+    }),
+    [publicKey, rpcEndpoint, sendTransaction, writeContractAsync]
+  );
+}
+
+// src/deposit/use-wallet-transaction-status.ts
+var import_react5 = require("react");
+var import_react_query2 = require("@tanstack/react-query");
+var import_viem3 = require("viem");
+var import_web33 = require("@solana/web3.js");
+var import_wagmi3 = require("wagmi");
+function useWalletTransactionStatus({
+  chainId,
+  txId
+}) {
+  var _a;
+  const { solanaRpcUrl } = useAggUiConfig();
+  const rpcEndpoint = solanaRpcUrl != null ? solanaRpcUrl : DEFAULT_SOLANA_RPC_ENDPOINT;
+  const isSvm = chainId !== void 0 && SVM_CHAIN_IDS.has(chainId);
+  const evmHash = !isSvm && txId ? txId : void 0;
+  const evmReceipt = (0, import_wagmi3.useWaitForTransactionReceipt)({
+    chainId,
+    hash: evmHash,
+    query: {
+      enabled: !!evmHash && !!chainId,
+      refetchInterval: 2e3
+    }
+  });
+  const connection = (0, import_react5.useMemo)(() => new import_web33.Connection(rpcEndpoint, "confirmed"), [rpcEndpoint]);
+  const svmQuery = (0, import_react_query2.useQuery)({
+    queryKey: ["wallet-transaction-status", chainId != null ? chainId : null, txId != null ? txId : null],
+    enabled: isSvm && !!txId,
+    refetchInterval: (query) => query.state.data === "settled" || query.state.data === "error" ? false : 2e3,
+    queryFn: () => __async(null, null, function* () {
+      if (!txId) return "submitted";
+      const [status] = (yield connection.getSignatureStatuses([txId], { searchTransactionHistory: true })).value;
+      if (!status) return "submitted";
+      if (status.err) return "error";
+      if (status.confirmationStatus === "confirmed" || status.confirmationStatus === "finalized") {
+        return "settled";
+      }
+      return "confirming";
+    })
+  });
+  if (isSvm) {
+    return { status: txId ? (_a = svmQuery.data) != null ? _a : "submitted" : null, gasFee: "" };
+  }
+  if (!txId) {
+    return { status: null, gasFee: "" };
+  }
+  if (evmReceipt.isError) {
+    return { status: "error", gasFee: "" };
+  }
+  if (!evmReceipt.data) {
+    return { status: evmReceipt.isPending ? "confirming" : "submitted", gasFee: "" };
+  }
+  const effectiveGasPrice = evmReceipt.data.effectiveGasPrice;
+  const gasFeeWei = effectiveGasPrice * evmReceipt.data.gasUsed;
+  const gasFeeEth = Number((0, import_viem3.formatEther)(gasFeeWei));
+  const gasFee = gasFeeEth > 0 ? `${gasFeeEth.toFixed(6)} ETH` : "";
+  return { status: "settled", gasFee };
+}
+
+// src/deposit/use-deposit-flow.ts
+var import_react7 = require("react");
+var import_wagmi4 = require("wagmi");
+var import_wallet_adapter_react3 = require("@solana/wallet-adapter-react");
+
+// src/execution/use-deposit-addresses.ts
+var import_react6 = require("react");
+var import_react_query3 = require("@tanstack/react-query");
+var SVM_CHAIN_IDS2 = /* @__PURE__ */ new Set([792703809]);
+function getDepositAddress(chainId, data) {
+  return chainId !== void 0 && SVM_CHAIN_IDS2.has(chainId) ? data.svmAddress : data.evmAddress;
+}
+function useDepositAddresses(options) {
+  var _a;
+  const client = useAggClient();
+  const {
+    enabled = true,
+    poll = true,
+    refetchIntervalMs = 5e3,
+    timeoutMs = 6e4
+  } = options != null ? options : {};
+  const [isTimedOut, setIsTimedOut] = (0, import_react6.useState)(false);
+  const timeoutRef = (0, import_react6.useRef)(null);
+  (0, import_react6.useEffect)(() => {
+    if (!enabled || !poll) return void 0;
+    setIsTimedOut(false);
+    timeoutRef.current = setTimeout(() => setIsTimedOut(true), timeoutMs);
+    return () => {
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    };
+  }, [enabled, poll, timeoutMs]);
+  const query = (0, import_react_query3.useQuery)({
+    queryKey: executionKeys.depositAddresses(),
+    queryFn: () => client.getDepositAddresses(),
+    enabled,
+    staleTime: 6e4,
+    gcTime: 5 * 6e4,
+    retry: 1,
+    refetchInterval: (q) => {
+      if (!poll || isTimedOut) return false;
+      const data = q.state.data;
+      if ((data == null ? void 0 : data.ready) === true) return false;
+      return refetchIntervalMs;
+    }
+  });
+  const isReady = ((_a = query.data) == null ? void 0 : _a.ready) === true;
+  const readyData = isReady ? query.data : void 0;
+  const evmAddress = (0, import_react6.useMemo)(() => readyData == null ? void 0 : readyData.evmAddress, [readyData]);
+  const svmAddress = (0, import_react6.useMemo)(() => readyData == null ? void 0 : readyData.svmAddress, [readyData]);
+  const supportedChains = (0, import_react6.useMemo)(() => readyData == null ? void 0 : readyData.supportedChains, [readyData]);
+  return __spreadProps(__spreadValues({}, query), {
+    isReady,
+    isTimedOut,
+    evmAddress,
+    svmAddress,
+    supportedChains,
+    depositAddresses: query.data,
+    /** Resolve the correct address (EVM or SVM) for a given chainId. */
+    getAddress: (chainId) => readyData ? getDepositAddress(chainId, readyData) : void 0
+  });
+}
+
+// src/execution/use-sync-balances.ts
+var import_react_query4 = require("@tanstack/react-query");
+function useSyncBalances(options) {
+  const client = useAggClient();
+  const queryClient = (0, import_react_query4.useQueryClient)();
+  return (0, import_react_query4.useMutation)({
+    mutationFn: () => client.syncManagedBalances(),
+    onSuccess: () => {
+      var _a;
+      invalidateBalanceQueries(queryClient);
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options);
+    },
+    onError: options == null ? void 0 : options.onError
+  });
+}
+
+// src/use-ramp-quotes.ts
+var import_react_query5 = require("@tanstack/react-query");
+function useRampQuotes() {
+  const client = useAggClient();
+  return (0, import_react_query5.useMutation)({
+    mutationFn: (params) => __async(null, null, function* () {
+      return client.getRampQuotes(params);
+    })
+  });
+}
+
+// src/use-ramp-session.ts
+var import_react_query6 = require("@tanstack/react-query");
+function useRampSession() {
+  const client = useAggClient();
+  return (0, import_react_query6.useMutation)({
+    mutationFn: (params) => __async(null, null, function* () {
+      return client.createRampSession(params);
+    })
+  });
+}
+
+// src/deposit/use-deposit-flow.ts
+function useDepositFlow(options) {
+  var _a, _b;
+  const { open, onOpenChange } = options;
+  const { user } = useAggAuthState();
+  const { walletActions } = useAggUiConfig();
+  const { totalBalance } = useAggBalanceState();
+  const deposit = useDepositAddresses({ enabled: !!user });
+  const { supportedChains } = deposit;
+  const { mutate: syncBalancesMutate } = useSyncBalances();
+  const defaultSendToken = useWalletSendToken();
+  const sendToken = (_a = walletActions == null ? void 0 : walletActions.sendToken) != null ? _a : defaultSendToken;
+  const { mutateAsync: getRampQuotes } = useRampQuotes();
+  const { mutateAsync: createRampSession } = useRampSession();
+  const [depositAmount, setDepositAmount] = (0, import_react7.useState)("");
+  const [cardAmount, setCardAmount] = (0, import_react7.useState)("");
+  const [cardNetwork, setCardNetwork] = (0, import_react7.useState)("solana");
+  const [walletModalChainId, setWalletModalChainId] = (0, import_react7.useState)(null);
+  const [walletModalTokenSymbol, setWalletModalTokenSymbol] = (0, import_react7.useState)(null);
+  const [walletTransaction, setWalletTransaction] = (0, import_react7.useState)(null);
+  const [walletTransactionError, setWalletTransactionError] = (0, import_react7.useState)(null);
+  const [walletTransactionErrorTone, setWalletTransactionErrorTone] = (0, import_react7.useState)(
+    "error"
+  );
+  const [pendingCardPurchaseSummary, setPendingCardPurchaseSummary] = (0, import_react7.useState)(null);
+  const rampRedirectHandled = (0, import_react7.useRef)(false);
+  (0, import_react7.useEffect)(() => {
+    var _a2, _b2;
+    if (rampRedirectHandled.current) return;
+    if (typeof window === "undefined") return;
+    const url = new URL(window.location.href);
+    const cryptoAmount = url.searchParams.get("cryptoAmount");
+    const cryptoCurrency = url.searchParams.get("cryptoCurrency");
+    if (!cryptoAmount) return;
+    rampRedirectHandled.current = true;
+    const network = (_a2 = url.searchParams.get("network")) != null ? _a2 : "";
+    const totalFee = (_b2 = url.searchParams.get("totalFeeInFiat")) != null ? _b2 : "";
+    setPendingCardPurchaseSummary({
+      amountReceived: `+${cryptoAmount} ${cryptoCurrency != null ? cryptoCurrency : "USDC"}`,
+      network: network.charAt(0).toUpperCase() + network.slice(1),
+      fees: totalFee ? `$${totalFee}` : ""
+    });
+    onOpenChange(true);
+  }, []);
+  const { chainId: connectedChainId, address: connectedAddress } = (0, import_wagmi4.useAccount)();
+  const { switchChainAsync } = (0, import_wagmi4.useSwitchChain)();
+  const { publicKey: solanaPublicKey } = (0, import_wallet_adapter_react3.useWallet)();
+  const balanceChainId = walletModalChainId ? Number(walletModalChainId) : connectedChainId;
+  const selectedChainTokens = (0, import_react7.useMemo)(() => {
+    var _a2;
+    if (!supportedChains || !balanceChainId) return [];
+    const chain = supportedChains.find((c) => c.chainId === balanceChainId);
+    return (_a2 = chain == null ? void 0 : chain.tokens) != null ? _a2 : [];
+  }, [supportedChains, balanceChainId]);
+  const selectedTokenMeta = (0, import_react7.useMemo)(() => {
+    if (!walletModalTokenSymbol) return void 0;
+    const match = selectedChainTokens.find((t) => t.symbol === walletModalTokenSymbol);
+    return match ? { address: match.address, decimals: match.decimals } : void 0;
+  }, [selectedChainTokens, walletModalTokenSymbol]);
+  const authSvmAddress = (0, import_react7.useMemo)(() => {
+    var _a2;
+    const wallets = user == null ? void 0 : user.wallets;
+    return (_a2 = wallets == null ? void 0 : wallets.find((w) => w.chain === "solana" || w.chain === "svm")) == null ? void 0 : _a2.address;
+  }, [user]);
+  const isSvmBalanceChain = balanceChainId !== void 0 && SVM_CHAIN_IDS.has(balanceChainId);
+  const walletAddress = (0, import_react7.useMemo)(() => {
+    var _a2, _b2, _c;
+    if (isSvmBalanceChain) {
+      return (_b2 = (_a2 = solanaPublicKey == null ? void 0 : solanaPublicKey.toBase58()) != null ? _a2 : authSvmAddress) != null ? _b2 : "";
+    }
+    return (_c = connectedAddress != null ? connectedAddress : getWalletAddressFromUserProfile(user)) != null ? _c : "";
+  }, [authSvmAddress, connectedAddress, isSvmBalanceChain, solanaPublicKey, user]);
+  const walletLabel = (0, import_react7.useMemo)(() => {
+    return walletAddress ? `${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}` : "\u2014";
+  }, [walletAddress]);
+  const { balance: walletBalance, isLoading: isWalletBalanceLoading } = useWalletTokenBalance({
+    isOpen: open,
+    chainId: balanceChainId,
+    tokenAddress: selectedTokenMeta == null ? void 0 : selectedTokenMeta.address,
+    decimals: selectedTokenMeta == null ? void 0 : selectedTokenMeta.decimals,
+    svmAddress: authSvmAddress
+  });
+  const { status: observedWalletTransactionStatus, gasFee: walletTransactionGasFee } = useWalletTransactionStatus({
+    chainId: walletTransaction == null ? void 0 : walletTransaction.chainId,
+    txId: (_b = walletTransaction == null ? void 0 : walletTransaction.txId) != null ? _b : null
+  });
+  const walletTransactionStatus = walletTransactionError ? "error" : walletTransaction ? observedWalletTransactionStatus != null ? observedWalletTransactionStatus : "submitted" : void 0;
+  const syncedDepositTxIdRef = (0, import_react7.useRef)(null);
+  (0, import_react7.useEffect)(() => {
+    if (walletTransactionStatus !== "settled" || !(walletTransaction == null ? void 0 : walletTransaction.txId)) return;
+    if (syncedDepositTxIdRef.current === walletTransaction.txId) return;
+    syncedDepositTxIdRef.current = walletTransaction.txId;
+    syncBalancesMutate();
+  }, [syncBalancesMutate, walletTransaction == null ? void 0 : walletTransaction.txId, walletTransactionStatus]);
+  const handleDepositModalOpenChange = (0, import_react7.useCallback)(
+    (isOpen) => {
+      if (!isOpen) {
+        setDepositAmount("");
+        setCardAmount("");
+        setCardNetwork("solana");
+        setWalletModalChainId(null);
+        setWalletModalTokenSymbol(null);
+        setWalletTransaction(null);
+        setWalletTransactionError(null);
+        setWalletTransactionErrorTone("error");
+        setPendingCardPurchaseSummary(null);
+        syncedDepositTxIdRef.current = null;
+      }
+      onOpenChange(isOpen);
+    },
+    [onOpenChange]
+  );
+  const handleConfirmWalletDeposit = (0, import_react7.useCallback)(
+    (params) => __async(null, null, function* () {
+      var _a2, _b2, _c;
+      const { address, amount, chainId, token } = params;
+      const chain = (_a2 = supportedChains == null ? void 0 : supportedChains.find((c) => c.chainId === chainId)) != null ? _a2 : null;
+      const tokenMeta = (_b2 = chain == null ? void 0 : chain.tokens.find((t) => t.symbol === token)) != null ? _b2 : null;
+      try {
+        setWalletTransactionError(null);
+        setWalletTransactionErrorTone("error");
+        const isEvmTarget = !SVM_CHAIN_IDS.has(chainId);
+        if (isEvmTarget && connectedChainId && connectedChainId !== chainId) {
+          yield switchChainAsync({ chainId });
+        }
+        const { txId } = yield sendToken({
+          chainId,
+          token: {
+            symbol: token,
+            address: tokenMeta == null ? void 0 : tokenMeta.address,
+            decimals: (_c = tokenMeta == null ? void 0 : tokenMeta.decimals) != null ? _c : 6
+          },
+          to: address,
+          amount
+        });
+        setWalletTransaction({ chainId, txId });
+      } catch (err) {
+        setWalletTransaction(null);
+        const normalizedError = normalizeWalletError(err, supportedChains);
+        setWalletTransactionError(normalizedError.message);
+        setWalletTransactionErrorTone(normalizedError.tone);
+        throw err;
+      }
+    }),
+    [connectedChainId, sendToken, supportedChains, switchChainAsync]
+  );
+  const handleGetCardQuotes = (0, import_react7.useCallback)(
+    (params) => __async(null, null, function* () {
+      const quotes = yield getRampQuotes(params);
+      return quotes.map(
+        (q, i) => ({
+          id: q.serviceProvider,
+          name: q.serviceProvider,
+          quote: `~ ${q.destinationAmount.toFixed(2)} USDC`,
+          fee: `$${q.totalFee.toFixed(2)}`,
+          badge: i === 0 ? "best" : q.lowKyc ? "low-kyc" : void 0
+        })
+      );
+    }),
+    [getRampQuotes]
+  );
+  const handleCreateCardSession = (0, import_react7.useCallback)(
+    (params) => __async(null, null, function* () {
+      if (!params.walletAddress) {
+        throw new Error("Deposit address not available for the selected network");
+      }
+      const session = yield createRampSession(params);
+      return {
+        id: session.id,
+        widgetUrl: session.widgetUrl,
+        serviceProviderWidgetUrl: session.serviceProviderWidgetUrl
+      };
+    }),
+    [createRampSession]
+  );
+  const cardRedirectUrl = typeof window !== "undefined" ? `${window.location.origin}/profile?tab=activity` : void 0;
+  return {
+    open,
+    onOpenChange: handleDepositModalOpenChange,
+    pendingCardPurchaseSummary,
+    walletFlow: {
+      balance: totalBalance != null ? totalBalance : 0,
+      walletLabel,
+      walletBalance,
+      isWalletBalanceLoading,
+      amount: depositAmount,
+      formErrorMessage: walletTransaction ? void 0 : walletTransactionError != null ? walletTransactionError : void 0,
+      formErrorTone: walletTransactionErrorTone,
+      transactionStatus: walletTransactionStatus,
+      transactionErrorMessage: walletTransactionError != null ? walletTransactionError : void 0,
+      successSummary: {
+        fromWallet: walletLabel,
+        gasFee: walletTransactionGasFee
+      }
+    },
+    onWalletAmountChange: setDepositAmount,
+    onWalletMax: (0, import_react7.useCallback)(() => setDepositAmount(String(walletBalance)), [walletBalance]),
+    onConfirmWalletDeposit: handleConfirmWalletDeposit,
+    onWalletNetworkChange: setWalletModalChainId,
+    onWalletTokenChange: setWalletModalTokenSymbol,
+    initialWalletChainId: connectedChainId ? String(connectedChainId) : void 0,
+    connectedWalletKind: connectedChainId && !solanaPublicKey ? "evm" : solanaPublicKey && !connectedChainId ? "solana" : void 0,
+    sendCryptoConfig: { minDeposit: "$1", feeEstimate: "~$0.01", eta: "~30s" },
+    onDoneSendCrypto: (0, import_react7.useCallback)(
+      () => handleDepositModalOpenChange(false),
+      [handleDepositModalOpenChange]
+    ),
+    cardFlow: {
+      amount: cardAmount,
+      currency: "USD",
+      tokenOptions: [{ value: "USDC", label: "USDC" }],
+      selectedToken: "USDC",
+      selectedNetwork: cardNetwork,
+      providers: [],
+      purchaseSummary: { amountReceived: "", network: "", fees: "" },
+      minAmount: 11
+    },
+    onCardAmountChange: setCardAmount,
+    onCardNetworkChange: setCardNetwork,
+    onDoneCardPurchase: (0, import_react7.useCallback)(() => {
+      syncBalancesMutate();
+      if (typeof window !== "undefined") {
+        window.history.replaceState({}, "", window.location.pathname);
+      }
+    }, [syncBalancesMutate]),
+    cardRedirectUrl,
+    onGetCardQuotes: handleGetCardQuotes,
+    onCreateCardSession: handleCreateCardSession
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SOLANA_RPC_ENDPOINT,
+  SVM_CHAIN_IDS,
+  normalizeWalletError,
+  useDepositAddresses,
+  useDepositFlow,
+  useSyncBalances,
+  useWalletSendToken,
+  useWalletTokenBalance,
+  useWalletTransactionStatus
+});