ank-agents

pub fn swap_exact_in(
    zero_for_one: bool,
    amount_in_e18: u128,
    min_out_e18: u128,
) -> Action

use ank_agents::*;
use ank_engine::Engine;

let mut engine = Engine::default();
// ... initialize engine with protocols, users, etc. ...

let mut runner = AbmRunner::new();

// Register agents
runner.register(Box::new(NoiseTraderAgent {
    user: 1,
    target: "uniswap-v3".into(),
    mean_notional_e18: 1_000_000_000_000_000_000u128, // 1 token
}));

runner.register(Box::new(DexArbAgent {
    user: 2,
    dex_a: "uniswap-v3".into(),
    dex_b: "sushiswap".into(),
    threshold_bps: 50, // 0.5% gap triggers arb
}));

// Initialize agents
runner.init(&engine)?;

// Run simulation
for _ in 0..100 {
    runner.tick(&mut engine)?;
}

use ank_agents::*;

struct MarketMaker {
    user: UserId,
    target: String,
    spread_bps: u32,
}

impl Agent for MarketMaker {
    fn name(&self) -> &'static str {
        "market_maker"
    }
    
    fn stride(&self) -> u64 {
        10 // Run every 10 ticks
    }
    
    fn step(&mut self, ctx: EngineCtx, world: &WorldView) -> Vec<PlannedTx> {
        let mut plans = vec![];
        
        // Read market state
        if let Some(market) = world.markets.get(&self.target) {
            let mid_price = market.get("mid_e18")
                .and_then(|v| v.as_str())
                .and_then(|s| s.parse::<u128>().ok())
                .unwrap_or(0);
            
            if mid_price > 0 {
                // Place bid and ask around mid
                let spread = (mid_price * self.spread_bps as u128) / 10_000;
                
                // Buy side
                plans.push(PlannedTx::new(
                    self.user,
                    Tx {
                        to: self.target.clone(),
                        action: dex_actions::swap_exact_in(
                            true,
                            1_000_000_000_000_000_000u128,
                            0,
                        ),
                        gas_limit: Some(200_000),
                    },
                    1,
                    10,
                ));
                
                // Sell side
                plans.push(PlannedTx::new(
                    self.user,
                    Tx {
                        to: self.target.clone(),
                        action: dex_actions::swap_exact_in(
                            false,
                            1_000_000_000_000_000_000u128,
                            0,
                        ),
                        gas_limit: Some(200_000),
                    },
                    1,
                    10,
                ));
            }
        }
        
        plans
    }
}

use ank_agents::*;

/// First-come, first-served builder (no MEV)
struct FcfsBuilder;

impl BlockBuilder for FcfsBuilder {
    fn build(&mut self, _ctx: EngineCtx, mut plans: Vec<PlannedTx>) -> Vec<(UserId, TxBundle)> {
        // Sort by agent_idx and seq only (arrival order)
        plans.sort_by_key(|p| (p.agent_idx, p.seq));
        
        let mut grouped: IndexMap<UserId, Vec<Tx>> = IndexMap::new();
        for p in plans {
            grouped.entry(p.user).or_default().push(p.tx);
        }
        
        grouped
            .into_iter()
            .map(|(u, txs)| (u, TxBundle { txs }))
            .collect()
    }
}

// Use custom builder
let runner = AbmRunner::new()
    .with_builder(Box::new(FcfsBuilder));

impl Agent for MyAgent {
    fn step(&mut self, ctx: EngineCtx, world: &WorldView) -> Vec<PlannedTx> {
        // Check user balance
        if let Some(balances) = world.portfolios.get(&self.user) {
            if let Some(eth_balance) = balances.get(&TOKEN_ETH) {
                let eth_float = *eth_balance as f64 / 1e18;
                println!("ETH balance: {:.4}", eth_float);
                
                // Only trade if sufficient balance
                if *eth_balance > 1_000_000_000_000_000_000u128 {
                    // ... create trades ...
                }
            }
        }
        
        vec![]
    }
}

// Create multiple noise traders with different behaviors
for i in 0..10 {
    runner.register(Box::new(NoiseTraderAgent {
        user: 100 + i,
        target: "uniswap-v3".into(),
        mean_notional_e18: (1_000 + i * 100) * 1_000_000_000_000_000u128,
    }));
}

// Add arbitrageurs
for i in 0..3 {
    runner.register(Box::new(DexArbAgent {
        user: 200 + i,
        dex_a: "uniswap-v3".into(),
        dex_b: "sushiswap".into(),
        threshold_bps: 25 + i * 25, // Different sensitivity
    }));
}

// Add MEV bots
runner.register(Box::new(SandwichBot {
    user: 300,
    target: "uniswap-v3".into(),
}));

(gas_bid DESC, priority DESC, agent_idx ASC, seq ASC)