Contributing

from typing import Optional
from dataclasses import dataclass

@dataclass
class Wallet:
    """Represents an AI agent wallet.
    
    Args:
        wallet_id: Unique wallet identifier
        balance: Current balance in base currency units
        currency: Currency code (e.g., USDC)
    """
    wallet_id: str
    balance: int
    currency: str
    
    def transfer(self, to: str, amount: int) -> bool:
        """Transfer funds to another wallet.
        
        Args:
            to: Destination wallet address
            amount: Amount to transfer in base units
            
        Returns:
            True if transfer succeeded
            
        Raises:
            InsufficientBalanceError: If balance is too low
        """
        if amount > self.balance:
            raise InsufficientBalanceError()
        # ... implementation
        return True

async def execute_payment(
    wallet_id: str,
    amount: int,
    recipient: str
) -> TransactionResult:
    """Execute a payment transaction."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{API_BASE}/payments",
            json={
                "wallet_id": wallet_id,
                "amount": amount,
                "recipient": recipient,
            }
        )
        response.raise_for_status()
        return TransactionResult(**response.json())

class SardisError(Exception):
    """Base exception for Sardis errors."""
    pass

class InsufficientBalanceError(SardisError):
    """Raised when wallet balance is too low."""
    
    def __init__(self, required: int, available: int):
        super().__init__(
            f"Insufficient balance: required {required}, "
            f"but only {available} available"
        )
        self.required = required
        self.available = available

import { z } from 'zod';

// Schema validation
const WalletSchema = z.object({
  wallet_id: z.string(),
  balance: z.number().int().nonnegative(),
  currency: z.enum(['USDC', 'USDT', 'EURC']),
});

type Wallet = z.infer<typeof WalletSchema>;

// Function with proper types
async function createWallet(
  agentId: string,
  currency: 'USDC' | 'USDT' | 'EURC'
): Promise<Wallet> {
  const response = await fetch(`${API_BASE}/wallets`, {
    method: 'POST',
    body: JSON.stringify({ agent_id: agentId, currency }),
  });
  
  const data = await response.json();
  return WalletSchema.parse(data);
}

export class SardisError extends Error {
  constructor(
    message: string,
    public readonly code: string,
    public readonly statusCode?: number
  ) {
    super(message);
    this.name = 'SardisError';
  }
}

export class InsufficientBalanceError extends SardisError {
  constructor(
    public readonly required: number,
    public readonly available: number
  ) {
    super(
      `Insufficient balance: required ${required}, available ${available}`,
      'INSUFFICIENT_BALANCE',
      400
    );
    this.name = 'InsufficientBalanceError';
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/Ownable.sol";

/// @title Sardis Agent Wallet
/// @notice Manages agent wallet balances and spending policies
/// @dev Implements ERC-4337 account abstraction
contract SardisAgentWallet is Ownable {
    /// @notice Maximum spending limit per transaction
    uint256 public maxPerTransaction;
    
    /// @notice Emitted when a payment is executed
    /// @param to Recipient address
    /// @param amount Amount transferred
    /// @param purpose Payment purpose
    event PaymentExecuted(
        address indexed to,
        uint256 amount,
        string purpose
    );
    
    /// @notice Execute a payment
    /// @param to Recipient address
    /// @param amount Amount to transfer
    /// @param purpose Payment purpose
    /// @dev Reverts if amount exceeds maxPerTransaction
    function executePayment(
        address to,
        uint256 amount,
        string memory purpose
    ) external onlyOwner {
        require(amount <= maxPerTransaction, "Exceeds limit");
        // ... implementation
        emit PaymentExecuted(to, amount, purpose);
    }
}