Treasury Workflow with Dual Approval

// server/treasury.ts
import { 
  createTreasuryKit, 
  InMemoryIdempotencyStore, 
  SpendCeilings, 
  TimeLockManager, 
  NoopSanctionScreener, // swap for OFAC/Chainalysis adapters in production
  HmacEvidenceSigner 
} from '@veridex/agents-treasury';
 
export const treasuryKit = createTreasuryKit({
  appId: 'treasury-prod-01',
  runId: 'ops-workflow',
  agentId: 'treasury-bot',
  
  // 1. Guaranteed single-execution under retries
  idempotency: new InMemoryIdempotencyStore(),
  
  // 2. Velocity and total spend tracking (limits per transfer / day)
  ceilings: new SpendCeilings({
    perTransferUsdMicro: 100_000_000_000n, // Max single transfer $100,000
    dayUsdMicro:         500_000_000_000n  // Max daily limit $500,000
  }),
  
  // 3. 60-second time-lock to allow revocations on high-value actions
  timeLock: new TimeLockManager({ baseDelaySec: 60 }),
  
  // 4. Sanctions screen block list
  sanctions: new NoopSanctionScreener(),
  
  // 5. Cryptographically-signed Evidence Bundler config
  // We use HmacEvidenceSigner with a secure 32-byte secret key for our audit logs
  evidenceSigner: new HmacEvidenceSigner(
    'treasury-ev-key-2026', 
    Buffer.from('super-secret-hmac-key-must-be-at-least-32-chars-long')
  ),
 
  // 6. Connect inline providers to populate the tool array correctly
  balance: {
    provider: {
      getBalance: async (asset) => ({
        amount: '10000000000', // $10,000 USD represented in micro-USD (6 decimals)
        currency: asset.currency,
        decimals: 6
      })
    }
  },
  transfer: {
    executor: {
      execute: async (proposal) => ({
        txHash: '0x' + 'a'.repeat(64),
        chain: proposal.to.chain,
        confirmedAt: Date.now(),
        idempotencyKey: proposal.idempotencyKey
      })
    }
  },
  
  // 7. Dual approval required for transfers exceeding $10,000 USD
  // All policy thresholds are set inside the policy config block
  policy: {
    dualApprovalThreshold: {
      USD: { amount: '10000000000', currency: 'USD', decimals: 6 } // $10,000 USD represented with 6 decimals (micro-USD)
    }
  }
});

// server/agent.ts
import { createAgent, OpenAIProvider } from '@veridex/agents';
import { treasuryKit } from './treasury';
 
export const agent = createAgent(
  {
    id: 'enterprise-treasury-agent',
    name: 'Enterprise Treasury Agent',
    model: { provider: 'openai', model: 'gpt-4o' },
    instructions: `
      You are an enterprise treasury agent.
      You process supplier payouts and execute asset redistributions.
      You must obey all spending limits and sanctions policies.
      If a transfer exceeds $10,000, explain to the user that it has been paused for approval.
    `,
    // Tools and policies are composite: they inherit all treasury rules automatically
    tools: [...treasuryKit.tools],
    policies: [...treasuryKit.policyRules],
    maxTurns: 10
  },
  {
    modelProviders: {
      openai: new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY }),
    },
    // We must enable checkpoints to store the execution state during human suspension
    enableCheckpoints: true,
    enableTracing: true,
    plugins: [treasuryKit.plugin]
  }
);

// server/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { agent } from './agent';
 
export async function POST(req: NextRequest) {
  const { prompt } = await req.json();
 
  // Execute the run loop
  const result = await agent.run(prompt);
 
  // Check if the agent's run was suspended by our treasury policies
  if (result.run.state === 'waiting_for_approval') {
    const checkpointId = result.run.checkpointId;
    const approvalId = result.run.approvalId; // Id of the matching policy trigger
    
    // Post details to our Slack channel or approval database
    await notifyOpsTeam({
      runId: result.run.id,
      checkpointId,
      approvalId,
      proposedTransfer: result.run.metadata.proposedAction, // Auto-extracted by treasury plugin
      reasoning: result.run.reasoning
    });
 
    return NextResponse.json({
      status: 'SUSPENDED',
      message: 'This transfer exceeds $10,000 and requires dual human approval.',
      runId: result.run.id,
      checkpointId
    });
  }
 
  return NextResponse.json({
    status: 'COMPLETED',
    output: result.output,
    txHash: result.run.metadata.txHash
  });
}

// server/resume-route.ts
import { NextRequest, NextResponse } from 'next/server';
import { agent } from './agent';
 
export async function POST(req: NextRequest) {
  const { checkpointId, approvals } = await req.json();
  
  // approvals is an array representing dual approvals:
  // [{ approver: "alice@acme.com", signature: "..." }, { approver: "bob@acme.com", signature: "..." }]
 
  const resumedResult = await agent.resumeFromCheckpoint(checkpointId, {
    approval: {
      approved: true,
      approvers: approvals.map((a: any) => a.approver),
      metadata: { signatures: approvals }
    }
  });
 
  // Verify that the run finalized successfully
  if (resumedResult.run.state === 'completed') {
    
    // Extract the cryptographically-signed Evidence Bundle (receipt)
    const evidenceBundle = resumedResult.run.metadata.evidenceBundle;
 
    return NextResponse.json({
      status: 'EXECUTED',
      output: resumedResult.output,
      receipt: evidenceBundle // Offline-verifiable RFC 8785 JSON bundle
    });
  }
 
  return NextResponse.json({
    status: 'FAILED',
    error: resumedResult.run.error
  });
}

// auditing/verify-receipt.ts
import { verifyEvidenceBundle } from '@veridex/agents-treasury';
import { readFileSync } from 'fs';
 
const publicKey = readFileSync('./evidence-signer-pub.pem');
const receiptJson = readFileSync('./receipt-01HF8.json', 'utf8');
 
async function auditTransaction() {
  const bundle = JSON.parse(receiptJson);
  
  const isAuthentic = await verifyEvidenceBundle(bundle, { publicKey });
  
  if (isAuthentic) {
    console.log('✅ RECEIPT VALID');
    console.log('Merchant:', bundle.proposal.recipient);
    console.log('Reasoning:', bundle.proposal.reasoning);
    console.log('Signed At:', new Date(bundle.timestamp).toISOString());
  } else {
    console.error('❌ TAMPER DETECTED: Receipt signatures do not match hashes.');
  }
}