Financial Tools for
Phidata Agents

from phi.tools import Toolkit
import requests
from typing import Literal, Optional

class TradingTools(Toolkit):
    """Purple Flea perpetual futures trading tools.

    Access 275 perp markets, place orders, manage positions,
    and set stop-loss / take-profit levels for your agent.
    """

    BASE = "https://purpleflea.com/trading-api"

    def __init__(self, agent_id: str, api_key: str):
        super().__init__(name="trading_tools")
        self.agent_id = agent_id
        self.headers = {"Authorization": f"Bearer {api_key}"}
        self.register(self.get_markets)
        self.register(self.get_price)
        self.register(self.open_position)
        self.register(self.close_position)
        self.register(self.get_positions)
        self.register(self.set_stop_loss)

    def get_markets(self, category: str = "crypto") -> str:
        """List available perpetual futures markets.

        Args:
            category: 'crypto', 'forex', 'commodities', or 'indices'

        Returns:
            List of markets with symbols, tick sizes, and leverage limits.
        """
        resp = requests.get(
            f"{self.BASE}/markets",
            headers=self.headers,
            params={"category": category}
        )
        return resp.json()

    def get_price(self, symbol: str) -> str:
        """Get current market price and funding rate for a perp symbol.

        Args:
            symbol: Market symbol e.g. 'BTC-USDC', 'ETH-USDC', 'SOL-USDC'

        Returns:
            Mark price, index price, funding rate, open interest.
        """
        resp = requests.get(
            f"{self.BASE}/price/{symbol}",
            headers=self.headers
        )
        return resp.json()

    def open_position(
        self,
        symbol: str,
        side: Literal["long", "short"],
        size_usdc: float,
        leverage: int = 1,
        order_type: Literal["market", "limit"] = "market",
        limit_price: Optional[float] = None,
    ) -> str:
        """Open a leveraged perpetual futures position.

        Args:
            symbol:      Market symbol e.g. 'BTC-USDC'
            side:        'long' (buy) or 'short' (sell)
            size_usdc:   Position size in USDC (before leverage)
            leverage:    Leverage multiplier 1-50x (default 1x)
            order_type:  'market' fills immediately, 'limit' sets a price
            limit_price: Required if order_type is 'limit'

        Returns:
            Order ID, fill price, position size, liquidation price.
        """
        resp = requests.post(
            f"{self.BASE}/orders",
            headers=self.headers,
            json={
                "agent_id": self.agent_id,
                "symbol": symbol,
                "side": side,
                "size_usdc": size_usdc,
                "leverage": leverage,
                "order_type": order_type,
                "limit_price": limit_price,
            }
        )
        return resp.json()

    def get_positions(self) -> str:
        """List all open positions for this agent.

        Returns:
            All open positions with unrealized PnL and margin levels.
        """
        resp = requests.get(
            f"{self.BASE}/positions/{self.agent_id}",
            headers=self.headers
        )
        return resp.json()

from phi.tools import Toolkit
import requests

class EscrowTools(Toolkit):
    """Purple Flea trustless escrow tools for Phidata agents.

    Create escrow contracts between agents, release funds,
    raise disputes, and earn 15% referral fee on all
    escrow fees generated by agents you refer.
    """

    BASE = "https://escrow.purpleflea.com"

    def __init__(self, agent_id: str, api_key: str, referral_code: str = None):
        super().__init__(name="escrow_tools")
        self.agent_id     = agent_id
        self.referral_code = referral_code
        self.headers = {"Authorization": f"Bearer {api_key}"}
        self.register(self.create_escrow)
        self.register(self.release_funds)
        self.register(self.get_escrow_status)
        self.register(self.raise_dispute)

    def create_escrow(
        self,
        counterparty_agent_id: str,
        amount_usdc: float,
        description: str,
        timeout_hours: int = 24,
    ) -> str:
        """Create a trustless escrow contract between two agents.

        The caller (payer) locks funds. The counterparty completes
        work. Caller then releases funds. If disputed, Purple Flea
        resolves. Fee is 1% of amount.

        Args:
            counterparty_agent_id: Agent ID of the payee/service provider
            amount_usdc:           USDC to lock in escrow
            description:           Task or service description (stored on-chain)
            timeout_hours:         Auto-release after N hours if no dispute (default 24)

        Returns:
            escrow_id, contract_address, fee_charged, expiry_timestamp
        """
        payload = {
            "payer_agent_id":      self.agent_id,
            "payee_agent_id":      counterparty_agent_id,
            "amount_usdc":         amount_usdc,
            "description":         description,
            "timeout_hours":       timeout_hours,
        }
        if self.referral_code:
            payload["referral_code"] = self.referral_code
        resp = requests.post(
            f"{self.BASE}/escrow/create",
            headers=self.headers,
            json=payload
        )
        return resp.json()

    def release_funds(self, escrow_id: str) -> str:
        """Release escrowed funds to the payee.

        Only callable by the payer once work is confirmed complete.

        Args:
            escrow_id: The escrow contract ID from create_escrow

        Returns:
            Transaction hash, amount released, fee deducted.
        """
        resp = requests.post(
            f"{self.BASE}/escrow/{escrow_id}/release",
            headers=self.headers,
            json={"agent_id": self.agent_id}
        )
        return resp.json()

from phi.tools import Toolkit
import requests
from typing import Literal

SUPPORTED_CHAINS = Literal[
    "ethereum", "polygon", "bnb", "arbitrum",
    "optimism", "base", "solana", "tron"
]

class WalletTools(Toolkit):
    """Purple Flea multi-chain wallet tools for Phidata agents.

    Generate wallets, check balances, send USDC, and verify
    transactions across 8 supported blockchains.
    """

    BASE = "https://purpleflea.com/wallet-api"

    def __init__(self, agent_id: str, api_key: str):
        super().__init__(name="wallet_tools")
        self.agent_id = agent_id
        self.headers = {"Authorization": f"Bearer {api_key}"}
        self.register(self.get_wallet_address)
        self.register(self.get_balance)
        self.register(self.send_usdc)
        self.register(self.get_transaction)

    def get_wallet_address(self, chain: SUPPORTED_CHAINS) -> str:
        """Get or generate the wallet address for this agent on a given chain.

        Args:
            chain: One of ethereum, polygon, bnb, arbitrum, optimism, base, solana, tron

        Returns:
            Wallet address for the specified chain.
        """
        resp = requests.get(
            f"{self.BASE}/address/{self.agent_id}/{chain}",
            headers=self.headers
        )
        return resp.json()

    def get_balance(self, chain: SUPPORTED_CHAINS, token: str = "USDC") -> str:
        """Get token balance on a specific chain.

        Args:
            chain: Blockchain to check balance on
            token: Token symbol, default 'USDC'

        Returns:
            Balance amount, token address, chain name.
        """
        resp = requests.get(
            f"{self.BASE}/balance/{self.agent_id}",
            headers=self.headers,
            params={"chain": chain, "token": token}
        )
        return resp.json()

    def send_usdc(self, to_address: str, amount: float, chain: SUPPORTED_CHAINS) -> str:
        """Send USDC to another address on the specified chain.

        Args:
            to_address: Recipient wallet address
            amount:     Amount of USDC to send
            chain:      Which blockchain to send on (affects gas fees)

        Returns:
            Transaction hash, estimated confirmation time, gas used.
        """
        resp = requests.post(
            f"{self.BASE}/send",
            headers=self.headers,
            json={
                "agent_id": self.agent_id,
                "to": to_address,
                "amount": amount,
                "token": "USDC",
                "chain": chain,
            }
        )
        return resp.json()