Build a trading agent on Velora in 10 minutes

import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
import {
  createWalletClient, encodeAbiParameters, erc20Abi, formatUnits, http, parseAbi, parseAbiParameters,
  parseSignature, publicActions, serializeCompactSignature, signatureToCompactSignature, type Address, type Hex,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";
import { createInterface } from "node:readline/promises";
import { z } from "zod";

process.loadEnvFile(); // reads .env

// Velora spenders (same address on every chain). Never interchangeable.
const DELTA: Address = "0x0000000000bbf5c5fd284e657f01bd000933c96d";
const AUGUSTUS = "0x6a000f20005980200259b80c5102003040001068"; // Augustus v6.2

// Native ETH, plus the tokens the agent may sell, the most it may sell per trade,
// and whether the token supports gasless EIP-2612 permits.
const ETH = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
const TOKENS: Record<string, { address: Address; decimals: number; max: bigint; permit: boolean }> = {
  USDC: { address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", decimals: 6, max: 100_000000n, permit: true },
  WETH: { address: "0x4200000000000000000000000000000000000006", decimals: 18, max: 50_000000000000000n, permit: false },
};
// Native ETH sold via Market is sent as tx value, with no approval to cap it: 0.02 ETH max.
const MAX_ETH = 20_000000000000000n;

const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);
const client = createWalletClient({ account, chain: base, transport: http(process.env.BASE_RPC_URL) }).extend(publicActions);

const permitAbi = parseAbi(["function version() view returns (string)", "function nonces(address) view returns (uint256)"]);

const is = (a: string, b: string) => a.toLowerCase() === b.toLowerCase();

function checkLimit(token: string, amount: bigint) {
  const [symbol, t] = Object.entries(TOKENS).find(([, t]) => is(t.address, token)) ?? [];
  if (!t) throw new Error(`${token} is not on the allowlist`);
  if (amount > t.max) throw new Error(`over the ${formatUnits(t.max, t.decimals)} ${symbol} limit`);
  return `${formatUnits(amount, t.decimals)} ${symbol}`;
}

async function confirm(question: string) {
  const rl = createInterface({ input: process.stdin, output: process.stdout });
  const answer = await rl.question(`\n⚠️  ${question}\n   Sign? (y/N) `);
  rl.close();
  if (answer.trim().toLowerCase() !== "y") throw new Error("user declined");
}

// Any thrown check becomes "REFUSED: <reason>" for the agent.
const guarded = (fn: (args: any) => Promise<unknown>) => async (args: any) => {
  try {
    const result = await fn(args);
    return { content: [{ type: "text" as const, text: JSON.stringify(result, (_, v) => (typeof v === "bigint" ? `${v}` : v)) }] };
  } catch (e) {
    return { content: [{ type: "text" as const, text: `REFUSED: ${(e as Error).message}` }], isError: true };
  }
};

export const walletServer = createSdkMcpServer({
  name: "wallet",
  tools: [
    tool("wallet_info", "Wallet address, current unix time, native ETH, and the allowlisted tokens with address, decimals, balance and allowances to Velora.",
      {},
      guarded(async () => ({
        address: account.address,
        now: Math.floor(Date.now() / 1000),
        ETH: { address: ETH, decimals: 18, balance: await client.getBalance({ address: account.address }) },
        tokens: await Promise.all(Object.entries(TOKENS).map(async ([symbol, { address, decimals, max, permit }]) => {
          const erc20 = { address, abi: erc20Abi } as const;
          return {
            symbol, address, decimals, maxPerTrade: max, permit,
            balance: await client.readContract({ ...erc20, functionName: "balanceOf", args: [account.address] }),
            allowanceDelta: await client.readContract({ ...erc20, functionName: "allowance", args: [account.address, DELTA] }),
            allowanceAugustus: await client.readContract({ ...erc20, functionName: "allowance", args: [account.address, AUGUSTUS] }),
          };
        })),
      }))),

    tool("sign_permit", "Sign a gasless EIP-2612 permit letting Velora Delta spend an exact amount of a token with permit: true. Pass the result as permit to velora_build_delta_order.",
      { token: z.string(), amount: z.string(), deadline: z.number() },
      guarded(async ({ token, amount, deadline }) => {
        const t = Object.values(TOKENS).find((t) => is(t.address, token));
        if (!t?.permit) throw new Error("token does not support permits, use approve_token");
        await confirm(`Permit: let Velora Delta spend ${checkLimit(token, BigInt(amount))} (no gas)`);
        const [name, version, nonce] = await Promise.all([
          client.readContract({ address: t.address, abi: erc20Abi, functionName: "name" }),
          client.readContract({ address: t.address, abi: permitAbi, functionName: "version" }),
          client.readContract({ address: t.address, abi: permitAbi, functionName: "nonces", args: [account.address] }),
        ]);
        const message = { owner: account.address, spender: DELTA, value: BigInt(amount), nonce, deadline: BigInt(deadline) };
        const signature = await account.signTypedData({
          domain: { name, version, chainId: base.id, verifyingContract: t.address },
          types: { Permit: [
            { name: "owner", type: "address" }, { name: "spender", type: "address" }, { name: "value", type: "uint256" },
            { name: "nonce", type: "uint256" }, { name: "deadline", type: "uint256" },
          ] },
          primaryType: "Permit",
          message,
        });
        const { r, s, v, yParity } = parseSignature(signature);
        // Delta expects abi.encode(owner, spender, value, deadline, v, r, s): 224 bytes.
        return { permit: encodeAbiParameters(parseAbiParameters("address, address, uint256, uint256, uint8, bytes32, bytes32"),
          [message.owner, DELTA, message.value, message.deadline, Number(v ?? 27n + BigInt(yParity)), r, s]) };
      })),

    tool("approve_token", "Approve an exact amount of an allowlisted token to Velora Delta or Augustus v6.2.",
      { token: z.string(), spender: z.string(), amount: z.string() },
      guarded(async ({ token, spender, amount }) => {
        if (!is(spender, DELTA) && !is(spender, AUGUSTUS)) throw new Error("spender is not a Velora contract");
        await confirm(`Approve ${checkLimit(token, BigInt(amount))} to ${is(spender, DELTA) ? "Velora Delta" : "Augustus v6.2"}`);
        const hash = await client.writeContract({ address: token as Address, abi: erc20Abi, functionName: "approve", args: [spender as Address, BigInt(amount)] });
        await client.waitForTransactionReceipt({ hash });
        return { hash };
      })),

    tool("sign_delta_order", "Sign the toSign payload from velora_build_delta_order. Returns an ERC-2098 compact signature.",
      { toSign: z.object({ domain: z.any(), types: z.any(), value: z.any() }), summary: z.string() },
      guarded(async ({ toSign: { domain, types, value }, summary }) => {
        if (Number(domain.chainId) !== base.id || !is(domain.verifyingContract, DELTA)) throw new Error("not a Velora Delta order on Base");
        if (!is(value.owner, account.address)) throw new Error("order owner is not this wallet");
        await confirm(`Delta order: sell ${checkLimit(value.srcToken, BigInt(value.srcAmount))}. ${summary}`);
        const { EIP712Domain, ...orderTypes } = types;
        const signature = await account.signTypedData({ domain, types: orderTypes, primaryType: "Order", message: value });
        return { signature: serializeCompactSignature(signatureToCompactSignature(parseSignature(signature))) };
      })),

    tool("send_transaction", "Send a Market swap built by velora_build_transaction. Only Augustus v6.2 is allowed.",
      { to: z.string(), data: z.string(), value: z.string(), summary: z.string() },
      guarded(async ({ to, data, value, summary }) => {
        if (!is(to, AUGUSTUS)) throw new Error("destination is not Augustus v6.2");
        if (BigInt(value) > MAX_ETH) throw new Error("native ETH value over the limit");
        await confirm(`Market swap: ${summary}`);
        const hash = await client.sendTransaction({ to: AUGUSTUS, data: data as Hex, value: BigInt(value) });
        const { status } = await client.waitForTransactionReceipt({ hash });
        return { hash, status };
      })),
  ],
});

import { query } from "@anthropic-ai/claude-agent-sdk";
import { walletServer } from "./wallet.ts";

const task = process.argv[2] ?? "Swap 25 USDC to ETH on Base";

const systemPrompt = `You are a careful trading agent. You trade on Base (chainId 8453) through Velora.
Always pass partner: "my-trading-agent" to Velora tools.

Process for every trade:
1. Call wallet_info. It lists native ETH and the tokens this wallet can sell, with addresses,
   decimals, balances and allowances. Only trade between these tokens, and never invent
   addresses or decimals. Stop if the balance is too low.
2. Call velora_get_quote with mode "ALL", side "SELL", userAddress = wallet address.
   Selling native ETH: use mode "MARKET" instead.
3. Branch on result.responseType, never on the mode you asked for. Use velora_explain_quote
   if it is "market" so you can tell the user why Delta wasn't used.
4. Before signing, state: amount in, expected amount out, USD values, gas cost (Market only)
   and price impact. If price impact is above 2%, stop and explain.
5a. Delta: if allowanceDelta < amount and the token has permit: true, call sign_permit with
    amount = the quote's srcAmount and deadline = now + 600 (no gas). Otherwise approve_token
    to the Delta spender for the exact amount.
    velora_build_delta_order with route = result.raw.delta.route copied VERBATIM, owner = wallet,
    slippage 50, the same deadline, and permit = the sign_permit result (if any).
    Then sign_delta_order with result.raw.toSign,
    then velora_submit_delta_order with order = toSign.value and the signature.
    Poll velora_get_delta_order by id until COMPLETED, FAILED, EXPIRED, CANCELLED or REFUNDED.
5b. Market: if allowanceAugustus < amount (ERC-20 only), approve_token to Augustus v6.2
    (velora_build_transaction takes no permit).
    velora_build_transaction with priceRoute copied VERBATIM and its srcAmount/destAmount.
    Then send_transaction with to, data, value.
6. If a quote is older than ~30 seconds when you submit, requote.
7. Finish with a short receipt: path used, amounts, tx hash or order id.
If sign_permit, approve_token, sign_delta_order or send_transaction returns REFUSED, do not retry with
different parameters. Explain and stop.`;

// In-process MCP servers (the wallet) need streaming input, so the prompt is an async generator.
async function* prompt() {
  yield { type: "user" as const, message: { role: "user" as const, content: task }, parent_tool_use_id: null, session_id: "" };
}

try {
  for await (const msg of query({
    prompt: prompt(),
    options: {
      systemPrompt,
      mcpServers: { velora: { type: "http", url: "https://ai.velora.xyz/mcp" }, wallet: walletServer },
      tools: [],                                    // no shell, file or web tools
      allowedTools: ["mcp__velora", "mcp__wallet"], // every tool on these two servers
      disallowedTools: ["mcp__velora__velora_get_tokens"], // too large; wallet_info has the addresses
    },
  })) {
    if (msg.type !== "assistant") continue;
    for (const block of msg.message.content) {
      if (block.type === "text") console.log(block.text);
      if (block.type === "tool_use") console.log(`  → ${block.name.split("__").pop()}`);
    }
  }
} catch (e) {
  // Print one readable line instead of Node's stack trace.
  console.error(`\n✖ ${(e as Error).message.replace("Claude Code returned an error result: ", "")}`);
  process.exit(1);
}