@compass-labs/widgets 0.1.42 → 0.1.43

package/dist/server/nestjs/index.mjs

@@ -0,0 +1,1837 @@
+import { Injectable, Inject, Catch, Get, Query, HttpCode, Post, Body, Controller, UseFilters, Module, HttpException } from '@nestjs/common';
+import { CompassApiSDK } from '@compass-labs/api-sdk';
+import { createWalletClient, http, createPublicClient } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { arbitrum, base, mainnet } from 'viem/chains';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+var CHAIN_MAP = {
+  ethereum: mainnet,
+  base,
+  arbitrum
+};
+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 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 (!hasRealTransfers && td.transfers.length > 0) {
+        continue;
+      }
+      const usdValue = td.usd_value || td.usdValue || "0";
+      const usdValueNum = parseFloat(usdValue);
+      if (usdValueNum === 0 || isNaN(usdValueNum)) {
+        continue;
+      }
+      balances[symbol] = {
+        balance: balanceFormatted,
+        usdValue
+      };
+    }
+    const earnAccountAddr = data.earn_account_address || data.earnAccountAddress || "";
+    const totalUsd = data.total_usd_value || data.totalUsdValue || "0";
+    return {
+      earnAccountAddress: earnAccountAddr,
+      balances,
+      totalUsdValue: totalUsd
+    };
+  }
+  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 = privateKeyToAccount(gasSponsorPrivateKey);
+    const walletClient = createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: http(rpcUrl)
+    });
+    const publicClient = createPublicClient({
+      chain: viemChain,
+      transport: 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
+    };
+  }
+  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
+    };
+  }
+  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 = privateKeyToAccount(gasSponsorPrivateKey);
+    const walletClient = createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: 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 };
+  }
+  // --- 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;
+    }
+  }
+  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 = 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
+    };
+  }
+  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 = privateKeyToAccount(gasSponsorPrivateKey);
+    const walletClient = createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: 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 };
+  }
+  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 = privateKeyToAccount(gasSponsorPrivateKey);
+    const walletClient = createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: http(rpcUrl)
+    });
+    const publicClient = createPublicClient({
+      chain: viemChain,
+      transport: 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" };
+  }
+  // --- 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);
+    }
+  }
+  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"
+    };
+  }
+  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 = privateKeyToAccount(this.config.gasSponsorPrivateKey);
+    const walletClient = createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: http(rpcUrl)
+    });
+    const publicClient = createPublicClient({
+      chain: viemChain,
+      transport: 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 };
+  }
+  // --- 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
+    };
+    return {
+      eip712,
+      normalizedTypes,
+      domain: eip712.domain,
+      message: eip712.message,
+      actionsCount: response.actionsCount || actions.length
+    };
+  }
+  async bundleExecute(body) {
+    return this.transferExecute(body);
+  }
+  // --- 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);
+    }
+  }
+  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);
+    }
+  }
+  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);
+    }
+  }
+  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);
+    }
+  }
+  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 = createPublicClient({
+      chain: viemChain,
+      transport: http(rpcUrl)
+    });
+    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);
+      }
+    }
+    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,
+        SafeTx: types.safeTx || types.SafeTx
+      };
+      return {
+        eip712,
+        normalizedTypes,
+        domain: eip712.domain,
+        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);
+    }
+  }
+  // --- 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
+    };
+  }
+  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 = privateKeyToAccount(gasSponsorPrivateKey);
+    const walletClient = createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: http(rpcUrl)
+    });
+    const publicClient = createPublicClient({
+      chain: viemChain,
+      transport: http(rpcUrl)
+    });
+    const response = await this.client.credit.creditCreateAccount({
+      chain,
+      owner,
+      sender: sponsorAccount.address,
+      estimateGas: false
+    });
+    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
+    };
+  }
+  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
+    });
+    return response;
+  }
+  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;
+  }
+  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,
+      gasSponsorship: true,
+      actions: wrappedActions
+    });
+    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,
+      actionsCount: response.actionsCount || actions.length
+    };
+  }
+  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,
+      token,
+      amount,
+      action: "DEPOSIT",
+      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
+    };
+    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,
+      primaryType: eip712.primaryType
+    };
+  }
+  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) {
+      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 = privateKeyToAccount(gasSponsorPrivateKey);
+    const walletClient = createWalletClient({
+      account: sponsorAccount,
+      chain: viemChain,
+      transport: http(rpcUrl)
+    });
+    const publicClient = createPublicClient({
+      chain: viemChain,
+      transport: http(rpcUrl)
+    });
+    const response = await this.client.gasSponsorship.gasSponsorshipPrepare({
+      chain,
+      owner,
+      sender: sponsorAccount.address,
+      eip712,
+      signature,
+      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
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash
+    });
+    if (receipt.status === "reverted") {
+      throw new CompassServiceError("Transaction reverted", 500);
+    }
+    return { txHash, success: true };
+  }
+};
+
+// src/server/nestjs/compass.service.ts
+var COMPASS_CONFIG = /* @__PURE__ */ Symbol("COMPASS_CONFIG");
+var CompassService = class extends CompassCoreService {
+  constructor(config) {
+    super(config);
+  }
+};
+CompassService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(COMPASS_CONFIG))
+], CompassService);
+
+// src/server/core/utils.ts
+function extractErrorMessage(error) {
+  if (!(error instanceof Error)) {
+    return { message: "Something went wrong. Please try again.", status: 500 };
+  }
+  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 {
+    }
+  }
+  if (error.name === "SDKValidationError" || raw.startsWith("Input validation failed")) {
+    return { message: "Invalid request data. Please check your inputs and try again.", status: 400 };
+  }
+  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 { message: "Something went wrong. Please try again.", status: 500 };
+}
+
+// src/server/nestjs/compass-exception.filter.ts
+var CompassExceptionFilter = class {
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    if (exception instanceof CompassServiceError) {
+      response.status(exception.statusCode).json({ error: exception.message });
+      return;
+    }
+    if (exception instanceof HttpException) {
+      const status2 = exception.getStatus();
+      const body = exception.getResponse();
+      response.status(status2).json(typeof body === "string" ? { error: body } : body);
+      return;
+    }
+    const { message, status } = extractErrorMessage(exception);
+    response.status(status).json({ error: message });
+  }
+};
+CompassExceptionFilter = __decorateClass([
+  Catch()
+], CompassExceptionFilter);
+
+// src/server/nestjs/earn.controller.ts
+var EarnController = class {
+  constructor(compass) {
+    this.compass = compass;
+  }
+  earnAccountCheck(params) {
+    return this.compass.earnAccountCheck(params);
+  }
+  earnAccountBalances(params) {
+    return this.compass.earnAccountBalances(params);
+  }
+  createAccount(body) {
+    return this.compass.createAccount(body);
+  }
+  depositPrepare(body) {
+    return this.compass.managePrepare(body, "DEPOSIT");
+  }
+  depositExecute(body) {
+    return this.compass.execute(body);
+  }
+  withdrawPrepare(body) {
+    return this.compass.managePrepare(body, "WITHDRAW");
+  }
+  withdrawExecute(body) {
+    return this.compass.execute(body);
+  }
+  positions(params) {
+    return this.compass.positions(params);
+  }
+  vaults(params) {
+    return this.compass.vaults(params);
+  }
+  aaveMarkets(params) {
+    return this.compass.aaveMarkets(params);
+  }
+  pendleMarkets(params) {
+    return this.compass.pendleMarkets(params);
+  }
+};
+__decorateClass([
+  Get("earn-account/check"),
+  __decorateParam(0, Query())
+], EarnController.prototype, "earnAccountCheck", 1);
+__decorateClass([
+  Get("earn-account/balances"),
+  __decorateParam(0, Query())
+], EarnController.prototype, "earnAccountBalances", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("create-account"),
+  __decorateParam(0, Body())
+], EarnController.prototype, "createAccount", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("deposit/prepare"),
+  __decorateParam(0, Body())
+], EarnController.prototype, "depositPrepare", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("deposit/execute"),
+  __decorateParam(0, Body())
+], EarnController.prototype, "depositExecute", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("withdraw/prepare"),
+  __decorateParam(0, Body())
+], EarnController.prototype, "withdrawPrepare", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("withdraw/execute"),
+  __decorateParam(0, Body())
+], EarnController.prototype, "withdrawExecute", 1);
+__decorateClass([
+  Get("positions"),
+  __decorateParam(0, Query())
+], EarnController.prototype, "positions", 1);
+__decorateClass([
+  Get("vaults"),
+  __decorateParam(0, Query())
+], EarnController.prototype, "vaults", 1);
+__decorateClass([
+  Get("aave/markets"),
+  __decorateParam(0, Query())
+], EarnController.prototype, "aaveMarkets", 1);
+__decorateClass([
+  Get("pendle/markets"),
+  __decorateParam(0, Query())
+], EarnController.prototype, "pendleMarkets", 1);
+EarnController = __decorateClass([
+  Controller("compass"),
+  UseFilters(CompassExceptionFilter),
+  __decorateParam(0, Inject(CompassService))
+], EarnController);
+var CreditController = class {
+  constructor(compass) {
+    this.compass = compass;
+  }
+  creditAccountCheck(params) {
+    return this.compass.creditAccountCheck(params);
+  }
+  creditCreateAccount(body) {
+    return this.compass.creditCreateAccount(body);
+  }
+  creditPositions(params) {
+    return this.compass.creditPositions(params);
+  }
+  creditBalances(params) {
+    return this.compass.creditBalances(params);
+  }
+  creditBundlePrepare(body) {
+    return this.compass.creditBundlePrepare(body);
+  }
+  creditExecute(body) {
+    return this.compass.creditExecute(body);
+  }
+  creditTransfer(body) {
+    return this.compass.creditTransfer(body);
+  }
+};
+__decorateClass([
+  Get("credit-account/check"),
+  __decorateParam(0, Query())
+], CreditController.prototype, "creditAccountCheck", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("credit-account/create"),
+  __decorateParam(0, Body())
+], CreditController.prototype, "creditCreateAccount", 1);
+__decorateClass([
+  Get("credit/positions"),
+  __decorateParam(0, Query())
+], CreditController.prototype, "creditPositions", 1);
+__decorateClass([
+  Get("credit/balances"),
+  __decorateParam(0, Query())
+], CreditController.prototype, "creditBalances", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("credit/bundle/prepare"),
+  __decorateParam(0, Body())
+], CreditController.prototype, "creditBundlePrepare", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("credit/bundle/execute"),
+  __decorateParam(0, Body())
+], CreditController.prototype, "creditExecute", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("credit/transfer"),
+  __decorateParam(0, Body())
+], CreditController.prototype, "creditTransfer", 1);
+CreditController = __decorateClass([
+  Controller("compass"),
+  UseFilters(CompassExceptionFilter),
+  __decorateParam(0, Inject(CompassService))
+], CreditController);
+var TokenController = class {
+  constructor(compass) {
+    this.compass = compass;
+  }
+  tokenBalance(params) {
+    return this.compass.tokenBalance(params);
+  }
+  tokenPrices(params) {
+    return this.compass.tokenPrices(params);
+  }
+  swapQuote(params) {
+    return this.compass.swapQuote(params);
+  }
+  swapPrepare(body) {
+    return this.compass.swapPrepare(body);
+  }
+  swapExecute(body) {
+    return this.compass.swapExecute(body);
+  }
+  txReceipt(params) {
+    return this.compass.txReceipt(params);
+  }
+};
+__decorateClass([
+  Get("token/balance"),
+  __decorateParam(0, Query())
+], TokenController.prototype, "tokenBalance", 1);
+__decorateClass([
+  Get("token/prices"),
+  __decorateParam(0, Query())
+], TokenController.prototype, "tokenPrices", 1);
+__decorateClass([
+  Get("swap/quote"),
+  __decorateParam(0, Query())
+], TokenController.prototype, "swapQuote", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("swap/prepare"),
+  __decorateParam(0, Body())
+], TokenController.prototype, "swapPrepare", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("swap/execute"),
+  __decorateParam(0, Body())
+], TokenController.prototype, "swapExecute", 1);
+__decorateClass([
+  Get("tx/receipt"),
+  __decorateParam(0, Query())
+], TokenController.prototype, "txReceipt", 1);
+TokenController = __decorateClass([
+  Controller("compass"),
+  UseFilters(CompassExceptionFilter),
+  __decorateParam(0, Inject(CompassService))
+], TokenController);
+var BundleController = class {
+  constructor(compass) {
+    this.compass = compass;
+  }
+  bundlePrepare(body) {
+    return this.compass.bundlePrepare(body);
+  }
+  bundleExecute(body) {
+    return this.compass.bundleExecute(body);
+  }
+  rebalancePreview(body) {
+    return this.compass.rebalancePreview(body);
+  }
+  transferApprove(body) {
+    return this.compass.transferApprove(body);
+  }
+  transferPrepare(body) {
+    return this.compass.transferPrepare(body);
+  }
+  transferExecute(body) {
+    return this.compass.transferExecute(body);
+  }
+  approvalExecute(body) {
+    return this.compass.approvalExecute(body);
+  }
+};
+__decorateClass([
+  HttpCode(200),
+  Post("bundle/prepare"),
+  __decorateParam(0, Body())
+], BundleController.prototype, "bundlePrepare", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("bundle/execute"),
+  __decorateParam(0, Body())
+], BundleController.prototype, "bundleExecute", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("rebalance/preview"),
+  __decorateParam(0, Body())
+], BundleController.prototype, "rebalancePreview", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("transfer/approve"),
+  __decorateParam(0, Body())
+], BundleController.prototype, "transferApprove", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("transfer/prepare"),
+  __decorateParam(0, Body())
+], BundleController.prototype, "transferPrepare", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("transfer/execute"),
+  __decorateParam(0, Body())
+], BundleController.prototype, "transferExecute", 1);
+__decorateClass([
+  HttpCode(200),
+  Post("approval/execute"),
+  __decorateParam(0, Body())
+], BundleController.prototype, "approvalExecute", 1);
+BundleController = __decorateClass([
+  Controller("compass"),
+  UseFilters(CompassExceptionFilter),
+  __decorateParam(0, Inject(CompassService))
+], BundleController);
+
+// src/server/nestjs/compass.module.ts
+var CompassModule = class {
+  static register(config) {
+    return {
+      module: CompassModule,
+      providers: [
+        {
+          provide: COMPASS_CONFIG,
+          useValue: config
+        },
+        CompassService
+      ],
+      controllers: [
+        EarnController,
+        CreditController,
+        TokenController,
+        BundleController
+      ],
+      exports: [CompassService]
+    };
+  }
+  static registerAsync(options) {
+    return {
+      module: CompassModule,
+      imports: options.imports || [],
+      providers: [
+        {
+          provide: COMPASS_CONFIG,
+          useFactory: options.useFactory,
+          inject: options.inject || []
+        },
+        CompassService
+      ],
+      controllers: [
+        EarnController,
+        CreditController,
+        TokenController,
+        BundleController
+      ],
+      exports: [CompassService]
+    };
+  }
+};
+CompassModule = __decorateClass([
+  Module({})
+], CompassModule);
+
+export { BundleController, COMPASS_CONFIG, CompassExceptionFilter, CompassModule, CompassService, CreditController, EarnController, TokenController };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map