@compass-labs/widgets 0.1.26 → 0.1.28

package/dist/server/index.js

@@ -73,6 +73,8 @@ function createCompassHandler(config) {
             return await handleSwapPrepare(client, body);
           case "swap/execute":
             return await handleSwapExecute(client, body, config);
+          case "rebalance/preview":
+            return await handleRebalancePreview(client, body, config);
           default:
             return jsonResponse({ error: `Unknown POST route: ${route}` }, 404);
         }
@@ -839,6 +841,308 @@ async function handlePositions(client, params) {
     return jsonResponse({ error: "Failed to fetch positions" }, 500);
   }
 }
+async function handleRebalancePreview(client, body, config) {
+  const { owner, chain = "base", targets, slippage = 0.5 } = body;
+  if (!owner) {
+    return jsonResponse({ error: "Missing owner parameter" }, 400);
+  }
+  if (!targets || targets.length === 0) {
+    return jsonResponse({ error: "Missing targets" }, 400);
+  }
+  for (const t of targets) {
+    if (t.targetPercent < 0 || t.targetPercent > 100) {
+      return jsonResponse({ error: `Invalid target percentage: ${t.targetPercent}%` }, 400);
+    }
+  }
+  try {
+    const positionsResponse = await client.earn.earnPositions({
+      chain,
+      owner
+    });
+    const positionsRaw = JSON.parse(JSON.stringify(positionsResponse));
+    const balancesResponse = await client.earn.earnBalances({
+      chain,
+      owner
+    });
+    const balancesRaw = JSON.parse(JSON.stringify(balancesResponse));
+    const currentPositions = [];
+    for (const a of positionsRaw.aave || []) {
+      const balance = a.balance || "0";
+      if (parseFloat(balance) <= 0) continue;
+      const symbol = (a.reserveSymbol || a.reserve_symbol || "UNKNOWN").toUpperCase();
+      currentPositions.push({
+        venueType: "AAVE",
+        venueAddress: symbol,
+        token: symbol,
+        usdValue: parseFloat(a.usdValue || a.usd_value || balance),
+        balance
+      });
+    }
+    for (const v of positionsRaw.vaults || []) {
+      const balance = v.balance || "0";
+      if (parseFloat(balance) <= 0) continue;
+      const symbol = (v.underlyingSymbol || v.underlying_symbol || "TOKEN").toUpperCase();
+      currentPositions.push({
+        venueType: "VAULT",
+        venueAddress: v.vaultAddress || v.vault_address || "",
+        token: symbol,
+        usdValue: parseFloat(v.usdValue || v.usd_value || balance),
+        balance
+      });
+    }
+    for (const p of positionsRaw.pendlePt || positionsRaw.pendle_pt || []) {
+      const balance = p.ptBalance || p.pt_balance || p.balance || "0";
+      if (parseFloat(balance) <= 0) continue;
+      const symbol = (p.underlyingSymbol || p.underlying_symbol || "PT").toUpperCase();
+      currentPositions.push({
+        venueType: "PENDLE_PT",
+        venueAddress: p.marketAddress || p.market_address || "",
+        token: symbol,
+        usdValue: parseFloat(p.usdValue || p.usd_value || balance),
+        balance
+      });
+    }
+    let totalIdleUsd = 0;
+    for (const [, tokenData] of Object.entries(balancesRaw.balances || {})) {
+      const td = tokenData;
+      const usdVal = parseFloat(td.usd_value || td.usdValue || "0");
+      totalIdleUsd += usdVal;
+    }
+    const totalPositionUsd = currentPositions.reduce((sum, p) => sum + p.usdValue, 0);
+    const totalUsd = totalPositionUsd + totalIdleUsd;
+    if (totalUsd <= 0) {
+      return jsonResponse({ error: "No portfolio value found to rebalance" }, 400);
+    }
+    const bundleActions = [];
+    const actionsSummary = [];
+    const warnings = [];
+    const MIN_THRESHOLD_USD = 0.01;
+    const pendingDeposits = [];
+    for (const target of targets) {
+      const targetUsd = totalUsd * (target.targetPercent / 100);
+      const current = currentPositions.find(
+        (p) => p.venueType === target.venueType && p.venueAddress.toLowerCase() === target.venueAddress.toLowerCase()
+      );
+      const currentUsd = current?.usdValue || 0;
+      const deltaUsd = targetUsd - currentUsd;
+      if (Math.abs(deltaUsd) < MIN_THRESHOLD_USD) continue;
+      if (deltaUsd < 0 && current) {
+        const withdrawFraction = Math.abs(deltaUsd) / currentUsd;
+        const withdrawAmount = (parseFloat(current.balance) * withdrawFraction).toString();
+        let venue;
+        if (target.venueType === "VAULT") {
+          venue = { type: "VAULT", vaultAddress: target.venueAddress };
+        } else if (target.venueType === "AAVE") {
+          venue = { type: "AAVE", token: current.token };
+        } else if (target.venueType === "PENDLE_PT") {
+          venue = { type: "PENDLE_PT", marketAddress: target.venueAddress, maxSlippagePercent: slippage };
+          warnings.push(`Withdrawing from Pendle PT - check maturity implications`);
+        }
+        bundleActions.push({
+          body: {
+            actionType: "V2_MANAGE",
+            venue,
+            action: "WITHDRAW",
+            amount: withdrawAmount
+          }
+        });
+        actionsSummary.push({
+          type: "withdraw",
+          venue: target.venueAddress,
+          token: current.token,
+          amount: withdrawAmount,
+          usdValue: Math.abs(deltaUsd)
+        });
+      } else if (deltaUsd > 0) {
+        let venue;
+        const token = target.token || current?.token || "";
+        if (target.venueType === "VAULT") {
+          venue = { type: "VAULT", vaultAddress: target.venueAddress };
+        } else if (target.venueType === "AAVE") {
+          venue = { type: "AAVE", token };
+        } else if (target.venueType === "PENDLE_PT") {
+          venue = { type: "PENDLE_PT", marketAddress: target.venueAddress, token, maxSlippagePercent: slippage };
+        }
+        pendingDeposits.push({ venue, venueAddress: target.venueAddress, token, deltaUsd });
+      }
+    }
+    for (const current of currentPositions) {
+      const hasTarget = targets.some(
+        (t) => t.venueType === current.venueType && t.venueAddress.toLowerCase() === current.venueAddress.toLowerCase()
+      );
+      if (!hasTarget && current.usdValue >= MIN_THRESHOLD_USD) {
+        let venue;
+        if (current.venueType === "VAULT") {
+          venue = { type: "VAULT", vaultAddress: current.venueAddress };
+        } else if (current.venueType === "AAVE") {
+          venue = { type: "AAVE", token: current.token };
+        } else if (current.venueType === "PENDLE_PT") {
+          venue = { type: "PENDLE_PT", marketAddress: current.venueAddress, maxSlippagePercent: slippage };
+        }
+        bundleActions.unshift({
+          body: {
+            actionType: "V2_MANAGE",
+            venue,
+            action: "WITHDRAW",
+            amount: current.balance
+          }
+        });
+        actionsSummary.unshift({
+          type: "withdraw",
+          venue: current.venueAddress,
+          token: current.token,
+          amount: current.balance,
+          usdValue: current.usdValue
+        });
+      }
+    }
+    const availableByToken = {};
+    for (const action of actionsSummary) {
+      if (action.type === "withdraw") {
+        const key = action.token.toUpperCase();
+        if (!availableByToken[key]) availableByToken[key] = { usd: 0, tokenAmount: 0 };
+        availableByToken[key].usd += action.usdValue;
+        availableByToken[key].tokenAmount += parseFloat(action.amount);
+      }
+    }
+    for (const [tokenSymbol, tokenData] of Object.entries(balancesRaw.balances || {})) {
+      const td = tokenData;
+      const usdVal = parseFloat(td.usd_value || td.usdValue || "0");
+      const bal = parseFloat(td.balance || "0");
+      if (usdVal > MIN_THRESHOLD_USD) {
+        const key = tokenSymbol.toUpperCase();
+        if (!availableByToken[key]) availableByToken[key] = { usd: 0, tokenAmount: 0 };
+        availableByToken[key].usd += usdVal;
+        availableByToken[key].tokenAmount += bal;
+      }
+    }
+    const depositNeedsByToken = {};
+    for (const dep of pendingDeposits) {
+      const key = dep.token.toUpperCase();
+      depositNeedsByToken[key] = (depositNeedsByToken[key] || 0) + dep.deltaUsd;
+    }
+    for (const [depositToken, neededUsd] of Object.entries(depositNeedsByToken)) {
+      const availableUsd = availableByToken[depositToken]?.usd || 0;
+      let shortfallUsd = neededUsd - availableUsd;
+      if (shortfallUsd <= MIN_THRESHOLD_USD) continue;
+      for (const [sourceToken, sourceData] of Object.entries(availableByToken)) {
+        if (sourceToken === depositToken) continue;
+        const sourceNeeded = depositNeedsByToken[sourceToken] || 0;
+        const sourceExcess = sourceData.usd - sourceNeeded;
+        if (sourceExcess <= MIN_THRESHOLD_USD) continue;
+        const swapUsd = Math.min(shortfallUsd, sourceExcess);
+        if (swapUsd < MIN_THRESHOLD_USD) continue;
+        const tokenAmountIn = sourceData.usd > 0 ? swapUsd / sourceData.usd * sourceData.tokenAmount : swapUsd;
+        bundleActions.push({
+          body: {
+            actionType: "V2_SWAP",
+            tokenIn: sourceToken,
+            tokenOut: depositToken,
+            amountIn: tokenAmountIn.toString(),
+            slippage
+          }
+        });
+        actionsSummary.push({
+          type: "swap",
+          token: sourceToken,
+          tokenOut: depositToken,
+          amount: tokenAmountIn,
+          usdValue: swapUsd
+        });
+        sourceData.usd -= swapUsd;
+        sourceData.tokenAmount -= tokenAmountIn;
+        const slippageFactor = 1 - slippage / 100;
+        if (!availableByToken[depositToken]) availableByToken[depositToken] = { usd: 0, tokenAmount: 0 };
+        const receivedUsd = swapUsd * slippageFactor;
+        const existingData = availableByToken[depositToken];
+        const impliedPrice = existingData.tokenAmount > 0 && existingData.usd > 0 ? existingData.usd / existingData.tokenAmount : 1;
+        availableByToken[depositToken].usd += receivedUsd;
+        availableByToken[depositToken].tokenAmount += receivedUsd / impliedPrice;
+        shortfallUsd -= swapUsd;
+        warnings.push(`Swap ${sourceToken} to ${depositToken} involves slippage risk`);
+        if (shortfallUsd <= MIN_THRESHOLD_USD) break;
+      }
+    }
+    for (const dep of pendingDeposits) {
+      const key = dep.token.toUpperCase();
+      const available = availableByToken[key];
+      const tokenPrice = available && available.tokenAmount > 0 && available.usd > 0 ? available.usd / available.tokenAmount : 1;
+      const desiredTokens = dep.deltaUsd / tokenPrice;
+      const maxAvailableTokens = available ? available.tokenAmount * 0.99 : 0;
+      const depositTokenAmount = maxAvailableTokens > 0 && maxAvailableTokens < desiredTokens ? maxAvailableTokens : desiredTokens;
+      bundleActions.push({
+        body: {
+          actionType: "V2_MANAGE",
+          venue: dep.venue,
+          action: "DEPOSIT",
+          amount: depositTokenAmount.toString()
+        }
+      });
+      const depositUsd = depositTokenAmount * tokenPrice;
+      actionsSummary.push({
+        type: "deposit",
+        venue: dep.venueAddress,
+        token: dep.token,
+        amount: depositTokenAmount.toString(),
+        usdValue: depositUsd
+      });
+      if (available) {
+        available.usd -= depositUsd;
+        available.tokenAmount -= depositTokenAmount;
+      }
+    }
+    if (bundleActions.length === 0 && pendingDeposits.length === 0) {
+      return jsonResponse({
+        actions: [],
+        actionsCount: 0,
+        warnings: ["Portfolio is already at target allocation"]
+      });
+    }
+    bundleActions.sort((a, b) => {
+      const getOrder = (action) => {
+        if (action.body.action === "WITHDRAW") return 0;
+        if (action.body.actionType === "V2_SWAP") return 1;
+        if (action.body.action === "DEPOSIT") return 2;
+        return 3;
+      };
+      return getOrder(a) - getOrder(b);
+    });
+    actionsSummary.sort((a, b) => {
+      const order = { withdraw: 0, swap: 1, deposit: 2 };
+      return (order[a.type] || 0) - (order[b.type] || 0);
+    });
+    if (actionsSummary.some((a) => a.type === "swap")) {
+      warnings.push("Swap amounts are estimates - actual amounts may vary due to slippage");
+    }
+    const bundleResponse = await client.earn.earnBundle({
+      owner,
+      chain,
+      gasSponsorship: true,
+      actions: bundleActions
+    });
+    const eip712 = bundleResponse.eip712;
+    if (!eip712) {
+      return jsonResponse({ error: "No EIP-712 data returned from bundle API" }, 500);
+    }
+    const types = eip712.types;
+    const normalizedTypes = {
+      EIP712Domain: types.eip712Domain || types.EIP712Domain,
+      SafeTx: types.safeTx || types.SafeTx
+    };
+    return jsonResponse({
+      eip712,
+      normalizedTypes,
+      domain: eip712.domain,
+      message: eip712.message,
+      actions: actionsSummary,
+      actionsCount: bundleActions.length,
+      warnings
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to compute rebalance preview";
+    return jsonResponse({ error: message }, 502);
+  }
+}
 
 exports.createCompassHandler = createCompassHandler;
 //# sourceMappingURL=index.js.map