AI Agent with a $50/day USDC Budget

// frontend/components/AgentProvisioner.tsx
import { usePasskey, useVault } from '@veridex/react';
import { useState } from 'react';
 
export function AgentProvisioner() {
  const { register, credential } = usePasskey();
  const { address } = useVault();
  const [session, setSession] = useState<any>(null);
 
  if (!credential) {
    return (
      <div className="vdx-card">
        <h3>1. Create Passkey Wallet</h3>
        <p>Register a WebAuthn vault on Base Sepolia. No seed phrase required.</p>
        <button className="vdx-btn" onClick={() => register('user@example.com', 'My Agent Vault')}>
          Create Vault
        </button>
      </div>
    );
  }
 
  return (
    <div className="vdx-card">
      <h3>Vault Active</h3>
      <code className="block bg-black/10 p-2 rounded text-sm">{address}</code>
      {/* Proceed to Step 2 */}
    </div>
  );
}

// frontend/components/AgentProvisioner.tsx (continued)
import { SessionManager, EVMHubClientAdapter, createSDK } from '@veridex/sdk';
import { parseUnits, JsonRpcProvider } from 'ethers';
 
export function SessionCreator({ sdk, credential }: { sdk: any, credential: any }) {
  const [status, setStatus] = useState('');
  
  const createAndRegisterSession = async () => {
    setStatus('Creating session key...');
    const provider = new JsonRpcProvider('https://sepolia.base.org');
    
    // We use a public relayer adapter to register our session key on-chain gaslessly
    const hubClient = new EVMHubClientAdapter(sdk.getChainClient() as any);
    
    const manager = new SessionManager(
      credential,
      hubClient,
      (challenge) => sdk.passkey.sign(challenge),
      { 
        duration: 86400, // 24 hours
        // USDC uses 6 decimals on-chain. $50 USDC = 50 * 10^6
        maxValue: parseUnits('50', 6), 
        allowedTokens: ['0x036CbD53842c5426634e7929541eC2318f3dCF7e'] // USDC on Base Sepolia
      }
    );
 
    const session = await manager.createSession();
    setStatus('Syncing with agent server...');
 
    // Post session credentials to the server
    const res = await fetch('/api/agent/provision', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        vaultAddress: sdk.getVaultAddress(),
        sessionCredentials: session.serialize() // Encrypted/serialized session parameters
      }),
    });
 
    if (res.ok) setStatus('Agent Active and Budgeted!');
    else setStatus('Failed to provision agent server.');
  };
 
  return (
    <div className="vdx-card mt-4">
      <h3>2. Authorize $50/Day Budget</h3>
      <p>Mints an on-chain Session Key that restricts the agent server's actions.</p>
      <button className="vdx-btn vdx-btn-primary" onClick={createAndRegisterSession}>
        Authorize Agent
      </button>
      {status && <p className="mt-2 text-sm">{status}</p>}
    </div>
  );
}

// server/agent.ts
import { createAgent, OpenAIProvider } from '@veridex/agents';
import { createAgentWallet } from '@veridex/agentic-payments';
import { createSDK } from '@veridex/sdk';
import { payTool, balanceTool } from './tools';
 
