Uniswap V3 Protocol

pub struct PoolConfig {
    pub token0: TokenId,
    pub token1: TokenId,
    pub fee_bps: u16,      // Fee in basis points (e.g., 30 = 0.30%)
    pub tick_spacing: i32, // Tick spacing (e.g., 60 for 0.3% pools)
}

use ank_protocol_uniswap_v3::{Uniswapv3, PoolConfig};
use ank_accounting::TokenId;

let uni = Uniswapv3::new(PoolConfig {
    token0: TokenId(1), // ETH
    token1: TokenId(2), // USDC
    fee_bps: 30,        // 0.30% fee
    tick_spacing: 60,
});

pub struct Pool {
    current_tick: i32,
    sqrt_price_x96: u128,   // Current sqrt(price) in Q96 format
    liquidity: u128,        // Active liquidity at current price
    positions: IndexMap<u64, Position>,
    ticks: IndexMap<i32, i128>, // tick -> net_liquidity_delta
    fee_growth_global_0_x128: u128,
    fee_growth_global_1_x128: u128,
}

pub struct Position {
    pub owner: UserId,
    pub tick_lower: i32,
    pub tick_upper: i32,
    pub liquidity: u128,
    pub fees_owed_0: u128,
    pub fees_owed_1: u128,
}

{
  "total_liquidity": "1000000000000000000000",
  "position_count": 2,
  "positions": [
    {
      "id": 1,
      "tick_lower": -887220,
      "tick_upper": 887220,
      "liquidity": "500000000000000000000",
      "fees_owed_0": "0",
      "fees_owed_1": "0"
    },
    {
      "id": 2,
      "tick_lower": -60,
      "tick_upper": 60,
      "liquidity": "500000000000000000000",
      "fees_owed_0": "100000000000000000",
      "fees_owed_1": "200000"
    }
  ]
}

{
  "token0": 1,
  "token1": 2,
  "fee_bps": 30,
  "tick_spacing": 60,
  "current_tick": 0,
  "sqrt_price_x96": "79228162514264337593543950336",
  "liquidity": "1000000000000000000000",
  "position_count": 2,
  "fee_growth_global_0": "0",
  "fee_growth_global_1": "0"
}

use ank_protocol::{Action, Protocol};

// Mint position around current price (±1%)
let result = uni.execute(
    ts,
    user_id,
    Action::Custom(serde_json::json!({
        "kind": "mint_position",
        "tick_lower": -60,
        "tick_upper": 60,
        "amount0_desired": "10000000000000000000",
        "amount1_desired": "20000000000"
    })),
)?;

// Parse position_id from events
let event_msg = result.events[0].to_string();
let position_id = extract_position_id(&event_msg);

// Swap 1 ETH for USDC, expect at least 1900 USDC
let result = uni.execute(
    ts,
    user_id,
    Action::Custom(serde_json::json!({
        "kind": "swap_exact_in",
        "token_in": 1,
        "amount_in": "1000000000000000000",
        "min_out": "1900000000"
    })),
);

match result {
    Ok(out) => {
        let usdc_received = out.delta.0[&TokenId(2)];
        println!("Received {} USDC", usdc_received);
    }
    Err(e) if e.to_string().contains("slippage") => {
        println!("Slippage exceeded, retrying with higher min_out...");
    }
    Err(e) => return Err(e),
}

// Provide liquidity across all ticks
uni.execute(
    ts,
    user_id,
    Action::Custom(serde_json::json!({
        "kind": "mint_position",
        "tick_lower": -887220, // MIN_TICK (adjusted for tick_spacing)
        "tick_upper": 887220,  // MAX_TICK (adjusted for tick_spacing)
        "amount0_desired": "100000000000000000000",
        "amount1_desired": "200000000000"
    })),
)?;

liquidity = min(
    get_liquidity_for_amount0(sqrt_price_current, sqrt_price_upper, amount0),
    get_liquidity_for_amount1(sqrt_price_lower, sqrt_price_current, amount1)
)

// Token0 (when price moves from A to B, B > A)
amount0 = liquidity * (1/sqrt_B - 1/sqrt_A)

// Token1 (when price moves from A to B, B > A)
amount1 = liquidity * (sqrt_B - sqrt_A)

// Zero for one (token0 in, token1 out)
sqrt_price_next = get_next_sqrt_price_from_input(
    sqrt_price_current,
    liquidity,
    amount_in_after_fee,
    zero_for_one
)

amount_out = get_amount1_delta(sqrt_price_next, sqrt_price_current, liquidity)

// Valid ticks for tick_spacing = 60:
// ..., -120, -60, 0, 60, 120, ...

// Invalid: -55, 61, 100

price = 1.0001^tick
sqrt_price_x96 = sqrt(price) * 2^96

// Pool 1: ETH/USDC
let out1 = uni_eth_usdc.execute(
    ts,
    user_id,
    Action::Custom(json!({
        "kind": "swap_exact_in",
        "token_in": 1,
        "amount_in": "1000000000000000000",
        "min_out": "1900000000"
    })),
)?;

let usdc_out = out1.delta.0[&TokenId(2)];

// Pool 2: USDC/DAI
let out2 = uni_usdc_dai.execute(
    ts,
    user_id,
    Action::Custom(json!({
        "kind": "swap_exact_in",
        "token_in": 2,
        "amount_in": usdc_out.to_string(),
        "min_out": "1850000000000000000000"
    })),
)?;