@rhinestone/deposit-modal 0.9.1 → 0.10.0

package/dist/{chunk-N3OHR3T2.mjs → chunk-MHIOMTMM.mjs}

@@ -18,10 +18,10 @@ import {
   runAccountSetupDeduped,
   txRefsMatch,
   warnRemovedProps
-} from "./chunk-GYEUZSQP.mjs";
+} from "./chunk-VDGT6NZQ.mjs";
 import {
   ListRow
-} from "./chunk-AYWEWI47.mjs";
+} from "./chunk-KW32UBUQ.mjs";
 import {
   AlertTriangleIcon,
   AppleIcon,
@@ -77,7 +77,7 @@ import {
   useLatestRef,
   useRpcUrls,
   useStableRpcUrls
-} from "./chunk-WUQZYQRK.mjs";
+} from "./chunk-7TV7GLJB.mjs";
 import {
   POLYMARKET_COLLATERAL_OFFRAMP_ADDRESS,
   POLYMARKET_ICON_URL,
@@ -90,6 +90,7 @@ import {
   readPolymarketBalances
 } from "./chunk-ILT2PITN.mjs";
 import {
+  CHAIN_BY_ID,
   HYPERCORE_CHAIN_ID,
   HYPERCORE_MIN_DEPOSIT_USD,
   NATIVE_TOKEN_ADDRESS,
@@ -262,18 +263,17 @@ var DAPP_IMPORT_CATALOG = [
     label: "Polymarket",
     iconUrl: cdnIconUrl("dapps", "polymarket")
   },
+  {
+    id: "aave",
+    label: "Aave",
+    iconUrl: cdnIconUrl("dapps", "aave")
+  },
   {
     id: "hyperliquid",
     label: "Hyperliquid",
     iconUrl: cdnIconUrl("dapps", "hyperliquid"),
     comingSoon: true
   },
-  {
-    id: "aave",
-    label: "Aave",
-    iconUrl: cdnIconUrl("dapps", "aave"),
-    comingSoon: true
-  },
   {
     id: "morpho",
     label: "Morpho",
@@ -1036,6 +1036,7 @@ function AmountStep({
   publicClient,
   address,
   balanceAddress,
+  declaredBalance,
   asset,
   defaultAmount,
   switchChain,
@@ -1078,6 +1079,10 @@ function AmountStep({
   const hasPricing = tokenPriceUsd !== null;
   useEffect3(() => {
     let active = true;
+    if (declaredBalance !== void 0) {
+      setBalance(declaredBalance);
+      return;
+    }
     async function fetchBalance() {
       const balanceTarget = balanceAddress ?? address;
       if (!balanceTarget || !publicClient) return;
@@ -1097,7 +1102,7 @@ function AmountStep({
     return () => {
       active = false;
     };
-  }, [address, balanceAddress, publicClient, asset]);
+  }, [address, balanceAddress, declaredBalance, publicClient, asset]);
   useEffect3(() => {
     if (chainMismatch && switchChain && !hasAttemptedSwitch.current) {
       hasAttemptedSwitch.current = true;
@@ -4385,6 +4390,7 @@ import { jsx as jsx22, jsxs as jsxs19 } from "react/jsx-runtime";
 function DappImportAssetSelectStep({
   sourceLabel,
   assets,
+  incompleteSummary,
   onSelect
 }) {
   return /* @__PURE__ */ jsxs19("div", { className: "rs-screen", children: [
@@ -4397,6 +4403,7 @@ function DappImportAssetSelectStep({
           subtitle: "Pick the balance to import"
         }
       ),
+      incompleteSummary && /* @__PURE__ */ jsx22("div", { className: "rs-asset-notice", role: "status", children: incompleteSummary }),
       /* @__PURE__ */ jsx22("div", { className: "rs-asset-list", children: assets.map((asset) => {
         const tokenAmount = asset.balance ? tokenFormatter.format(
           Number(asset.balance) / 10 ** asset.decimals
@@ -4435,7 +4442,8 @@ function DappImportAssetSelectStep({
                     /* @__PURE__ */ jsx22("span", { className: "rs-asset-name", children: asset.symbol }),
                     /* @__PURE__ */ jsxs19("span", { className: "rs-asset-chain", children: [
                       "on ",
-                      asset.sourceLabel
+                      asset.sourceLabel,
+                      asset.qualifier ? ` \xB7 ${asset.qualifier}` : ""
                     ] })
                   ] }),
                   /* @__PURE__ */ jsxs19("div", { className: "rs-asset-balance-small", children: [
@@ -4649,6 +4657,188 @@ function composeFiatMethods(regional, fallbackMethods) {
   };
 }
 
+// src/core/dapp-imports/balance-source.ts
+function dappImportBalanceSource(asset) {
+  if (!isDappImportAsset(asset)) return {};
+  if (asset.balanceAddress) return { balanceAddress: asset.balanceAddress };
+  if (asset.balance === void 0) return {};
+  try {
+    return { declaredBalance: BigInt(asset.balance) };
+  } catch {
+    return {};
+  }
+}
+
+// src/core/dapp-imports/aave/index.ts
+var PROVIDER_ID = "aave";
+var SOURCE_LABEL = "Aave";
+var POLICY_REFUSED = [
+  "below_deposit_floor",
+  "deposit_not_whitelisted"
+];
+var aaveProvider = {
+  id: PROVIDER_ID,
+  sourceLabel: SOURCE_LABEL,
+  async fetchAvailability({ eoa, backend, signal }) {
+    if (!backend) {
+      throw new Error("Aave positions require a backend connection");
+    }
+    const response = await backend.getPositions(eoa);
+    if (signal?.aborted) return null;
+    const assets = toImportableAssets(response.positions);
+    const failures = response.failures ?? [];
+    if (assets.length === 0) {
+      if (failures.length > 0) {
+        throw new Error(
+          `Could not read Aave positions: ${failures.map((failure) => failure.reason).join("; ")}`
+        );
+      }
+      return null;
+    }
+    const availability = {
+      providerId: PROVIDER_ID,
+      // Deliberately the sum over importable assets rather than
+      // `response.totalUsd`: the latter counts positions this flow filters out,
+      // so using it would show a balance the user then cannot find.
+      totalUsd: assets.reduce((sum, asset) => sum + (asset.balanceUsd ?? 0), 0),
+      assets,
+      // Some markets read, some did not. Erroring would discard positions the
+      // user can migrate right now — and with ~29 markets on a keyless API, one
+      // failing is the expected case, so erroring would be the normal outcome.
+      // The list therefore stands, marked as a floor. The upstream reason names
+      // an internal market, so it is summarised rather than surfaced.
+      ...failures.length > 0 ? {
+        incomplete: {
+          summary: failures.length === 1 ? "One Aave market couldn't be loaded, so a position may be missing." : `${failures.length} Aave markets couldn't be loaded, so positions may be missing.`
+        }
+      } : {}
+    };
+    return availability;
+  },
+  async executeTransfer({ walletClient, recipient, asset, amount, backend }) {
+    if (!backend) {
+      throw new Error("Aave withdrawals require a backend connection");
+    }
+    const metadata = asset.providerMetadata;
+    const account = walletClient.account;
+    const chain = walletClient.chain;
+    if (!account || !chain) {
+      throw new Error("Wallet not connected");
+    }
+    if (chain.id !== metadata.chainId) {
+      throw new Error(
+        `Switch to ${metadata.marketName} chain (${metadata.chainId}) to sign`
+      );
+    }
+    const prepared = await backend.prepareUnwind({
+      address: account.address,
+      // The backend resolves the recipient from this account rather than
+      // trusting a supplied address. `amount` is always explicit — expressing
+      // "everything" is the backend's call, since only it knows whether sweeping
+      // accrued interest could push the delivered amount past a whitelist
+      // ceiling and get the proceeds rejected after the withdraw succeeded.
+      account: recipient,
+      market: metadata.market,
+      chainId: metadata.chainId,
+      asset: metadata.asset,
+      amount: amount.toString()
+    });
+    if (prepared.recipient.toLowerCase() !== recipient.toLowerCase()) {
+      throw new Error(
+        "Aave withdrawal would send funds to an unexpected address"
+      );
+    }
+    if (prepared.transaction.chainId !== metadata.chainId) {
+      throw new Error("Aave withdrawal was prepared for a different chain");
+    }
+    const txHash = await walletClient.sendTransaction({
+      account,
+      chain,
+      to: prepared.transaction.to,
+      data: prepared.transaction.data,
+      value: BigInt(prepared.transaction.value)
+    });
+    return {
+      txHash,
+      // Aave pays out the underlying straight to the deposit address — no
+      // unwrap, no swap, so what arrives is what was supplied.
+      sourceToken: metadata.asset,
+      sourceSymbol: asset.symbol,
+      sourceDecimals: asset.decimals
+    };
+  }
+};
+function toImportableAssets(positions) {
+  const assets = [];
+  for (const position of positions) {
+    const chainId = parseEvmChainId(position.chain);
+    if (chainId === null) continue;
+    if (!CHAIN_BY_ID[chainId]) continue;
+    if (BigInt(position.maxWithdrawable) <= 0n) continue;
+    if (position.constraints.some((c) => POLICY_REFUSED.includes(c))) continue;
+    assets.push(buildAsset(position, chainId));
+  }
+  return qualifyAmbiguousMarkets(assets);
+}
+function buildAsset(position, chainId) {
+  const { asset, market } = position;
+  const token = asset.address.toLowerCase();
+  const metadata = {
+    market: market.address,
+    marketName: market.name,
+    chainId,
+    asset: asset.address
+  };
+  return {
+    // Market-keyed, so one chain holding the same token in two markets yields
+    // two distinct rows rather than one that silently shadows the other.
+    id: `aave:${chainId}:${market.address.toLowerCase()}:${token}`,
+    chainId,
+    token,
+    symbol: asset.symbol,
+    // The market name, not a token description: it is what tells four Aave v3
+    // markets on Ethereum apart.
+    name: market.name,
+    decimals: asset.decimals,
+    // `maxWithdrawable`, NOT the supplied balance. The amount selector lets the
+    // user pick up to this, and seeding it with the supplied balance would let
+    // them choose above the cap and sign a withdraw the pool rejects.
+    balance: position.maxWithdrawable,
+    balanceUsd: withdrawableUsd(position),
+    source: PROVIDER_ID,
+    sourceLabel: SOURCE_LABEL,
+    reviewLabel: `You withdraw ${asset.symbol} from Aave`,
+    // Aave sends the underlying itself to the deposit address, so the token the
+    // orchestrator sees land is the same one and on the same chain.
+    depositToken: token,
+    depositChainId: chainId,
+    providerMetadata: metadata
+  };
+}
+function qualifyAmbiguousMarkets(assets) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    const key = `${asset.chainId}:${asset.token}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return assets.map(
+    (asset) => (counts.get(`${asset.chainId}:${asset.token}`) ?? 0) > 1 ? {
+      ...asset,
+      qualifier: asset.providerMetadata.marketName
+    } : asset
+  );
+}
+function withdrawableUsd(position) {
+  const amount = BigInt(position.amount);
+  const withdrawable = BigInt(position.maxWithdrawable);
+  if (amount === 0n) return 0;
+  if (withdrawable === amount) return position.usdValue;
+  const SCALE = 1000000n;
+  const ratio = Number(withdrawable * SCALE / amount) / Number(SCALE);
+  const usd = position.usdValue * ratio;
+  return Number.isFinite(usd) ? usd : 0;
+}
+
 // src/core/dapp-imports/polymarket/index.ts
 import { formatUnits as formatUnits6 } from "viem";
 
@@ -4819,11 +5009,10 @@ function buildPusdUnwrapCalls(recipient, amount) {
 }
 
 // src/core/dapp-imports/polymarket/index.ts
-var PROVIDER_ID = "polymarket";
+var PROVIDER_ID2 = "polymarket";
 var polymarketProvider = {
-  id: PROVIDER_ID,
+  id: PROVIDER_ID2,
   sourceLabel: "Polymarket",
-  chainId: POLYMARKET_POLYGON_CHAIN_ID,
   async fetchAvailability({ eoa, getPublicClient: getPublicClient2, signal }) {
     const proxyWallet = await fetchPolymarketProxyWallet(eoa, signal);
     if (!proxyWallet) return null;
@@ -4846,17 +5035,17 @@ var polymarketProvider = {
     const assets = [];
     if (balances.pusd > 0n) {
       assets.push(
-        buildAsset({ tokenKind: "pusd", proxyWallet, walletKind, balance: balances.pusd })
+        buildAsset2({ tokenKind: "pusd", proxyWallet, walletKind, balance: balances.pusd })
       );
     }
     if (balances.usdce > 0n) {
       assets.push(
-        buildAsset({ tokenKind: "usdce", proxyWallet, walletKind, balance: balances.usdce })
+        buildAsset2({ tokenKind: "usdce", proxyWallet, walletKind, balance: balances.usdce })
       );
     }
     const totalUsd = assets.reduce((sum, a) => sum + (a.balanceUsd ?? 0), 0);
     const availability = {
-      providerId: PROVIDER_ID,
+      providerId: PROVIDER_ID2,
       totalUsd,
       assets
     };
@@ -4904,7 +5093,7 @@ var polymarketProvider = {
     };
   }
 };
-function buildAsset(params) {
+function buildAsset2(params) {
   const { tokenKind, proxyWallet, walletKind, balance } = params;
   const isPusd = tokenKind === "pusd";
   const tokenAddress = isPusd ? POLYMARKET_PUSD_ADDRESS : POLYMARKET_USDCE_ADDRESS;
@@ -4921,8 +5110,11 @@ function buildAsset(params) {
     decimals: 6,
     balance: balance.toString(),
     balanceUsd: Number.isFinite(balanceUsd) ? balanceUsd : 0,
-    source: PROVIDER_ID,
+    source: PROVIDER_ID2,
     sourceLabel: "Polymarket",
+    // The proxy wallet really does hold this ERC-20, so the amount step reads it
+    // live rather than trusting the figure from the availability fetch.
+    balanceAddress: proxyWallet,
     reviewLabel: isPusd ? "You send pUSD from Polymarket" : "You send USDC.e from Polymarket",
     // pUSD unwraps to USDC.e via the offramp; USDC.e is what actually
     // arrives at the smart account, so it's also what the orchestrator
@@ -4934,7 +5126,10 @@ function buildAsset(params) {
 }
 
 // src/core/dapp-imports/registry.ts
-var DAPP_IMPORT_PROVIDERS = [polymarketProvider];
+var DAPP_IMPORT_PROVIDERS = [
+  polymarketProvider,
+  aaveProvider
+];
 function getEnabledProviders(config) {
   if (!config) return [];
   return DAPP_IMPORT_PROVIDERS.filter(
@@ -6768,6 +6963,9 @@ function DepositFlow({
             return null;
           }
         },
+        // Providers whose positions live behind the Rhinestone API rather than
+        // an RPC (Aave) read them through here.
+        backend: service,
         signal: controller.signal
       }).then((availability) => {
         if (controller.signal.aborted) return;
@@ -6792,7 +6990,8 @@ function DepositFlow({
     enabledDappImportProviders,
     dappImportAttemptNonce,
     storeApi,
-    rpcUrls
+    rpcUrls,
+    service
   ]);
   useLayoutEffect2(() => {
     if (!initialAssetMigrationProvider) return;
@@ -8096,6 +8295,7 @@ function DepositFlow({
       {
         sourceLabel: activeDappImportAvailability.assets[0]?.sourceLabel ?? activeDappImportProvider.sourceLabel,
         assets: activeDappImportAvailability.assets,
+        incompleteSummary: activeDappImportAvailability.incomplete?.summary,
         onSelect: handleDappImportAssetSelected
       }
     ),
@@ -8105,7 +8305,7 @@ function DepositFlow({
         walletClient: signerContext.walletClient,
         publicClient: getReadClientForChain(effectiveStep.asset.chainId),
         address: ownerAddress,
-        balanceAddress: isDappImportAsset(effectiveStep.asset) ? effectiveStep.asset.providerMetadata.proxyWallet : void 0,
+        ...dappImportBalanceSource(effectiveStep.asset),
         asset: effectiveStep.asset,
         defaultAmount: effectiveStep.inputAmountUsd ?? defaultAmount,
         switchChain: signerContext.switchChain,
@@ -8152,8 +8352,11 @@ function DepositFlow({
           const result = await activeDappImportProvider.executeTransfer(
             {
               walletClient: signerContext.walletClient,
+              // The asset's chain: a provider's assets can span chains
+              // (Aave positions exist on every deposit-enabled chain), so
+              // there is no single provider-level chain to read from.
               publicClient: getReadClientForChain(
-                activeDappImportProvider.chainId
+                effectiveStep.asset.chainId
               ),
               recipient: effectiveStep.smartAccount,
               asset: effectiveStep.asset,
@@ -8492,7 +8695,7 @@ DepositHistoryPanel.displayName = "DepositHistoryPanel";
 // src/DepositModal.tsx
 import { jsx as jsx27, jsxs as jsxs24 } from "react/jsx-runtime";
 var ReownDepositInner = lazy2(
-  () => import("./DepositModalReown-JUJI7UHE.mjs").then((m) => ({ default: m.DepositModalReown }))
+  () => import("./DepositModalReown-MTWT6Y66.mjs").then((m) => ({ default: m.DepositModalReown }))
 );
 function sortByCreatedAtDesc(items) {
   return [...items].sort((a, b) => {

package/dist/{chunk-XJE5MRY4.cjs → chunk-NF4NBRUP.cjs}

@@ -1,5 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/core/version.ts
-var MODAL_VERSION = "0.9.1";
+var MODAL_VERSION = "0.10.0";
 var SERVICE_HEADERS = {
   "Content-Type": "application/json",
   "x-deposit-modal-version": MODAL_VERSION