export async function startAutonomousAgent(vaultAddress: string, sessionCredentialsHex: string) {
  // 1. Initialize core Veridex protocol primitives
  const sdk = createSDK('base', { network: 'testnet' });
  
  const wallet = await createAgentWallet({
    masterCredential: {
      credentialId: 'user-credential-id',
      publicKeyX: 0n,
      publicKeyY: 0n,
      keyHash: '0xhash...'
    },
    session: {
      dailyLimitUSD: 50,
      perTransactionLimitUSD: 10,
      expiryHours: 24,
      allowedChains: [10004] // Base Sepolia Wormhole chain ID
    }
  });
 
  // Import the session payload received from the browser
  await wallet.importSession(JSON.parse(sessionCredentialsHex));
 
  // 2. Initialize the safe agentic runtime
  const agent = createAgent(
    {
      id: `agent-${vaultAddress.slice(0, 8)}`,
      name: 'Budgeted Swapper & Purchaser',
      model: { provider: 'openai', model: 'gpt-4o' },
      instructions: `
        You are an autonomous treasury and purchasing assistant.
        You have an active daily limit of $50 USDC. 
        You spend autonomously to execute the user's tasks.
        Before every transfer, explain your exact reasoning to the user.
        Never exceed your daily cap.
      `,
      tools: [
        payTool(wallet),
        balanceTool(wallet)
      ],
      // Hard stop after 8 reasoning loops to prevent cost or loop runaways
      maxTurns: 8,
      policies: [
        // Policies are evaluated in the runtime before tool invocation
        { type: 'maxRunSpendUSD', params: { limit: 50 } },
        { type: 'blockSafetyClasses', params: { safetyClasses: ['destructive', 'privileged'] } }
      ]
    },
    {
      modelProviders: {
        openai: new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY }),
      },
      enableTracing: true,
      enableCheckpoints: true
    }
  );
 
  return agent;
}

// server/tools.ts
import { tool } from '@veridex/agents';
import { AgentWallet } from '@veridex/agentic-payments';
import { parseUnits } from 'ethers';
import { z } from 'zod';
 
export const balanceTool = (wallet: AgentWallet) =>
  tool({
    name: 'check_usdc_balance',
    description: 'Check your available USDC balance on Base',
    input: z.object({}),
    safetyClass: 'read',
    async execute() {
      // getBalance expects a Wormhole Chain ID (e.g., 10004 for Base Sepolia) and returns TokenBalance[]
      const balances = await wallet.getBalance(10004);
      const usdc = balances.find((b: any) => b.token.symbol === 'USDC');
      const formattedBalance = usdc ? usdc.formatted : '0';
      const status = wallet.getSessionStatus();
 
      return {
        success: true,
        llmOutput: `Available balance: ${formattedBalance} USDC. Limit spent today: $${status.totalSpentUSD}/$50.`,
      };
    },
  });
 
export const payTool = (wallet: AgentWallet) =>
  tool({
    name: 'make_usdc_payment',
    description: 'Autonomous payment in USDC up to your daily budget limit',
    input: z.object({
      recipient: z.string().regex(/^0x[a-fA-F0-9]{40}$/, 'Invalid EVM address'),
      amountUSD: z.number().positive().max(50, 'Cannot exceed daily limit'),
      purpose: z.string().min(5, 'A clear reason is required for trace auditing'),
    }),
    safetyClass: 'financial',
    async execute({ input }) {
      try {
        const status = wallet.getSessionStatus();
        // Enforce reasoning capture
        const traceReasoning = `Autonomous Payment: ${input.purpose}. Daily cumulative spent: $${status.totalSpentUSD}`;
        
        // Convert to smallest units as string
        const atomicAmount = parseUnits(input.amountUSD.toString(), 6).toString();
 
        const tx = await wallet.pay({
          recipient: input.recipient,
          amount: atomicAmount, // USDC uses 6 decimals, pay expects smallest unit string
          token: 'USDC',
          chain: 10004, // Base Sepolia Wormhole chain ID
          metadata: { reasoning: traceReasoning }
        });
 
        return {
          success: true,
          llmOutput: `Successfully transferred ${input.amountUSD} USDC to ${input.recipient}. Hash: ${tx.txHash}`,
        };
      } catch (err: any) {
        return {
          success: false,
          llmOutput: `Payment failed: ${err.message}`,
        };
      }
    },
  });

// server/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { startAutonomousAgent } from './agent';
 
export async function POST(req: NextRequest) {
  const { vaultAddress, sessionCredentials, prompt } = await req.json();
 
  const agent = await startAutonomousAgent(vaultAddress, sessionCredentials);
 
  // Compile and run the agent loop
  const result = await agent.run(prompt);
 
  // Return the terminal outcome and the audit-ready Trace Log
  return NextResponse.json({
    output: result.output,
    state: result.run.state, // e.g. "completed" | "suspended"
    traceId: result.run.traceId,
    tokensUsed: result.run.tokensUsed
  });
}