@compass-labs/widgets 0.1.34 → 0.1.36

package/dist/server/index.mjs

@@ -32,6 +32,8 @@ function createCompassHandler(config) {
             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":
@@ -40,6 +42,14 @@ function createCompassHandler(config) {
             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);
         }
@@ -73,6 +83,14 @@ function createCompassHandler(config) {
             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);
           default:
             return jsonResponse({ error: `Unknown POST route: ${route}` }, 404);
         }
@@ -646,6 +664,26 @@ async function handleTokenBalance(client, params) {
     });
   }
 }
+async function handleTokenPrices(client, params) {
+  const { chain = "base", tokens } = params;
+  if (!tokens) {
+    return jsonResponse({ error: "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 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 jsonResponse({ prices });
+}
 async function handleBundlePrepare(client, body) {
   const { owner, chain = "base", actions } = body;
   if (!owner || !actions || actions.length === 0) {
@@ -1161,6 +1199,279 @@ async function handleRebalancePreview(client, body, config) {
     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 = privateKeyToAccount(gasSponsorPrivateKey);
+  const walletClient = createWalletClient({
+    account: sponsorAccount,
+    chain: viemChain,
+    transport: http(rpcUrl)
+  });
+  const publicClient = createPublicClient({
+    chain: viemChain,
+    transport: 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,
+    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
+    );
+  }
+  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 = privateKeyToAccount(gasSponsorPrivateKey);
+  const walletClient = createWalletClient({
+    account: sponsorAccount,
+    chain: viemChain,
+    transport: http(rpcUrl)
+  });
+  const publicClient = createPublicClient({
+    chain: viemChain,
+    transport: 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);
+  }
+  const publicClient = createPublicClient({
+    chain: viemChain,
+    transport: http(rpcUrl)
+  });
+  try {
+    const receipt = await publicClient.getTransactionReceipt({
+      hash
+    });
+    return jsonResponse({
+      status: receipt.status,
+      blockNumber: receipt.blockNumber.toString()
+    });
+  } catch {
+    return jsonResponse({ status: "pending" });
+  }
+}
 
 export { createCompassHandler };
 //# sourceMappingURL=index.mjs.map