@compass-labs/widgets 0.1.42 → 0.1.44

package/dist/server/index.js

@@ -5,665 +5,1391 @@ var viem = require('viem');
 var accounts = require('viem/accounts');
 var chains = require('viem/chains');
 
-// src/server/handler.ts
+// src/server/core/compass-service.ts
 var CHAIN_MAP = {
   ethereum: chains.mainnet,
   base: chains.base,
   arbitrum: chains.arbitrum
 };
-function createCompassHandler(config) {
-  const { apiKey, serverUrl = "https://api.compasslabs.ai" } = config;
-  const client = new apiSdk.CompassApiSDK({
-    apiKeyAuth: apiKey,
-    serverURL: serverUrl
-  });
-  return async function handler(request, context) {
-    try {
-      const { path } = await context.params;
-      const route = path.join("/");
-      const method = request.method;
-      if (method === "GET") {
-        const url = new URL(request.url);
-        const searchParams = Object.fromEntries(url.searchParams.entries());
-        switch (route) {
-          case "earn-account/check":
-            return await handleEarnAccountCheck(client, searchParams);
-          case "earn-account/balances":
-            return await handleEarnAccountBalances(client, searchParams);
-          case "swap/quote":
-            return await handleSwapQuote(client, searchParams);
-          case "token/balance":
-            return await handleTokenBalance(client, searchParams);
-          case "token/prices":
-            return await handleTokenPrices(client, searchParams);
-          case "vaults":
-            return await handleVaults(client, searchParams);
-          case "aave/markets":
-            return await handleAaveMarkets(client, searchParams);
-          case "pendle/markets":
-            return await handlePendleMarkets(client, searchParams);
-          case "positions":
-            return await handlePositions(client, searchParams);
-          case "credit-account/check":
-            return await handleCreditAccountCheck(client, searchParams);
-          case "credit/positions":
-            return await handleCreditPositions(client, searchParams);
-          case "credit/balances":
-            return await handleCreditBalances(client, searchParams);
-          case "tx/receipt":
-            return await handleTxReceipt(searchParams, config);
-          default:
-            return jsonResponse({ error: `Unknown GET route: ${route}` }, 404);
-        }
+var CREDIT_TOKENS = {
+  base: ["USDC", "WETH", "USDT", "DAI", "WBTC"],
+  ethereum: ["USDC", "WETH", "USDT", "DAI", "WBTC"],
+  arbitrum: ["USDC", "WETH", "USDT", "DAI", "WBTC"]
+};
+
+// src/server/core/compass-service.ts
+var CompassServiceError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "CompassServiceError";
+  }
+};
+var CompassCoreService = class {
+  constructor(config) {
+    this.config = config;
+    const { apiKey, serverUrl = "https://api.compasslabs.ai" } = config;
+    this.client = new apiSdk.CompassApiSDK({
+      apiKeyAuth: apiKey,
+      serverURL: serverUrl
+    });
+  }
+  // --- Earn ---
+  async earnAccountCheck(params) {
+    const { owner, chain = "base" } = params;
+    if (!owner) {
+      throw new CompassServiceError("Missing owner parameter", 400);
+    }
+    const response = await this.client.earn.earnCreateAccount({
+      chain,
+      owner,
+      sender: owner,
+      estimateGas: false
+    });
+    const earnAccountAddress = response.earnAccountAddress;
+    const hasTransaction = !!response.transaction;
+    return {
+      earnAccountAddress,
+      isDeployed: !hasTransaction,
+      needsCreation: hasTransaction
+    };
+  }
+  async earnAccountBalances(params) {
+    const { owner, chain = "base" } = params;
+    if (!owner) {
+      throw new CompassServiceError("Missing owner parameter", 400);
+    }
+    const response = await this.client.earn.earnBalances({
+      chain,
+      owner
+    });
+    const data = response;
+    const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+    const balances = {};
+    for (const [symbol, tokenData] of Object.entries(data.balances)) {
+      const td = tokenData;
+      const hasRealTransfers = td.transfers.some((t) => {
+        const fromAddr = (t.from_address || t.fromAddress || "").toLowerCase();
+        const toAddr = (t.to_address || t.toAddress || "").toLowerCase();
+        return fromAddr !== ZERO_ADDRESS && toAddr !== ZERO_ADDRESS;
+      });
+      const balanceFormatted = td.balance_formatted || td.balanceFormatted || "0";
+      const balanceNum = parseFloat(balanceFormatted);
+      if (balanceNum === 0 && !hasRealTransfers) {
+        continue;
       }
-      if (method === "POST") {
-        const body = await request.json();
-        switch (route) {
-          case "create-account":
-            return await handleCreateAccount(client, body, config);
-          case "deposit/prepare":
-            return await handleManagePrepare(client, body, "DEPOSIT");
-          case "deposit/execute":
-            return await handleExecute(client, body, config);
-          case "withdraw/prepare":
-            return await handleManagePrepare(client, body, "WITHDRAW");
-          case "withdraw/execute":
-            return await handleExecute(client, body, config);
-          case "transfer/approve":
-            return await handleTransferApprove(client, body);
-          case "transfer/prepare":
-            return await handleTransferPrepare(client, body, config);
-          case "transfer/execute":
-            return await handleTransferExecute(client, body, config);
-          case "bundle/prepare":
-            return await handleBundlePrepare(client, body);
-          case "bundle/execute":
-            return await handleBundleExecute(client, body, config);
-          case "swap/prepare":
-            return await handleSwapPrepare(client, body);
-          case "swap/execute":
-            return await handleSwapExecute(client, body, config);
-          case "rebalance/preview":
-            return await handleRebalancePreview(client, body, config);
-          case "credit-account/create":
-            return await handleCreditCreateAccount(client, body, config);
-          case "credit/bundle/prepare":
-            return await handleCreditBundlePrepare(client, body);
-          case "credit/bundle/execute":
-            return await handleCreditExecute(client, body, config);
-          case "credit/transfer":
-            return await handleCreditTransfer(client, body);
-          case "approval/execute":
-            return await handleApprovalExecute(body, config);
-          default:
-            return jsonResponse({ error: `Unknown POST route: ${route}` }, 404);
-        }
+      if (!hasRealTransfers && td.transfers.length > 0) {
+        continue;
       }
-      return jsonResponse({ error: `Method ${method} not allowed` }, 405);
-    } catch (error) {
-      const { message, status } = extractErrorMessage(error);
-      return jsonResponse({ error: message }, status);
+      const usdValue = td.usd_value || td.usdValue || "0";
+      const usdValueNum = parseFloat(usdValue);
+      if (usdValueNum === 0 || isNaN(usdValueNum)) {
+        continue;
+      }
+      balances[symbol] = {
+        balance: balanceFormatted,
+        usdValue
+      };
     }
-  };
-}
-function extractErrorMessage(error) {
-  if (!(error instanceof Error)) {
-    return { message: "Something went wrong. Please try again.", status: 500 };
+    const earnAccountAddr = data.earn_account_address || data.earnAccountAddress || "";
+    const totalUsd = data.total_usd_value || data.totalUsdValue || "0";
+    return {
+      earnAccountAddress: earnAccountAddr,
+      balances,
+      totalUsdValue: totalUsd
+    };
   }
-  const raw = error.message || "";
-  const jsonMatch = raw.match(/Body:\s*(\{[\s\S]*\})/);
-  if (jsonMatch) {
-    try {
-      const body = JSON.parse(jsonMatch[1]);
-      if (Array.isArray(body.detail)) {
-        const msgs = body.detail.map((d) => d.msg || d.message).filter(Boolean);
-        if (msgs.length > 0) return { message: msgs.join(". "), status: 422 };
-      }
-      if (typeof body.detail === "string") return { message: body.detail, status: 422 };
-      if (typeof body.error === "string") return { message: body.error, status: 500 };
-      if (typeof body.description === "string") return { message: body.description, status: 500 };
-    } catch {
+  async createAccount(body) {
+    const { owner, chain = "base" } = body;
+    const { gasSponsorPrivateKey, rpcUrls } = this.config;
+    if (!owner) {
+      throw new CompassServiceError("Missing owner parameter", 400);
+    }
+    if (!gasSponsorPrivateKey) {
+      throw new CompassServiceError(
+        "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config.",
+        500
+      );
+    }
+    const viemChain = CHAIN_MAP[chain.toLowerCase()];
+    if (!viemChain) {
+      throw new CompassServiceError(`Unsupported chain: ${chain}`, 500);
+    }
+    const rpcUrl = rpcUrls?.[chain.toLowerCase()];
+    if (!rpcUrl) {
+      throw new CompassServiceError(`No RPC URL configured for chain: ${chain}`, 500);
+    }
+    const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
+    const walletClient = viem.createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
+    });
+    const publicClient = viem.createPublicClient({
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
+    });
+    const response = await this.client.earn.earnCreateAccount({
+      chain,
+      owner,
+      sender: sponsorAccount.address,
+      estimateGas: false
+    });
+    const earnAccountAddress = response.earnAccountAddress;
+    if (!response.transaction) {
+      return {
+        earnAccountAddress,
+        success: true,
+        alreadyExists: true
+      };
+    }
+    const transaction = response.transaction;
+    const txHash = await walletClient.sendTransaction({
+      to: transaction.to,
+      data: transaction.data,
+      value: transaction.value ? BigInt(transaction.value) : 0n,
+      gas: transaction.gas ? BigInt(transaction.gas) : void 0
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash
+    });
+    if (receipt.status === "reverted") {
+      throw new CompassServiceError("Account creation transaction reverted", 500);
     }
+    return {
+      earnAccountAddress,
+      txHash,
+      success: true
+    };
   }
-  if (error.name === "SDKValidationError" || raw.startsWith("Input validation failed")) {
-    return { message: "Invalid request data. Please check your inputs and try again.", status: 400 };
+  async managePrepare(body, action) {
+    const { amount, token, owner, chain, venueType, vaultAddress, marketAddress, maxSlippagePercent } = body;
+    let venue;
+    if (venueType === "VAULT" && vaultAddress) {
+      venue = {
+        type: "VAULT",
+        vaultAddress
+      };
+    } else if (venueType === "AAVE") {
+      venue = {
+        type: "AAVE",
+        token
+      };
+    } else if (venueType === "PENDLE_PT" && marketAddress) {
+      venue = {
+        type: "PENDLE_PT",
+        marketAddress,
+        token: action === "DEPOSIT" ? token : void 0,
+        maxSlippagePercent: maxSlippagePercent ?? 1
+      };
+    } else {
+      throw new CompassServiceError("Invalid venue type or missing address", 400);
+    }
+    const response = await this.client.earn.earnManage({
+      owner,
+      chain,
+      venue,
+      action,
+      amount,
+      gasSponsorship: true
+    });
+    const eip712 = response.eip712;
+    if (!eip712) {
+      throw new CompassServiceError("No EIP-712 data returned from API", 500);
+    }
+    const types = eip712.types;
+    const normalizedTypes = {
+      EIP712Domain: types.eip712Domain || types.EIP712Domain,
+      SafeTx: types.safeTx || types.SafeTx
+    };
+    return {
+      eip712,
+      normalizedTypes,
+      domain: eip712.domain,
+      message: eip712.message
+    };
   }
-  if (raw.includes("Insufficient") || raw.includes("not deployed") || raw.includes("reverted") || raw.includes("not configured") || raw.includes("Unsupported chain")) {
-    return { message: raw, status: 500 };
+  async execute(body) {
+    const { owner, eip712, signature, chain } = body;
+    const { gasSponsorPrivateKey, rpcUrls } = this.config;
+    if (!gasSponsorPrivateKey) {
+      throw new CompassServiceError(
+        "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config.",
+        500
+      );
+    }
+    const viemChain = CHAIN_MAP[chain.toLowerCase()];
+    if (!viemChain) {
+      throw new CompassServiceError(`Unsupported chain: ${chain}`, 500);
+    }
+    const rpcUrl = rpcUrls?.[chain.toLowerCase()];
+    if (!rpcUrl) {
+      throw new CompassServiceError(`No RPC URL configured for chain: ${chain}`, 500);
+    }
+    const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
+    const walletClient = viem.createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
+    });
+    const response = await this.client.gasSponsorship.gasSponsorshipPrepare({
+      chain,
+      owner,
+      sender: sponsorAccount.address,
+      eip712,
+      signature
+    });
+    const transaction = response.transaction;
+    if (!transaction) {
+      throw new CompassServiceError(
+        "No transaction returned from gas sponsorship prepare",
+        500
+      );
+    }
+    const txHash = await walletClient.sendTransaction({
+      to: transaction.to,
+      data: transaction.data,
+      value: transaction.value ? BigInt(transaction.value) : 0n,
+      gas: transaction.gas ? BigInt(transaction.gas) : void 0
+    });
+    return { txHash, success: true };
   }
-  return { message: "Something went wrong. Please try again.", status: 500 };
-}
-function jsonResponse(data, status = 200) {
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-async function handleEarnAccountCheck(client, params) {
-  const { owner, chain = "base" } = params;
-  if (!owner) {
-    return jsonResponse({ error: "Missing owner parameter" }, 400);
+  // --- Transfer ---
+  async transferApprove(body) {
+    const { owner, chain = "base", token } = body;
+    if (!owner || !token) {
+      throw new CompassServiceError("Missing owner or token parameter", 400);
+    }
+    try {
+      const response = await this.client.gasSponsorship.gasSponsorshipApproveTransfer({
+        owner,
+        chain,
+        token,
+        gasSponsorship: true
+      });
+      const eip712 = response.eip712 || response.eip_712;
+      const transaction = response.transaction;
+      if (!eip712 && !transaction) {
+        return {
+          approved: true,
+          message: "Token already approved for Permit2"
+        };
+      }
+      if (eip712) {
+        const types = eip712.types;
+        const normalizedTypes = {
+          EIP712Domain: types.eip712Domain || types.EIP712Domain,
+          Permit: types.permit || types.Permit
+        };
+        return {
+          approved: false,
+          eip712,
+          normalizedTypes,
+          domain: eip712.domain,
+          message: eip712.message
+        };
+      }
+      return {
+        approved: false,
+        transaction,
+        requiresTransaction: true
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("already set") || errorMessage.includes("already been set")) {
+        return {
+          approved: true,
+          message: "Token allowance already set"
+        };
+      }
+      throw error;
+    }
   }
-  const response = await client.earn.earnCreateAccount({
-    chain,
-    owner,
-    sender: owner,
-    estimateGas: false
-  });
-  const earnAccountAddress = response.earnAccountAddress;
-  const hasTransaction = !!response.transaction;
-  return jsonResponse({
-    earnAccountAddress,
-    isDeployed: !hasTransaction,
-    needsCreation: hasTransaction
-  });
-}
-async function handleCreateAccount(client, body, config) {
-  const { owner, chain = "base" } = body;
-  const { gasSponsorPrivateKey, rpcUrls } = config;
-  if (!owner) {
-    return jsonResponse({ error: "Missing owner parameter" }, 400);
+  async transferPrepare(body) {
+    const { owner, chain = "base", token, amount, action, product } = body;
+    const { gasSponsorPrivateKey } = this.config;
+    if (!owner || !token || !amount || !action) {
+      throw new CompassServiceError("Missing required parameters", 400);
+    }
+    let spender;
+    if (action === "DEPOSIT" && gasSponsorPrivateKey) {
+      const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
+      spender = sponsorAccount.address;
+    }
+    let response;
+    if (product === "credit") {
+      response = await this.client.credit.creditTransfer({
+        owner,
+        chain,
+        token,
+        amount,
+        action,
+        gasSponsorship: true,
+        ...spender && { spender }
+      });
+    } else {
+      response = await this.client.earn.earnTransfer({
+        owner,
+        chain,
+        token,
+        amount,
+        action,
+        gasSponsorship: true,
+        ...spender && { spender }
+      });
+    }
+    const eip712 = response.eip712;
+    if (!eip712) {
+      throw new CompassServiceError("No EIP-712 data returned from API", 500);
+    }
+    const types = eip712.types;
+    let normalizedTypes;
+    if (action === "DEPOSIT") {
+      normalizedTypes = {
+        EIP712Domain: types.eip712Domain || types.EIP712Domain,
+        PermitTransferFrom: types.permitTransferFrom || types.PermitTransferFrom,
+        TokenPermissions: types.tokenPermissions || types.TokenPermissions
+      };
+    } else {
+      normalizedTypes = {
+        EIP712Domain: types.eip712Domain || types.EIP712Domain,
+        SafeTx: types.safeTx || types.SafeTx
+      };
+    }
+    return {
+      eip712,
+      normalizedTypes,
+      domain: eip712.domain,
+      message: eip712.message,
+      primaryType: eip712.primaryType
+    };
   }
-  if (!gasSponsorPrivateKey) {
-    return jsonResponse(
-      { error: "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config." },
-      500
-    );
+  async transferExecute(body) {
+    const { owner, chain = "base", eip712, signature, product } = body;
+    const { gasSponsorPrivateKey, rpcUrls } = this.config;
+    if (!owner || !eip712 || !signature) {
+      throw new CompassServiceError("Missing required parameters", 400);
+    }
+    if (!gasSponsorPrivateKey) {
+      throw new CompassServiceError(
+        "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config.",
+        500
+      );
+    }
+    const viemChain = CHAIN_MAP[chain.toLowerCase()];
+    if (!viemChain) {
+      throw new CompassServiceError(`Unsupported chain: ${chain}`, 500);
+    }
+    const rpcUrl = rpcUrls?.[chain.toLowerCase()];
+    if (!rpcUrl) {
+      throw new CompassServiceError(`No RPC URL configured for chain: ${chain}`, 500);
+    }
+    const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
+    const walletClient = viem.createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
+    });
+    const response = await this.client.gasSponsorship.gasSponsorshipPrepare({
+      chain,
+      owner,
+      sender: sponsorAccount.address,
+      eip712,
+      signature,
+      ...product === "credit" && { product: "credit" }
+    });
+    const transaction = response.transaction;
+    if (!transaction) {
+      throw new CompassServiceError(
+        "No transaction returned from gas sponsorship prepare",
+        500
+      );
+    }
+    const txHash = await walletClient.sendTransaction({
+      to: transaction.to,
+      data: transaction.data,
+      value: transaction.value ? BigInt(transaction.value) : 0n,
+      gas: transaction.gas ? BigInt(transaction.gas) : void 0
+    });
+    return { txHash, success: true };
   }
-  const viemChain = CHAIN_MAP[chain.toLowerCase()];
-  if (!viemChain) {
-    return jsonResponse({ error: `Unsupported chain: ${chain}` }, 500);
+  async approvalExecute(body) {
+    const { owner, chain = "base", transaction } = body;
+    const { gasSponsorPrivateKey, rpcUrls } = this.config;
+    if (!owner || !transaction) {
+      throw new CompassServiceError("Missing required parameters (owner, transaction)", 400);
+    }
+    if (!gasSponsorPrivateKey) {
+      throw new CompassServiceError(
+        "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config.",
+        500
+      );
+    }
+    const viemChain = CHAIN_MAP[chain.toLowerCase()];
+    if (!viemChain) {
+      throw new CompassServiceError(`Unsupported chain: ${chain}`, 500);
+    }
+    const rpcUrl = rpcUrls?.[chain.toLowerCase()];
+    if (!rpcUrl) {
+      throw new CompassServiceError(`No RPC URL configured for chain: ${chain}`, 500);
+    }
+    const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
+    const walletClient = viem.createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
+    });
+    const publicClient = viem.createPublicClient({
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
+    });
+    const txHash = await walletClient.sendTransaction({
+      to: transaction.to,
+      data: transaction.data,
+      value: transaction.value ? BigInt(transaction.value) : 0n,
+      gas: transaction.gas ? BigInt(transaction.gas) : void 0
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      timeout: 6e4
+    });
+    if (receipt.status === "reverted") {
+      throw new CompassServiceError("Approval transaction reverted", 500);
+    }
+    return { txHash, status: "success" };
   }
-  const rpcUrl = rpcUrls?.[chain.toLowerCase()];
-  if (!rpcUrl) {
-    return jsonResponse({ error: `No RPC URL configured for chain: ${chain}` }, 500);
+  // --- Swap ---
+  async swapQuote(params) {
+    const { owner, chain = "base", tokenIn, tokenOut, amountIn } = params;
+    if (!owner || !tokenIn || !tokenOut || !amountIn) {
+      throw new CompassServiceError("Missing required parameters: owner, tokenIn, tokenOut, amountIn", 400);
+    }
+    try {
+      const response = await this.client.earn.earnSwap({
+        owner,
+        chain,
+        tokenIn,
+        tokenOut,
+        amountIn,
+        slippage: 1,
+        gasSponsorship: true
+      });
+      const estimatedAmountOut = response.estimatedAmountOut || "0";
+      return {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        estimatedAmountOut: estimatedAmountOut?.toString() || "0"
+      };
+    } catch (error) {
+      let errorMessage = "Failed to get swap quote";
+      try {
+        const bodyMessage = error?.body?.message || error?.message || "";
+        if (bodyMessage.includes("{")) {
+          const jsonMatch = bodyMessage.match(/\{.*\}/s);
+          if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            errorMessage = parsed.description || parsed.error || parsed.message || errorMessage;
+          }
+        } else if (bodyMessage) {
+          const balanceMatch = bodyMessage.match(/Insufficient \w+ balance[^.]+/i);
+          if (balanceMatch) {
+            errorMessage = balanceMatch[0];
+          } else {
+            errorMessage = bodyMessage;
+          }
+        }
+      } catch {
+        errorMessage = error?.body?.error || error?.message || "Failed to get swap quote";
+      }
+      throw new CompassServiceError(errorMessage, 400);
+    }
   }
-  const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
-  const walletClient = viem.createWalletClient({
-    account: sponsorAccount,
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  const publicClient = viem.createPublicClient({
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  const response = await client.earn.earnCreateAccount({
-    chain,
-    owner,
-    sender: sponsorAccount.address,
-    estimateGas: false
-  });
-  const earnAccountAddress = response.earnAccountAddress;
-  if (!response.transaction) {
-    return jsonResponse({
-      earnAccountAddress,
-      success: true,
-      alreadyExists: true
+  async swapPrepare(body) {
+    const { owner, chain = "base", tokenIn, tokenOut, amountIn, slippage = 1 } = body;
+    if (!owner || !tokenIn || !tokenOut || !amountIn) {
+      throw new CompassServiceError("Missing required parameters: owner, tokenIn, tokenOut, amountIn", 400);
+    }
+    const response = await this.client.earn.earnSwap({
+      owner,
+      chain,
+      tokenIn,
+      tokenOut,
+      amountIn,
+      slippage,
+      gasSponsorship: true
     });
+    const eip712 = response.eip712;
+    if (!eip712) {
+      throw new CompassServiceError("No EIP-712 data returned from API", 500);
+    }
+    const types = eip712.types;
+    const normalizedTypes = {
+      EIP712Domain: types.eip712Domain || types.EIP712Domain,
+      SafeTx: types.safeTx || types.SafeTx
+    };
+    return {
+      eip712,
+      normalizedTypes,
+      domain: eip712.domain,
+      message: eip712.message,
+      estimatedAmountOut: response.estimatedAmountOut?.toString() || "0"
+    };
   }
-  const transaction = response.transaction;
-  const txHash = await walletClient.sendTransaction({
-    to: transaction.to,
-    data: transaction.data,
-    value: transaction.value ? BigInt(transaction.value) : 0n,
-    gas: transaction.gas ? BigInt(transaction.gas) : void 0
-  });
-  const receipt = await publicClient.waitForTransactionReceipt({
-    hash: txHash
-  });
-  if (receipt.status === "reverted") {
-    return jsonResponse({ error: "Account creation transaction reverted" }, 500);
+  async swapExecute(body) {
+    const { owner, chain = "base", eip712, signature } = body;
+    if (!owner || !eip712 || !signature) {
+      throw new CompassServiceError("Missing required parameters: owner, eip712, signature", 400);
+    }
+    if (!this.config.gasSponsorPrivateKey) {
+      throw new CompassServiceError("Gas sponsor not configured", 500);
+    }
+    const chainLower = chain.toLowerCase();
+    const rpcUrl = this.config.rpcUrls?.[chainLower];
+    if (!rpcUrl) {
+      throw new CompassServiceError(`No RPC URL configured for chain: ${chain}`, 500);
+    }
+    const viemChain = CHAIN_MAP[chainLower];
+    if (!viemChain) {
+      throw new CompassServiceError(`Unsupported chain: ${chain}`, 400);
+    }
+    const sponsorAccount = accounts.privateKeyToAccount(this.config.gasSponsorPrivateKey);
+    const walletClient = viem.createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
+    });
+    const publicClient = viem.createPublicClient({
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
+    });
+    const response = await this.client.gasSponsorship.gasSponsorshipPrepare({
+      chain,
+      owner,
+      sender: sponsorAccount.address,
+      eip712,
+      signature
+    });
+    const transaction = response.transaction;
+    if (!transaction) {
+      throw new CompassServiceError("No transaction returned from gas sponsorship prepare", 500);
+    }
+    const txHash = await walletClient.sendTransaction({
+      to: transaction.to,
+      data: transaction.data,
+      value: transaction.value ? BigInt(transaction.value) : 0n,
+      gas: transaction.gas ? BigInt(transaction.gas) : void 0
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash
+    });
+    if (receipt.status === "reverted") {
+      throw new CompassServiceError("Transaction reverted", 500);
+    }
+    return { txHash, success: true };
+  }
+  // --- Token ---
+  async tokenBalance(params) {
+    const { chain = "base", token, address } = params;
+    if (!token || !address) {
+      throw new CompassServiceError("Missing token or address parameter", 400);
+    }
+    try {
+      const response = await this.client.token.tokenBalance({
+        chain,
+        token,
+        user: address
+      });
+      return {
+        token,
+        address,
+        balance: response.amount || "0",
+        balanceRaw: response.balanceRaw || "0"
+      };
+    } catch {
+      return {
+        token,
+        address,
+        balance: "0",
+        balanceRaw: "0"
+      };
+    }
+  }
+  async tokenPrices(params) {
+    const { chain = "base", tokens } = params;
+    if (!tokens) {
+      throw new CompassServiceError("Missing tokens parameter", 400);
+    }
+    const tokenList = tokens.split(",").map((t) => t.trim().toUpperCase());
+    const prices = {};
+    const results = await Promise.allSettled(
+      tokenList.map(async (symbol) => {
+        const resp = await this.client.token.tokenPrice({ chain, token: symbol });
+        return { symbol, price: parseFloat(resp.price || "0") };
+      })
+    );
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value.price > 0) {
+        prices[result.value.symbol] = result.value.price;
+      }
+    }
+    return { prices };
   }
-  return jsonResponse({
-    earnAccountAddress,
-    txHash,
-    success: true
-  });
-}
-async function handleManagePrepare(client, body, action) {
-  const { amount, token, owner, chain, venueType, vaultAddress, marketAddress, maxSlippagePercent } = body;
-  let venue;
-  if (venueType === "VAULT" && vaultAddress) {
-    venue = {
-      type: "VAULT",
-      vaultAddress
-    };
-  } else if (venueType === "AAVE") {
-    venue = {
-      type: "AAVE",
-      token
+  // --- Bundle ---
+  async bundlePrepare(body) {
+    const { owner, chain = "base", actions } = body;
+    if (!owner || !actions || actions.length === 0) {
+      throw new CompassServiceError("Missing owner or actions", 400);
+    }
+    const response = await this.client.earn.earnBundle({
+      owner,
+      chain,
+      gasSponsorship: true,
+      actions
+    });
+    const eip712 = response.eip712;
+    if (!eip712) {
+      throw new CompassServiceError("No EIP-712 data returned from API", 500);
+    }
+    const types = eip712.types;
+    const normalizedTypes = {
+      EIP712Domain: types.eip712Domain || types.EIP712Domain,
+      SafeTx: types.safeTx || types.SafeTx
     };
-  } else if (venueType === "PENDLE_PT" && marketAddress) {
-    venue = {
-      type: "PENDLE_PT",
-      marketAddress,
-      token: action === "DEPOSIT" ? token : void 0,
-      maxSlippagePercent: maxSlippagePercent ?? 1
+    return {
+      eip712,
+      normalizedTypes,
+      domain: eip712.domain,
+      message: eip712.message,
+      actionsCount: response.actionsCount || actions.length
     };
-  } else {
-    return jsonResponse({ error: "Invalid venue type or missing address" }, 400);
-  }
-  const response = await client.earn.earnManage({
-    owner,
-    chain,
-    venue,
-    action,
-    amount,
-    gasSponsorship: true
-  });
-  const eip712 = response.eip712;
-  if (!eip712) {
-    return jsonResponse({ error: "No EIP-712 data returned from API" }, 500);
   }
-  const types = eip712.types;
-  const normalizedTypes = {
-    EIP712Domain: types.eip712Domain,
-    SafeTx: types.safeTx
-  };
-  return jsonResponse({
-    eip712,
-    normalizedTypes,
-    domain: eip712.domain,
-    message: eip712.message
-  });
-}
-async function handleExecute(client, body, config) {
-  const { owner, eip712, signature, chain } = body;
-  const { gasSponsorPrivateKey, rpcUrls } = config;
-  if (!gasSponsorPrivateKey) {
-    return jsonResponse(
-      { error: "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config." },
-      500
-    );
+  async bundleExecute(body) {
+    return this.transferExecute(body);
   }
-  const viemChain = CHAIN_MAP[chain.toLowerCase()];
-  if (!viemChain) {
-    return jsonResponse({ error: `Unsupported chain: ${chain}` }, 500);
+  // --- Data ---
+  async vaults(params) {
+    const { chain = "base", orderBy = "apy_7d", direction = "desc", limit = "100", assetSymbol, minTvlUsd } = params;
+    try {
+      const response = await this.client.earn.earnVaults({
+        chain,
+        orderBy,
+        direction,
+        limit: parseInt(limit, 10),
+        ...assetSymbol && { assetSymbol },
+        ...minTvlUsd && { minTvlUsd: parseFloat(minTvlUsd) }
+      });
+      return response;
+    } catch {
+      throw new CompassServiceError("Failed to fetch vaults", 500);
+    }
   }
-  const rpcUrl = rpcUrls?.[chain.toLowerCase()];
-  if (!rpcUrl) {
-    return jsonResponse({ error: `No RPC URL configured for chain: ${chain}` }, 500);
+  async aaveMarkets(params) {
+    const { chain = "base" } = params;
+    try {
+      const response = await this.client.earn.earnAaveMarkets({
+        chain
+      });
+      return response;
+    } catch {
+      throw new CompassServiceError("Failed to fetch Aave markets", 500);
+    }
   }
-  const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
-  const walletClient = viem.createWalletClient({
-    account: sponsorAccount,
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  const response = await client.gasSponsorship.gasSponsorshipPrepare({
-    chain,
-    owner,
-    sender: sponsorAccount.address,
-    eip712,
-    signature
-  });
-  const transaction = response.transaction;
-  if (!transaction) {
-    return jsonResponse(
-      { error: "No transaction returned from gas sponsorship prepare" },
-      500
-    );
+  async pendleMarkets(params) {
+    const { chain = "base", orderBy = "implied_apy", direction = "desc", limit = "100", underlyingSymbol, minTvlUsd } = params;
+    try {
+      const response = await this.client.earn.earnPendleMarkets({
+        chain,
+        orderBy,
+        direction,
+        limit: parseInt(limit, 10),
+        ...underlyingSymbol && { underlyingSymbol },
+        ...minTvlUsd && { minTvlUsd: parseFloat(minTvlUsd) }
+      });
+      return response;
+    } catch {
+      throw new CompassServiceError("Failed to fetch Pendle markets", 500);
+    }
   }
-  const txHash = await walletClient.sendTransaction({
-    to: transaction.to,
-    data: transaction.data,
-    value: transaction.value ? BigInt(transaction.value) : 0n,
-    gas: transaction.gas ? BigInt(transaction.gas) : void 0
-  });
-  return jsonResponse({ txHash, success: true });
-}
-async function handleTransferApprove(client, body) {
-  const { owner, chain = "base", token } = body;
-  if (!owner || !token) {
-    return jsonResponse({ error: "Missing owner or token parameter" }, 400);
+  async positions(params) {
+    const { chain = "base", owner } = params;
+    if (!owner) {
+      throw new CompassServiceError("Missing owner parameter", 400);
+    }
+    try {
+      const positionsResponse = await this.client.earn.earnPositions({
+        chain,
+        owner
+      });
+      const raw = JSON.parse(JSON.stringify(positionsResponse));
+      const positions = [];
+      const aavePositions = raw.aave || [];
+      for (const a of aavePositions) {
+        const balance = a.balance || "0";
+        const symbol = (a.reserveSymbol || a.reserve_symbol || "UNKNOWN").toUpperCase();
+        const pnl = a.pnl;
+        positions.push({
+          protocol: "aave",
+          symbol,
+          name: `${symbol} on Aave`,
+          balance,
+          balanceUsd: a.usdValue || a.usd_value || balance,
+          apy: parseFloat(a.apy || "0"),
+          pnl: pnl ? {
+            unrealizedPnl: pnl.unrealizedPnl ?? pnl.unrealized_pnl ?? "0",
+            realizedPnl: pnl.realizedPnl ?? pnl.realized_pnl ?? "0",
+            totalPnl: pnl.totalPnl ?? pnl.total_pnl ?? "0",
+            totalDeposited: pnl.totalDeposited ?? pnl.total_deposited ?? "0"
+          } : null,
+          deposits: (a.deposits || []).map((d) => ({
+            amount: d.inputAmount || d.input_amount || d.amount || "0",
+            blockNumber: d.blockNumber || d.block_number || 0,
+            timestamp: d.blockTimestamp || d.block_timestamp || void 0,
+            txHash: d.transactionHash || d.transaction_hash || d.txHash || ""
+          })),
+          withdrawals: (a.withdrawals || []).map((w) => ({
+            amount: w.outputAmount || w.output_amount || w.amount || "0",
+            blockNumber: w.blockNumber || w.block_number || 0,
+            timestamp: w.blockTimestamp || w.block_timestamp || void 0,
+            txHash: w.transactionHash || w.transaction_hash || w.txHash || ""
+          }))
+        });
+      }
+      const vaultPositions = raw.vaults || [];
+      for (const v of vaultPositions) {
+        const balance = v.balance || "0";
+        const symbol = (v.underlyingSymbol || v.underlying_symbol || "TOKEN").toUpperCase();
+        const vaultName = v.vaultName || v.vault_name || `${symbol} Vault`;
+        const pnl = v.pnl;
+        positions.push({
+          protocol: "vaults",
+          symbol,
+          name: vaultName,
+          balance,
+          balanceUsd: v.usdValue || v.usd_value || balance,
+          apy: parseFloat(v.apy7d || v.apy_7d || "0"),
+          vaultAddress: v.vaultAddress || v.vault_address || void 0,
+          pnl: pnl ? {
+            unrealizedPnl: pnl.unrealizedPnl ?? pnl.unrealized_pnl ?? "0",
+            realizedPnl: pnl.realizedPnl ?? pnl.realized_pnl ?? "0",
+            totalPnl: pnl.totalPnl ?? pnl.total_pnl ?? "0",
+            totalDeposited: pnl.totalDeposited ?? pnl.total_deposited ?? "0"
+          } : null,
+          deposits: (v.deposits || []).map((d) => ({
+            amount: d.inputAmount || d.input_amount || d.amount || "0",
+            blockNumber: d.blockNumber || d.block_number || 0,
+            timestamp: d.blockTimestamp || d.block_timestamp || void 0,
+            txHash: d.transactionHash || d.transaction_hash || d.txHash || ""
+          })),
+          withdrawals: (v.withdrawals || []).map((w) => ({
+            amount: w.outputAmount || w.output_amount || w.amount || "0",
+            blockNumber: w.blockNumber || w.block_number || 0,
+            timestamp: w.blockTimestamp || w.block_timestamp || void 0,
+            txHash: w.transactionHash || w.transaction_hash || w.txHash || ""
+          }))
+        });
+      }
+      const pendlePositions = raw.pendlePt || raw.pendle_pt || [];
+      for (const p of pendlePositions) {
+        const balance = p.ptBalance || p.pt_balance || p.balance || "0";
+        const symbol = (p.underlyingSymbol || p.underlying_symbol || "PT").toUpperCase();
+        const pnl = p.pnl;
+        positions.push({
+          protocol: "pendle",
+          symbol,
+          name: `PT-${symbol}`,
+          balance,
+          balanceUsd: p.usdValue || p.usd_value || balance,
+          apy: parseFloat(p.impliedApy || p.implied_apy || "0"),
+          marketAddress: p.marketAddress || p.market_address || void 0,
+          pnl: pnl ? {
+            unrealizedPnl: pnl.unrealizedPnl ?? pnl.unrealized_pnl ?? "0",
+            realizedPnl: pnl.realizedPnl ?? pnl.realized_pnl ?? "0",
+            totalPnl: pnl.totalPnl ?? pnl.total_pnl ?? "0",
+            totalDeposited: pnl.totalDeposited ?? pnl.total_deposited ?? "0"
+          } : null,
+          deposits: (p.deposits || []).map((d) => ({
+            amount: d.inputAmount || d.input_amount || d.amount || "0",
+            blockNumber: d.blockNumber || d.block_number || 0,
+            timestamp: d.blockTimestamp || d.block_timestamp || void 0,
+            txHash: d.transactionHash || d.transaction_hash || d.txHash || ""
+          })),
+          withdrawals: (p.withdrawals || []).map((w) => ({
+            amount: w.outputAmount || w.output_amount || w.amount || "0",
+            blockNumber: w.blockNumber || w.block_number || 0,
+            timestamp: w.blockTimestamp || w.block_timestamp || void 0,
+            txHash: w.transactionHash || w.transaction_hash || w.txHash || ""
+          }))
+        });
+      }
+      return { positions };
+    } catch {
+      throw new CompassServiceError("Failed to fetch positions", 500);
+    }
   }
-  try {
-    const response = await client.gasSponsorship.gasSponsorshipApproveTransfer({
-      owner,
-      chain,
-      token,
-      gasSponsorship: true
+  async txReceipt(params) {
+    const { hash, chain } = params;
+    if (!hash || !chain) {
+      throw new CompassServiceError("Missing hash or chain parameter", 400);
+    }
+    const rpcUrl = this.config.rpcUrls?.[chain.toLowerCase()];
+    const viemChain = CHAIN_MAP[chain.toLowerCase()];
+    if (!viemChain) {
+      throw new CompassServiceError(`Unsupported chain: ${chain}`, 400);
+    }
+    if (!rpcUrl) {
+      throw new CompassServiceError(`No RPC URL configured for chain: ${chain}`, 500);
+    }
+    const publicClient = viem.createPublicClient({
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
     });
-    const eip712 = response.eip712 || response.eip_712;
-    const transaction = response.transaction;
-    if (!eip712 && !transaction) {
-      return jsonResponse({
-        approved: true,
-        message: "Token already approved for Permit2"
+    try {
+      const receipt = await publicClient.getTransactionReceipt({
+        hash
       });
+      return {
+        status: receipt.status,
+        blockNumber: receipt.blockNumber.toString()
+      };
+    } catch {
+      return { status: "pending" };
+    }
+  }
+  // --- Rebalance ---
+  async rebalancePreview(body) {
+    const { owner, chain = "base", targets, slippage = 0.5 } = body;
+    if (!owner) {
+      throw new CompassServiceError("Missing owner parameter", 400);
+    }
+    if (!targets || targets.length === 0) {
+      throw new CompassServiceError("Missing targets", 400);
+    }
+    for (const t of targets) {
+      if (t.targetPercent < 0 || t.targetPercent > 100) {
+        throw new CompassServiceError(`Invalid target percentage: ${t.targetPercent}%`, 400);
+      }
     }
-    if (eip712) {
+    try {
+      const positionsResponse = await this.client.earn.earnPositions({
+        chain,
+        owner
+      });
+      const positionsRaw = JSON.parse(JSON.stringify(positionsResponse));
+      const balancesResponse = await this.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) {
+        throw new CompassServiceError("No portfolio value found to rebalance", 400);
+      }
+      const allTokenSymbols = /* @__PURE__ */ new Set();
+      for (const pos of currentPositions) allTokenSymbols.add(pos.token.toUpperCase());
+      for (const t of targets) if (t.token) allTokenSymbols.add(t.token.toUpperCase());
+      for (const sym of Object.keys(balancesRaw.balances || {})) allTokenSymbols.add(sym.toUpperCase());
+      const tokenPrices = {};
+      const priceResults = await Promise.allSettled(
+        [...allTokenSymbols].map(async (symbol) => {
+          const resp = await this.client.token.tokenPrice({ chain, token: symbol });
+          return { symbol, price: parseFloat(resp.price || "0") };
+        })
+      );
+      for (const result of priceResults) {
+        if (result.status === "fulfilled" && result.value.price > 0) {
+          tokenPrices[result.value.symbol] = result.value.price;
+        }
+      }
+      const bundleActions = [];
+      const actionsSummary = [];
+      const warnings = [];
+      const MIN_THRESHOLD_USD = 0.01;
+      const CHANGE_THRESHOLD_PCT = 0.1;
+      const pendingDeposits = [];
+      for (const target of targets) {
+        const originalPct = target.originalPercent ?? target.targetPercent;
+        if (Math.abs(target.targetPercent - originalPct) <= CHANGE_THRESHOLD_PCT) continue;
+        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_formatted || td.balanceFormatted || "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 : tokenPrices[sourceToken] ? swapUsd / tokenPrices[sourceToken] : 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 : tokenPrices[depositToken] || 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 : tokenPrices[key] || 1;
+        const desiredTokens = dep.deltaUsd / tokenPrice;
+        const maxAvailableTokens = available ? available.tokenAmount * 0.95 : 0;
+        const maxAvailableUsd = maxAvailableTokens * tokenPrice;
+        if (maxAvailableUsd <= MIN_THRESHOLD_USD) {
+          warnings.push(`Skipping deposit to ${dep.token} - insufficient available balance`);
+          continue;
+        }
+        const depositTokenAmount = Math.min(desiredTokens, maxAvailableTokens);
+        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 {
+          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 this.client.earn.earnBundle({
+        owner,
+        chain,
+        gasSponsorship: true,
+        actions: bundleActions
+      });
+      const eip712 = bundleResponse.eip712;
+      if (!eip712) {
+        throw new CompassServiceError("No EIP-712 data returned from bundle API", 500);
+      }
       const types = eip712.types;
       const normalizedTypes = {
         EIP712Domain: types.eip712Domain || types.EIP712Domain,
-        Permit: types.permit || types.Permit
+        SafeTx: types.safeTx || types.SafeTx
       };
-      return jsonResponse({
-        approved: false,
+      return {
         eip712,
         normalizedTypes,
         domain: eip712.domain,
-        message: eip712.message
-      });
-    }
-    return jsonResponse({
-      approved: false,
-      transaction,
-      requiresTransaction: true
-    });
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage.includes("already set") || errorMessage.includes("already been set")) {
-      return jsonResponse({
-        approved: true,
-        message: "Token allowance already set"
-      });
+        message: eip712.message,
+        actions: actionsSummary,
+        actionsCount: bundleActions.length,
+        warnings
+      };
+    } catch (error) {
+      if (error instanceof CompassServiceError) throw error;
+      const message = error instanceof Error ? error.message : "Failed to compute rebalance preview";
+      throw new CompassServiceError(message, 502);
     }
-    throw error;
-  }
-}
-async function handleApprovalExecute(body, config) {
-  const { owner, chain = "base", transaction } = body;
-  const { gasSponsorPrivateKey, rpcUrls } = config;
-  if (!owner || !transaction) {
-    return jsonResponse({ error: "Missing required parameters (owner, transaction)" }, 400);
-  }
-  if (!gasSponsorPrivateKey) {
-    return jsonResponse(
-      { error: "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config." },
-      500
-    );
-  }
-  const viemChain = CHAIN_MAP[chain.toLowerCase()];
-  if (!viemChain) {
-    return jsonResponse({ error: `Unsupported chain: ${chain}` }, 500);
-  }
-  const rpcUrl = rpcUrls?.[chain.toLowerCase()];
-  if (!rpcUrl) {
-    return jsonResponse({ error: `No RPC URL configured for chain: ${chain}` }, 500);
-  }
-  const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
-  const walletClient = viem.createWalletClient({
-    account: sponsorAccount,
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  const publicClient = viem.createPublicClient({
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  const txHash = await walletClient.sendTransaction({
-    to: transaction.to,
-    data: transaction.data,
-    value: transaction.value ? BigInt(transaction.value) : 0n,
-    gas: transaction.gas ? BigInt(transaction.gas) : void 0
-  });
-  const receipt = await publicClient.waitForTransactionReceipt({
-    hash: txHash,
-    timeout: 6e4
-  });
-  if (receipt.status === "reverted") {
-    return jsonResponse({ error: "Approval transaction reverted" }, 500);
   }
-  return jsonResponse({ txHash, status: "success" });
-}
-async function handleTransferPrepare(client, body, config) {
-  const { owner, chain = "base", token, amount, action, product } = body;
-  const { gasSponsorPrivateKey } = config;
-  if (!owner || !token || !amount || !action) {
-    return jsonResponse({ error: "Missing required parameters" }, 400);
+  // --- Credit ---
+  async creditAccountCheck(params) {
+    const { owner, chain = "base" } = params;
+    if (!owner) {
+      throw new CompassServiceError("Missing owner parameter", 400);
+    }
+    const response = await this.client.credit.creditCreateAccount({
+      chain,
+      owner,
+      sender: owner,
+      estimateGas: false
+    });
+    const creditAccountAddress = response.creditAccountAddress;
+    const hasTransaction = !!response.transaction;
+    return {
+      creditAccountAddress,
+      isDeployed: !hasTransaction,
+      needsCreation: hasTransaction
+    };
   }
-  let spender;
-  if (action === "DEPOSIT" && gasSponsorPrivateKey) {
+  async creditCreateAccount(body) {
+    const { owner, chain = "base" } = body;
+    const { gasSponsorPrivateKey, rpcUrls } = this.config;
+    if (!owner) {
+      throw new CompassServiceError("Missing owner parameter", 400);
+    }
+    if (!gasSponsorPrivateKey) {
+      throw new CompassServiceError(
+        "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config.",
+        500
+      );
+    }
+    const viemChain = CHAIN_MAP[chain.toLowerCase()];
+    if (!viemChain) {
+      throw new CompassServiceError(`Unsupported chain: ${chain}`, 500);
+    }
+    const rpcUrl = rpcUrls?.[chain.toLowerCase()];
+    if (!rpcUrl) {
+      throw new CompassServiceError(`No RPC URL configured for chain: ${chain}`, 500);
+    }
     const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
-    spender = sponsorAccount.address;
-  }
-  let response;
-  if (product === "credit") {
-    response = await client.credit.creditTransfer({
-      owner,
-      chain,
-      token,
-      amount,
-      action,
-      gasSponsorship: true,
-      ...spender && { spender }
+    const walletClient = viem.createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
     });
-  } else {
-    response = await client.earn.earnTransfer({
-      owner,
+    const publicClient = viem.createPublicClient({
+      chain: viemChain,
+      transport: viem.http(rpcUrl)
+    });
+    const response = await this.client.credit.creditCreateAccount({
       chain,
-      token,
-      amount,
-      action,
-      gasSponsorship: true,
-      ...spender && { spender }
+      owner,
+      sender: sponsorAccount.address,
+      estimateGas: false
     });
-  }
-  const eip712 = response.eip712;
-  if (!eip712) {
-    return jsonResponse({ error: "No EIP-712 data returned from API" }, 500);
-  }
-  const types = eip712.types;
-  let normalizedTypes;
-  if (action === "DEPOSIT") {
-    normalizedTypes = {
-      EIP712Domain: types.eip712Domain || types.EIP712Domain,
-      PermitTransferFrom: types.permitTransferFrom || types.PermitTransferFrom,
-      TokenPermissions: types.tokenPermissions || types.TokenPermissions
-    };
-  } else {
-    normalizedTypes = {
-      EIP712Domain: types.eip712Domain || types.EIP712Domain,
-      SafeTx: types.safeTx || types.SafeTx
+    const creditAccountAddress = response.creditAccountAddress;
+    if (!response.transaction) {
+      return {
+        creditAccountAddress,
+        success: true,
+        alreadyExists: true
+      };
+    }
+    const transaction = response.transaction;
+    const txHash = await walletClient.sendTransaction({
+      to: transaction.to,
+      data: transaction.data,
+      value: transaction.value ? BigInt(transaction.value) : 0n,
+      gas: transaction.gas ? BigInt(transaction.gas) : void 0
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash
+    });
+    if (receipt.status === "reverted") {
+      throw new CompassServiceError("Account creation transaction reverted", 500);
+    }
+    return {
+      creditAccountAddress,
+      txHash,
+      success: true
     };
   }
-  return jsonResponse({
-    eip712,
-    normalizedTypes,
-    domain: eip712.domain,
-    message: eip712.message,
-    primaryType: eip712.primaryType
-  });
-}
-async function handleTransferExecute(client, body, config) {
-  const { owner, chain = "base", eip712, signature, product } = body;
-  const { gasSponsorPrivateKey, rpcUrls } = config;
-  if (!owner || !eip712 || !signature) {
-    return jsonResponse({ error: "Missing required parameters" }, 400);
-  }
-  if (!gasSponsorPrivateKey) {
-    return jsonResponse(
-      { error: "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config." },
-      500
-    );
-  }
-  const viemChain = CHAIN_MAP[chain.toLowerCase()];
-  if (!viemChain) {
-    return jsonResponse({ error: `Unsupported chain: ${chain}` }, 500);
-  }
-  const rpcUrl = rpcUrls?.[chain.toLowerCase()];
-  if (!rpcUrl) {
-    return jsonResponse({ error: `No RPC URL configured for chain: ${chain}` }, 500);
-  }
-  const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
-  const walletClient = viem.createWalletClient({
-    account: sponsorAccount,
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  const response = await client.gasSponsorship.gasSponsorshipPrepare({
-    chain,
-    owner,
-    sender: sponsorAccount.address,
-    eip712,
-    signature,
-    ...product === "credit" && { product: "credit" }
-  });
-  const transaction = response.transaction;
-  if (!transaction) {
-    return jsonResponse(
-      { error: "No transaction returned from gas sponsorship prepare" },
-      500
-    );
-  }
-  const txHash = await walletClient.sendTransaction({
-    to: transaction.to,
-    data: transaction.data,
-    value: transaction.value ? BigInt(transaction.value) : 0n,
-    gas: transaction.gas ? BigInt(transaction.gas) : void 0
-  });
-  return jsonResponse({ txHash, success: true });
-}
-async function handleEarnAccountBalances(client, params) {
-  const { owner, chain = "base" } = params;
-  if (!owner) {
-    return jsonResponse({ error: "Missing owner parameter" }, 400);
-  }
-  const response = await client.earn.earnBalances({
-    chain,
-    owner
-  });
-  const data = response;
-  const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-  const balances = {};
-  for (const [symbol, tokenData] of Object.entries(data.balances)) {
-    const hasRealTransfers = tokenData.transfers.some((t) => {
-      const fromAddr = (t.from_address || t.fromAddress || "").toLowerCase();
-      const toAddr = (t.to_address || t.toAddress || "").toLowerCase();
-      return fromAddr !== ZERO_ADDRESS && toAddr !== ZERO_ADDRESS;
+  async creditPositions(params) {
+    const { owner, chain = "base" } = params;
+    if (!owner) {
+      throw new CompassServiceError("Missing owner parameter", 400);
+    }
+    const response = await this.client.credit.creditPositions({
+      chain,
+      owner
     });
-    const balanceFormatted = tokenData.balance_formatted || tokenData.balanceFormatted || "0";
-    const balanceNum = parseFloat(balanceFormatted);
-    if (balanceNum === 0 && !hasRealTransfers) {
-      continue;
-    }
-    if (!hasRealTransfers && tokenData.transfers.length > 0) {
-      continue;
-    }
-    const usdValue = tokenData.usd_value || tokenData.usdValue || "0";
-    const usdValueNum = parseFloat(usdValue);
-    if (usdValueNum === 0 || isNaN(usdValueNum)) {
-      continue;
-    }
-    balances[symbol] = {
-      balance: balanceFormatted,
-      usdValue
-    };
+    return response;
   }
-  const earnAccountAddr = data.earn_account_address || data.earnAccountAddress || "";
-  const totalUsd = data.total_usd_value || data.totalUsdValue || "0";
-  return jsonResponse({
-    earnAccountAddress: earnAccountAddr,
-    balances,
-    totalUsdValue: totalUsd
-  });
-}
-async function handleSwapQuote(client, params) {
-  const { owner, chain = "base", tokenIn, tokenOut, amountIn } = params;
-  if (!owner || !tokenIn || !tokenOut || !amountIn) {
-    return jsonResponse({ error: "Missing required parameters: owner, tokenIn, tokenOut, amountIn" }, 400);
+  async creditBalances(params) {
+    const { owner, chain = "base" } = params;
+    if (!owner) {
+      throw new CompassServiceError("Missing owner parameter", 400);
+    }
+    const tokens = CREDIT_TOKENS[chain.toLowerCase()] || CREDIT_TOKENS["base"];
+    const balances = await Promise.allSettled(
+      tokens.map(async (token) => {
+        const response = await this.client.token.tokenBalance({
+          chain,
+          token,
+          user: owner
+        });
+        return {
+          tokenSymbol: token,
+          amount: response.amount || "0",
+          decimals: response.decimals || 18,
+          tokenAddress: response.tokenAddress || ""
+        };
+      })
+    );
+    const result = balances.filter((b) => b.status === "fulfilled").map((b) => b.value);
+    return result;
   }
-  try {
-    const response = await client.earn.earnSwap({
+  async creditBundlePrepare(body) {
+    const { owner, chain = "base", actions } = body;
+    if (!owner || !actions || actions.length === 0) {
+      throw new CompassServiceError("Missing owner or actions", 400);
+    }
+    const wrappedActions = actions.map((action) => ({ body: action }));
+    const response = await this.client.credit.creditBundle({
       owner,
       chain,
-      tokenIn,
-      tokenOut,
-      amountIn,
-      slippage: 1,
-      gasSponsorship: true
-    });
-    const estimatedAmountOut = response.estimatedAmountOut || "0";
-    return jsonResponse({
-      tokenIn,
-      tokenOut,
-      amountIn,
-      estimatedAmountOut: estimatedAmountOut?.toString() || "0"
+      gasSponsorship: true,
+      actions: wrappedActions
     });
-  } catch (error) {
-    let errorMessage = "Failed to get swap quote";
-    try {
-      const bodyMessage = error?.body?.message || error?.message || "";
-      if (bodyMessage.includes("{")) {
-        const jsonMatch = bodyMessage.match(/\{.*\}/s);
-        if (jsonMatch) {
-          const parsed = JSON.parse(jsonMatch[0]);
-          errorMessage = parsed.description || parsed.error || parsed.message || errorMessage;
-        }
-      } else if (bodyMessage) {
-        const balanceMatch = bodyMessage.match(/Insufficient \w+ balance[^.]+/i);
-        if (balanceMatch) {
-          errorMessage = balanceMatch[0];
-        } else {
-          errorMessage = bodyMessage;
-        }
-      }
-    } catch {
-      errorMessage = error?.body?.error || error?.message || "Failed to get swap quote";
+    const eip712 = response.eip712;
+    if (!eip712) {
+      throw new CompassServiceError("No EIP-712 data returned from API", 500);
     }
-    return jsonResponse({
-      error: "Swap quote failed",
-      message: errorMessage
-    }, 400);
-  }
-}
-async function handleSwapPrepare(client, body) {
-  const { owner, chain = "base", tokenIn, tokenOut, amountIn, slippage = 1 } = body;
-  if (!owner || !tokenIn || !tokenOut || !amountIn) {
-    return jsonResponse({ error: "Missing required parameters: owner, tokenIn, tokenOut, amountIn" }, 400);
+    const types = eip712.types;
+    const normalizedTypes = {
+      EIP712Domain: types.eip712Domain || types.EIP712Domain,
+      SafeTx: types.safeTx || types.SafeTx
+    };
+    return {
+      eip712,
+      normalizedTypes,
+      domain: eip712.domain,
+      message: eip712.message,
+      actionsCount: response.actionsCount || actions.length
+    };
   }
-  try {
-    const response = await client.earn.earnSwap({
+  async creditTransfer(body) {
+    const { owner, chain = "base", token, amount } = body;
+    if (!owner || !token || !amount) {
+      throw new CompassServiceError("Missing required parameters", 400);
+    }
+    const response = await this.client.credit.creditTransfer({
       owner,
       chain,
-      tokenIn,
-      tokenOut,
-      amountIn,
-      slippage,
+      token,
+      amount,
+      action: "DEPOSIT",
       gasSponsorship: true
     });
     const eip712 = response.eip712;
     if (!eip712) {
-      return jsonResponse({ error: "No EIP-712 data returned from API" }, 500);
+      throw new CompassServiceError("No EIP-712 data returned from API", 500);
     }
     const types = eip712.types;
     const normalizedTypes = {
-      EIP712Domain: types.eip712Domain || types.EIP712Domain,
-      SafeTx: types.safeTx || types.SafeTx
+      EIP712Domain: types.eip712Domain || types.EIP712Domain
     };
-    return jsonResponse({
+    if (types.permitTransferFrom || types.PermitTransferFrom) {
+      normalizedTypes.PermitTransferFrom = types.permitTransferFrom || types.PermitTransferFrom;
+    }
+    if (types.tokenPermissions || types.TokenPermissions) {
+      normalizedTypes.TokenPermissions = types.tokenPermissions || types.TokenPermissions;
+    }
+    if (types.safeTx || types.SafeTx) {
+      normalizedTypes.SafeTx = types.safeTx || types.SafeTx;
+    }
+    return {
       eip712,
       normalizedTypes,
       domain: eip712.domain,
       message: eip712.message,
-      estimatedAmountOut: response.estimatedAmountOut?.toString() || "0"
-    });
-  } catch (error) {
-    return jsonResponse({
-      error: error instanceof Error ? error.message : "Failed to prepare swap"
-    }, 500);
-  }
-}
-async function handleSwapExecute(client, body, config) {
-  const { owner, chain = "base", eip712, signature } = body;
-  if (!owner || !eip712 || !signature) {
-    return jsonResponse({ error: "Missing required parameters: owner, eip712, signature" }, 400);
-  }
-  if (!config.gasSponsorPrivateKey) {
-    return jsonResponse({ error: "Gas sponsor not configured" }, 500);
-  }
-  const rpcUrl = config.rpcUrls?.[chain];
-  if (!rpcUrl) {
-    return jsonResponse({ error: `No RPC URL configured for chain: ${chain}` }, 500);
+      primaryType: eip712.primaryType
+    };
   }
-  try {
-    const viemChain = CHAIN_MAP[chain];
+  async creditExecute(body) {
+    const { owner, eip712, signature, chain = "base" } = body;
+    const { gasSponsorPrivateKey, rpcUrls } = this.config;
+    if (!owner || !eip712 || !signature) {
+      throw new CompassServiceError("Missing required parameters (owner, eip712, signature)", 400);
+    }
+    if (!gasSponsorPrivateKey) {
+      throw new CompassServiceError(
+        "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config.",
+        500
+      );
+    }
+    const viemChain = CHAIN_MAP[chain.toLowerCase()];
     if (!viemChain) {
-      return jsonResponse({ error: `Unsupported chain: ${chain}` }, 400);
+      throw new CompassServiceError(`Unsupported chain: ${chain}`, 500);
+    }
+    const rpcUrl = rpcUrls?.[chain.toLowerCase()];
+    if (!rpcUrl) {
+      throw new CompassServiceError(`No RPC URL configured for chain: ${chain}`, 500);
     }
-    const sponsorAccount = accounts.privateKeyToAccount(config.gasSponsorPrivateKey);
+    const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
     const walletClient = viem.createWalletClient({
       account: sponsorAccount,
       chain: viemChain,
@@ -673,16 +1399,20 @@ async function handleSwapExecute(client, body, config) {
       chain: viemChain,
       transport: viem.http(rpcUrl)
     });
-    const response = await client.gasSponsorship.gasSponsorshipPrepare({
+    const response = await this.client.gasSponsorship.gasSponsorshipPrepare({
       chain,
       owner,
       sender: sponsorAccount.address,
       eip712,
-      signature
+      signature,
+      product: "credit"
     });
     const transaction = response.transaction;
     if (!transaction) {
-      return jsonResponse({ error: "No transaction returned from gas sponsorship prepare" }, 500);
+      throw new CompassServiceError(
+        "No transaction returned from gas sponsorship prepare",
+        500
+      );
     }
     const txHash = await walletClient.sendTransaction({
       to: transaction.to,
@@ -694,851 +1424,158 @@ async function handleSwapExecute(client, body, config) {
       hash: txHash
     });
     if (receipt.status === "reverted") {
-      return jsonResponse({ error: "Transaction reverted" }, 500);
+      throw new CompassServiceError("Transaction reverted", 500);
     }
-    return jsonResponse({ txHash, success: true });
-  } catch (error) {
-    return jsonResponse({
-      error: error instanceof Error ? error.message : "Failed to execute swap"
-    }, 500);
+    return { txHash, success: true };
   }
-}
-async function handleTokenBalance(client, params) {
-  const { chain = "base", token, address } = params;
-  if (!token || !address) {
-    return jsonResponse({ error: "Missing token or address parameter" }, 400);
+};
+
+// src/server/core/utils.ts
+function extractErrorMessage(error) {
+  if (!(error instanceof Error)) {
+    return { message: "Something went wrong. Please try again.", status: 500 };
   }
-  try {
-    const response = await client.token.tokenBalance({
-      chain,
-      token,
-      user: address
-    });
-    return jsonResponse({
-      token,
-      address,
-      balance: response.amount || "0",
-      balanceRaw: response.balanceRaw || "0"
-    });
-  } catch (error) {
-    return jsonResponse({
-      token,
-      address,
-      balance: "0",
-      balanceRaw: "0"
-    });
+  const raw = error.message || "";
+  const jsonMatch = raw.match(/Body:\s*(\{[\s\S]*\})/);
+  if (jsonMatch) {
+    try {
+      const body = JSON.parse(jsonMatch[1]);
+      if (Array.isArray(body.detail)) {
+        const msgs = body.detail.map((d) => d.msg || d.message).filter(Boolean);
+        if (msgs.length > 0) return { message: msgs.join(". "), status: 422 };
+      }
+      if (typeof body.detail === "string") return { message: body.detail, status: 422 };
+      if (typeof body.error === "string") return { message: body.error, status: 500 };
+      if (typeof body.description === "string") return { message: body.description, status: 500 };
+    } catch {
+    }
   }
-}
-async function handleTokenPrices(client, params) {
-  const { chain = "base", tokens } = params;
-  if (!tokens) {
-    return jsonResponse({ error: "Missing tokens parameter" }, 400);
+  if (error.name === "SDKValidationError" || raw.startsWith("Input validation failed")) {
+    return { message: "Invalid request data. Please check your inputs and try again.", status: 400 };
   }
-  const tokenList = tokens.split(",").map((t) => t.trim().toUpperCase());
-  const prices = {};
-  const results = await Promise.allSettled(
-    tokenList.map(async (symbol) => {
-      const resp = await client.token.tokenPrice({ chain, token: symbol });
-      return { symbol, price: parseFloat(resp.price || "0") };
-    })
-  );
-  for (const result of results) {
-    if (result.status === "fulfilled" && result.value.price > 0) {
-      prices[result.value.symbol] = result.value.price;
+  const knownPatterns = ["Insufficient", "not deployed", "reverted", "not configured", "Unsupported chain"];
+  const lines = raw.split("\n");
+  for (const pattern of knownPatterns) {
+    const matchingLine = lines.find((line) => line.includes(pattern));
+    if (matchingLine) {
+      return { message: matchingLine.trim(), status: 500 };
     }
   }
-  return jsonResponse({ prices });
+  return { message: "Something went wrong. Please try again.", status: 500 };
 }
-async function handleBundlePrepare(client, body) {
-  const { owner, chain = "base", actions } = body;
-  if (!owner || !actions || actions.length === 0) {
-    return jsonResponse({ error: "Missing owner or actions" }, 400);
-  }
-  const response = await client.earn.earnBundle({
-    owner,
-    chain,
-    gasSponsorship: true,
-    actions
-  });
-  const eip712 = response.eip712;
-  if (!eip712) {
-    return jsonResponse({ error: "No EIP-712 data returned from 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,
-    actionsCount: response.actionsCount || actions.length
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
   });
 }
-async function handleBundleExecute(client, body, config) {
-  return handleTransferExecute(client, body, config);
-}
-async function handleVaults(client, params) {
-  const { chain = "base", orderBy = "apy_7d", direction = "desc", limit = "100", assetSymbol, minTvlUsd } = params;
-  try {
-    const response = await client.earn.earnVaults({
-      chain,
-      orderBy,
-      direction,
-      limit: parseInt(limit, 10),
-      ...assetSymbol && { assetSymbol },
-      ...minTvlUsd && { minTvlUsd: parseFloat(minTvlUsd) }
-    });
-    return jsonResponse(response);
-  } catch (error) {
-    return jsonResponse({ error: "Failed to fetch vaults" }, 500);
-  }
-}
-async function handleAaveMarkets(client, params) {
-  const { chain = "base" } = params;
-  try {
-    const response = await client.earn.earnAaveMarkets({
-      chain
-    });
-    return jsonResponse(response);
-  } catch (error) {
-    return jsonResponse({ error: "Failed to fetch Aave markets" }, 500);
-  }
-}
-async function handlePendleMarkets(client, params) {
-  const { chain = "base", orderBy = "implied_apy", direction = "desc", limit = "100", underlyingSymbol, minTvlUsd } = params;
-  try {
-    const response = await client.earn.earnPendleMarkets({
-      chain,
-      orderBy,
-      direction,
-      limit: parseInt(limit, 10),
-      ...underlyingSymbol && { underlyingSymbol },
-      ...minTvlUsd && { minTvlUsd: parseFloat(minTvlUsd) }
-    });
-    return jsonResponse(response);
-  } catch (error) {
-    return jsonResponse({ error: "Failed to fetch Pendle markets" }, 500);
-  }
-}
-async function handlePositions(client, params) {
-  const { chain = "base", owner } = params;
-  if (!owner) {
-    return jsonResponse({ error: "Missing owner parameter" }, 400);
-  }
-  try {
-    const positionsResponse = await client.earn.earnPositions({
-      chain,
-      owner
-    });
-    const raw = JSON.parse(JSON.stringify(positionsResponse));
-    const positions = [];
-    const aavePositions = raw.aave || [];
-    for (const a of aavePositions) {
-      const balance = a.balance || "0";
-      const symbol = (a.reserveSymbol || a.reserve_symbol || "UNKNOWN").toUpperCase();
-      const pnl = a.pnl;
-      positions.push({
-        protocol: "aave",
-        symbol,
-        name: `${symbol} on Aave`,
-        balance,
-        balanceUsd: a.usdValue || a.usd_value || balance,
-        apy: parseFloat(a.apy || "0"),
-        pnl: pnl ? {
-          unrealizedPnl: pnl.unrealizedPnl ?? pnl.unrealized_pnl ?? "0",
-          realizedPnl: pnl.realizedPnl ?? pnl.realized_pnl ?? "0",
-          totalPnl: pnl.totalPnl ?? pnl.total_pnl ?? "0",
-          totalDeposited: pnl.totalDeposited ?? pnl.total_deposited ?? "0"
-        } : null,
-        deposits: (a.deposits || []).map((d) => ({
-          amount: d.inputAmount || d.input_amount || d.amount || "0",
-          blockNumber: d.blockNumber || d.block_number || 0,
-          timestamp: d.blockTimestamp || d.block_timestamp || void 0,
-          txHash: d.transactionHash || d.transaction_hash || d.txHash || ""
-        })),
-        withdrawals: (a.withdrawals || []).map((w) => ({
-          amount: w.outputAmount || w.output_amount || w.amount || "0",
-          blockNumber: w.blockNumber || w.block_number || 0,
-          timestamp: w.blockTimestamp || w.block_timestamp || void 0,
-          txHash: w.transactionHash || w.transaction_hash || w.txHash || ""
-        }))
-      });
-    }
-    const vaultPositions = raw.vaults || [];
-    for (const v of vaultPositions) {
-      const balance = v.balance || "0";
-      const symbol = (v.underlyingSymbol || v.underlying_symbol || "TOKEN").toUpperCase();
-      const vaultName = v.vaultName || v.vault_name || `${symbol} Vault`;
-      const pnl = v.pnl;
-      positions.push({
-        protocol: "vaults",
-        symbol,
-        name: vaultName,
-        balance,
-        balanceUsd: v.usdValue || v.usd_value || balance,
-        apy: parseFloat(v.apy7d || v.apy_7d || "0"),
-        vaultAddress: v.vaultAddress || v.vault_address || void 0,
-        pnl: pnl ? {
-          unrealizedPnl: pnl.unrealizedPnl ?? pnl.unrealized_pnl ?? "0",
-          realizedPnl: pnl.realizedPnl ?? pnl.realized_pnl ?? "0",
-          totalPnl: pnl.totalPnl ?? pnl.total_pnl ?? "0",
-          totalDeposited: pnl.totalDeposited ?? pnl.total_deposited ?? "0"
-        } : null,
-        deposits: (v.deposits || []).map((d) => ({
-          amount: d.inputAmount || d.input_amount || d.amount || "0",
-          blockNumber: d.blockNumber || d.block_number || 0,
-          timestamp: d.blockTimestamp || d.block_timestamp || void 0,
-          txHash: d.transactionHash || d.transaction_hash || d.txHash || ""
-        })),
-        withdrawals: (v.withdrawals || []).map((w) => ({
-          amount: w.outputAmount || w.output_amount || w.amount || "0",
-          blockNumber: w.blockNumber || w.block_number || 0,
-          timestamp: w.blockTimestamp || w.block_timestamp || void 0,
-          txHash: w.transactionHash || w.transaction_hash || w.txHash || ""
-        }))
-      });
-    }
-    const pendlePositions = raw.pendlePt || raw.pendle_pt || [];
-    for (const p of pendlePositions) {
-      const balance = p.ptBalance || p.pt_balance || p.balance || "0";
-      const symbol = (p.underlyingSymbol || p.underlying_symbol || "PT").toUpperCase();
-      const pnl = p.pnl;
-      positions.push({
-        protocol: "pendle",
-        symbol,
-        name: `PT-${symbol}`,
-        balance,
-        balanceUsd: p.usdValue || p.usd_value || balance,
-        apy: parseFloat(p.impliedApy || p.implied_apy || "0"),
-        marketAddress: p.marketAddress || p.market_address || void 0,
-        pnl: pnl ? {
-          unrealizedPnl: pnl.unrealizedPnl ?? pnl.unrealized_pnl ?? "0",
-          realizedPnl: pnl.realizedPnl ?? pnl.realized_pnl ?? "0",
-          totalPnl: pnl.totalPnl ?? pnl.total_pnl ?? "0",
-          totalDeposited: pnl.totalDeposited ?? pnl.total_deposited ?? "0"
-        } : null,
-        deposits: (p.deposits || []).map((d) => ({
-          amount: d.inputAmount || d.input_amount || d.amount || "0",
-          blockNumber: d.blockNumber || d.block_number || 0,
-          timestamp: d.blockTimestamp || d.block_timestamp || void 0,
-          txHash: d.transactionHash || d.transaction_hash || d.txHash || ""
-        })),
-        withdrawals: (p.withdrawals || []).map((w) => ({
-          amount: w.outputAmount || w.output_amount || w.amount || "0",
-          blockNumber: w.blockNumber || w.block_number || 0,
-          timestamp: w.blockTimestamp || w.block_timestamp || void 0,
-          txHash: w.transactionHash || w.transaction_hash || w.txHash || ""
-        }))
-      });
-    }
-    return jsonResponse({ positions });
-  } catch (error) {
-    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 allTokenSymbols = /* @__PURE__ */ new Set();
-    for (const pos of currentPositions) allTokenSymbols.add(pos.token.toUpperCase());
-    for (const t of targets) if (t.token) allTokenSymbols.add(t.token.toUpperCase());
-    for (const sym of Object.keys(balancesRaw.balances || {})) allTokenSymbols.add(sym.toUpperCase());
-    const tokenPrices = {};
-    const priceResults = await Promise.allSettled(
-      [...allTokenSymbols].map(async (symbol) => {
-        const resp = await client.token.tokenPrice({ chain, token: symbol });
-        return { symbol, price: parseFloat(resp.price || "0") };
-      })
-    );
-    for (const result of priceResults) {
-      if (result.status === "fulfilled" && result.value.price > 0) {
-        tokenPrices[result.value.symbol] = result.value.price;
-      }
-    }
-    const bundleActions = [];
-    const actionsSummary = [];
-    const warnings = [];
-    const MIN_THRESHOLD_USD = 0.01;
-    const CHANGE_THRESHOLD_PCT = 0.1;
-    const pendingDeposits = [];
-    for (const target of targets) {
-      const originalPct = target.originalPercent ?? target.targetPercent;
-      if (Math.abs(target.targetPercent - originalPct) <= CHANGE_THRESHOLD_PCT) continue;
-      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 });
+
+// src/server/nextjs/handler.ts
+function createCompassHandler(config) {
+  const service = new CompassCoreService(config);
+  return async function handler(request, context) {
+    try {
+      const { path } = await context.params;
+      const route = path.join("/");
+      const method = request.method;
+      if (method === "GET") {
+        const url = new URL(request.url);
+        const params = Object.fromEntries(url.searchParams.entries());
+        const data = await routeGet(service, route, params);
+        return jsonResponse(data);
       }
-    }
-    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 };
+      if (method === "POST") {
+        let body;
+        try {
+          body = await request.json();
+        } catch {
+          return jsonResponse({ error: "Invalid JSON in request body" }, 400);
         }
-        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);
+        const data = await routePost(service, route, body);
+        return jsonResponse(data);
       }
-    }
-    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_formatted || td.balanceFormatted || "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 : tokenPrices[sourceToken] ? swapUsd / tokenPrices[sourceToken] : 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 : tokenPrices[depositToken] || 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 : tokenPrices[key] || 1;
-      const desiredTokens = dep.deltaUsd / tokenPrice;
-      const maxAvailableTokens = available ? available.tokenAmount * 0.95 : 0;
-      if (maxAvailableTokens <= MIN_THRESHOLD_USD) {
-        warnings.push(`Skipping deposit to ${dep.token} - insufficient available balance`);
-        continue;
-      }
-      const depositTokenAmount = Math.min(desiredTokens, maxAvailableTokens);
-      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;
+      return jsonResponse({ error: `Method ${method} not allowed` }, 405);
+    } catch (error) {
+      if (error instanceof CompassServiceError) {
+        return jsonResponse({ error: error.message }, error.statusCode);
       }
+      const { message, status } = extractErrorMessage(error);
+      return jsonResponse({ error: message }, status);
     }
-    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);
-  }
-}
-var CREDIT_TOKENS = {
-  base: ["USDC", "WETH", "USDT", "DAI", "WBTC"],
-  ethereum: ["USDC", "WETH", "USDT", "DAI", "WBTC"],
-  arbitrum: ["USDC", "WETH", "USDT", "DAI", "WBTC"]
-};
-async function handleCreditAccountCheck(client, params) {
-  const { owner, chain = "base" } = params;
-  if (!owner) {
-    return jsonResponse({ error: "Missing owner parameter" }, 400);
-  }
-  const response = await client.credit.creditCreateAccount({
-    chain,
-    owner,
-    sender: owner,
-    estimateGas: false
-  });
-  const creditAccountAddress = response.creditAccountAddress;
-  const hasTransaction = !!response.transaction;
-  return jsonResponse({
-    creditAccountAddress,
-    isDeployed: !hasTransaction,
-    needsCreation: hasTransaction
-  });
-}
-async function handleCreditCreateAccount(client, body, config) {
-  const { owner, chain = "base" } = body;
-  const { gasSponsorPrivateKey, rpcUrls } = config;
-  if (!owner) {
-    return jsonResponse({ error: "Missing owner parameter" }, 400);
-  }
-  if (!gasSponsorPrivateKey) {
-    return jsonResponse(
-      { error: "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config." },
-      500
-    );
-  }
-  const viemChain = CHAIN_MAP[chain.toLowerCase()];
-  if (!viemChain) {
-    return jsonResponse({ error: `Unsupported chain: ${chain}` }, 500);
-  }
-  const rpcUrl = rpcUrls?.[chain.toLowerCase()];
-  if (!rpcUrl) {
-    return jsonResponse({ error: `No RPC URL configured for chain: ${chain}` }, 500);
-  }
-  const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
-  const walletClient = viem.createWalletClient({
-    account: sponsorAccount,
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  const publicClient = viem.createPublicClient({
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  const response = await client.credit.creditCreateAccount({
-    chain,
-    owner,
-    sender: sponsorAccount.address,
-    estimateGas: false
-  });
-  const creditAccountAddress = response.creditAccountAddress;
-  if (!response.transaction) {
-    return jsonResponse({
-      creditAccountAddress,
-      success: true,
-      alreadyExists: true
-    });
-  }
-  const transaction = response.transaction;
-  const txHash = await walletClient.sendTransaction({
-    to: transaction.to,
-    data: transaction.data,
-    value: transaction.value ? BigInt(transaction.value) : 0n,
-    gas: transaction.gas ? BigInt(transaction.gas) : void 0
-  });
-  const receipt = await publicClient.waitForTransactionReceipt({
-    hash: txHash
-  });
-  if (receipt.status === "reverted") {
-    return jsonResponse({ error: "Account creation transaction reverted" }, 500);
-  }
-  return jsonResponse({
-    creditAccountAddress,
-    txHash,
-    success: true
-  });
-}
-async function handleCreditPositions(client, params) {
-  const { owner, chain = "base" } = params;
-  if (!owner) {
-    return jsonResponse({ error: "Missing owner parameter" }, 400);
-  }
-  const response = await client.credit.creditPositions({
-    chain,
-    owner
-  });
-  return jsonResponse(response);
-}
-async function handleCreditBalances(client, params) {
-  const { owner, chain = "base" } = params;
-  if (!owner) {
-    return jsonResponse({ error: "Missing owner parameter" }, 400);
-  }
-  const tokens = CREDIT_TOKENS[chain.toLowerCase()] || CREDIT_TOKENS["base"];
-  const balances = await Promise.allSettled(
-    tokens.map(async (token) => {
-      const response = await client.token.tokenBalance({
-        chain,
-        token,
-        user: owner
-      });
-      return {
-        tokenSymbol: token,
-        amount: response.amount || "0",
-        decimals: response.decimals || 18,
-        tokenAddress: response.tokenAddress || ""
-      };
-    })
-  );
-  const result = balances.filter((b) => b.status === "fulfilled").map((b) => b.value);
-  return jsonResponse(result);
-}
-async function handleCreditBundlePrepare(client, body) {
-  const { owner, chain = "base", actions } = body;
-  if (!owner || !actions || actions.length === 0) {
-    return jsonResponse({ error: "Missing owner or actions" }, 400);
-  }
-  const wrappedActions = actions.map((action) => ({ body: action }));
-  const response = await client.credit.creditBundle({
-    owner,
-    chain,
-    gasSponsorship: true,
-    actions: wrappedActions
-  });
-  const eip712 = response.eip712;
-  if (!eip712) {
-    return jsonResponse({ error: "No EIP-712 data returned from 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,
-    actionsCount: response.actionsCount || actions.length
-  });
-}
-async function handleCreditTransfer(client, body) {
-  const { owner, chain = "base", token, amount } = body;
-  if (!owner || !token || !amount) {
-    return jsonResponse({ error: "Missing required parameters" }, 400);
-  }
-  const response = await client.credit.creditTransfer({
-    owner,
-    chain,
-    token,
-    amount,
-    action: "DEPOSIT",
-    gasSponsorship: true
-  });
-  const eip712 = response.eip712;
-  if (!eip712) {
-    return jsonResponse({ error: "No EIP-712 data returned from API" }, 500);
-  }
-  const types = eip712.types;
-  const normalizedTypes = {
-    EIP712Domain: types.eip712Domain || types.EIP712Domain
   };
-  if (types.permitTransferFrom || types.PermitTransferFrom) {
-    normalizedTypes.PermitTransferFrom = types.permitTransferFrom || types.PermitTransferFrom;
-  }
-  if (types.tokenPermissions || types.TokenPermissions) {
-    normalizedTypes.TokenPermissions = types.tokenPermissions || types.TokenPermissions;
-  }
-  if (types.safeTx || types.SafeTx) {
-    normalizedTypes.SafeTx = types.safeTx || types.SafeTx;
-  }
-  return jsonResponse({
-    eip712,
-    normalizedTypes,
-    domain: eip712.domain,
-    message: eip712.message,
-    primaryType: eip712.primaryType
-  });
 }
-async function handleCreditExecute(client, body, config) {
-  const { owner, eip712, signature, chain = "base" } = body;
-  const { gasSponsorPrivateKey, rpcUrls } = config;
-  if (!owner || !eip712 || !signature) {
-    return jsonResponse({ error: "Missing required parameters (owner, eip712, signature)" }, 400);
-  }
-  if (!gasSponsorPrivateKey) {
-    return jsonResponse(
-      { error: "Gas sponsor not configured. Set gasSponsorPrivateKey in handler config." },
-      500
-    );
+function routeGet(service, route, params) {
+  switch (route) {
+    case "earn-account/check":
+      return service.earnAccountCheck(params);
+    case "earn-account/balances":
+      return service.earnAccountBalances(params);
+    case "swap/quote":
+      return service.swapQuote(params);
+    case "token/balance":
+      return service.tokenBalance(params);
+    case "token/prices":
+      return service.tokenPrices(params);
+    case "vaults":
+      return service.vaults(params);
+    case "aave/markets":
+      return service.aaveMarkets(params);
+    case "pendle/markets":
+      return service.pendleMarkets(params);
+    case "positions":
+      return service.positions(params);
+    case "credit-account/check":
+      return service.creditAccountCheck(params);
+    case "credit/positions":
+      return service.creditPositions(params);
+    case "credit/balances":
+      return service.creditBalances(params);
+    case "tx/receipt":
+      return service.txReceipt(params);
+    default:
+      throw new CompassServiceError(`Unknown GET route: ${route}`, 404);
   }
-  const viemChain = CHAIN_MAP[chain.toLowerCase()];
-  if (!viemChain) {
-    return jsonResponse({ error: `Unsupported chain: ${chain}` }, 500);
-  }
-  const rpcUrl = rpcUrls?.[chain.toLowerCase()];
-  if (!rpcUrl) {
-    return jsonResponse({ error: `No RPC URL configured for chain: ${chain}` }, 500);
-  }
-  const sponsorAccount = accounts.privateKeyToAccount(gasSponsorPrivateKey);
-  const walletClient = viem.createWalletClient({
-    account: sponsorAccount,
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  const publicClient = viem.createPublicClient({
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  const response = await client.gasSponsorship.gasSponsorshipPrepare({
-    chain,
-    owner,
-    sender: sponsorAccount.address,
-    eip712,
-    signature,
-    product: "credit"
-  });
-  const transaction = response.transaction;
-  if (!transaction) {
-    return jsonResponse(
-      { error: "No transaction returned from gas sponsorship prepare" },
-      500
-    );
-  }
-  const txHash = await walletClient.sendTransaction({
-    to: transaction.to,
-    data: transaction.data,
-    value: transaction.value ? BigInt(transaction.value) : 0n,
-    gas: transaction.gas ? BigInt(transaction.gas) : void 0
-  });
-  const receipt = await publicClient.waitForTransactionReceipt({
-    hash: txHash
-  });
-  if (receipt.status === "reverted") {
-    return jsonResponse({ error: "Transaction reverted" }, 500);
-  }
-  return jsonResponse({ txHash, success: true });
 }
-async function handleTxReceipt(params, config) {
-  const { hash, chain } = params;
-  if (!hash || !chain) {
-    return jsonResponse({ error: "Missing hash or chain parameter" }, 400);
-  }
-  const rpcUrl = config.rpcUrls?.[chain.toLowerCase()];
-  const viemChain = CHAIN_MAP[chain.toLowerCase()];
-  if (!viemChain) {
-    return jsonResponse({ error: `Unsupported chain: ${chain}` }, 400);
-  }
-  if (!rpcUrl) {
-    return jsonResponse({ error: `No RPC URL configured for chain: ${chain}` }, 500);
-  }
-  const publicClient = viem.createPublicClient({
-    chain: viemChain,
-    transport: viem.http(rpcUrl)
-  });
-  try {
-    const receipt = await publicClient.getTransactionReceipt({
-      hash
-    });
-    return jsonResponse({
-      status: receipt.status,
-      blockNumber: receipt.blockNumber.toString()
-    });
-  } catch {
-    return jsonResponse({ status: "pending" });
+function routePost(service, route, body) {
+  switch (route) {
+    case "create-account":
+      return service.createAccount(body);
+    case "deposit/prepare":
+      return service.managePrepare(body, "DEPOSIT");
+    case "deposit/execute":
+      return service.execute(body);
+    case "withdraw/prepare":
+      return service.managePrepare(body, "WITHDRAW");
+    case "withdraw/execute":
+      return service.execute(body);
+    case "transfer/approve":
+      return service.transferApprove(body);
+    case "transfer/prepare":
+      return service.transferPrepare(body);
+    case "transfer/execute":
+      return service.transferExecute(body);
+    case "bundle/prepare":
+      return service.bundlePrepare(body);
+    case "bundle/execute":
+      return service.bundleExecute(body);
+    case "swap/prepare":
+      return service.swapPrepare(body);
+    case "swap/execute":
+      return service.swapExecute(body);
+    case "rebalance/preview":
+      return service.rebalancePreview(body);
+    case "credit-account/create":
+      return service.creditCreateAccount(body);
+    case "credit/bundle/prepare":
+      return service.creditBundlePrepare(body);
+    case "credit/bundle/execute":
+      return service.creditExecute(body);
+    case "credit/transfer":
+      return service.creditTransfer(body);
+    case "approval/execute":
+      return service.approvalExecute(body);
+    default:
+      throw new CompassServiceError(`Unknown POST route: ${route}`, 404);
   }
 }