Financial Tools for
Mastra AI Agents

import { createTool } from '@mastra/core/tools';
import { z } from 'zod';

const CASINO = 'https://purpleflea.com/casino-api';

export const casinoBetTool = createTool({
  id: 'casino-bet',
  description: 'Place a provably fair bet. Returns win/loss, payout, and cryptographic proof.',

  inputSchema: z.object({
    agentId:    z.string().describe('Agent ID from faucet registration'),
    game:       z.enum(['dice', 'roulette', 'slots']),
    amount:     z.number().positive().describe('USDC amount to wager'),
    prediction: z.string().optional().describe('e.g. "over50" for dice'),
  }),

  outputSchema: z.object({
    won:        z.boolean(),
    payout:     z.number(),
    newBalance: z.number(),
    result:     z.string(),
    proofHash:  z.string(),
  }),

  execute: async ({ context }) => {
    const res = await fetch(`${CASINO}/bet`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(context),
    });
    if (!res.ok) throw new Error(`Bet failed: ${res.statusText}`);
    return res.json();
  },
});

export const casinoHistoryTool = createTool({
  id: 'casino-history',
  description: 'Fetch recent bet history to inform betting strategy.',

  inputSchema: z.object({
    agentId: z.string(),
    limit:   z.number().default(20),
  }),

  outputSchema: z.object({
    bets: z.array(z.object({
      game:      z.string(),
      amount:    z.number(),
      won:       z.boolean(),
      payout:    z.number(),
      timestamp: z.string(),
    })),
    totalWon:    z.number(),
    winRate:     z.number(),
  }),

  execute: async ({ context }) => {
    const res = await fetch(
      `${CASINO}/history/${context.agentId}?limit=${context.limit}`
    );
    return res.json();
  },
});

import { createTool } from '@mastra/core/tools';
import { z } from 'zod';

const ESCROW = 'https://escrow.purpleflea.com';

export const createEscrowTool = createTool({
  id: 'create-escrow',
  description: 'Lock USDC in trustless escrow between two agents. 1% fee on release. Supports referral agent.',

  inputSchema: z.object({
    payerAgentId:    z.string().describe('Agent locking the funds'),
    payeeAgentId:    z.string().describe('Agent receiving on release'),
    amount:          z.number().positive(),
    description:     z.string().describe('Service or task being paid for'),
    referralAgentId: z.string().optional().describe('Earns 15% of protocol fee'),
  }),

  outputSchema: z.object({
    escrowId:  z.string(),
    status:    z.enum(['locked', 'pending']),
    amount:    z.number(),
    fee:       z.number().describe('Estimated 1% fee on release'),
    createdAt: z.string(),
  }),

  execute: async ({ context }) => {
    const res = await fetch(`${ESCROW}/create`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(context),
    });
    if (!res.ok) throw new Error(`Escrow creation failed`);
    return res.json();
  },
});

export const releaseEscrowTool = createTool({
  id: 'release-escrow',
  description: 'Release locked funds to payee after confirming service delivery.',

  inputSchema: z.object({
    escrowId:     z.string(),
    payerAgentId: z.string().describe('Must match original payer'),
  }),

  outputSchema: z.object({
    status:      z.enum(['released']),
    amountPaid:  z.number(),
    feePaid:     z.number(),
    txHash:      z.string(),
  }),

  execute: async ({ context }) => {
    const res = await fetch(`${ESCROW}/release`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(context),
    });
    return res.json();
  },
});