TideFi PropAMM

function quote(address tokenIn, address tokenOut, uint256 maxAmountIn, UFixed18 limitPrice)
    external
    view
    returns (uint256 amountIn, uint256 amountOut);

function swap(
    address tokenIn,
    address tokenOut,
    uint256 maxAmountIn,
    uint256 minAmountOut,
    UFixed18 limitPrice,
    address to,
    bytes calldata callbackData
) external returns (uint256 amountIn, uint256 amountOut);

function swap(
    address tokenIn,
    address tokenOut,
    uint256 maxAmountIn,
    uint256 minAmountOut,
    UFixed18 limitPrice,
    address to
) external returns (uint256 amountIn, uint256 amountOut);

interface ITideFiCallback {
    function tidefiSwap(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        bytes calldata data
    ) external;
}

limitPrice = humanPrice * 10**decimalsIn / 10**decimalsOut * 1e18

2000 * 10**6 / 10**18 * 1e18 = 2000e6

(1/2000) * 10**18 / 10**6 * 1e18 = 5e26

{
  "server_time_ms": 1788700122000,
  "chain_id": 8453,
  "tidefi": "0x71def100007a540305dd65d1034d10e809679fd5",
  "engine": "<tidefi engine>",
  "quote_asset_symbol": "USD",
  "quote_asset_decimals": 18,
  "assets": [
    {"symbol": "WETH", "token_address": "0x4200000000000000000000000000000000000006", "token_decimals": 18},
    {"symbol": "USDC", "token_address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", "token_decimals": 6}
  ]
}

{"jsonrpc": "2.0", "method": "tidefi_quote", "id": 1, "params": {
  "token_in": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
  "token_out": "0x4200000000000000000000000000000000000006",
  "amount_in": 50.0,
  "caller": "0x6ff5693b99212da76ad316178a184ab56d299b43",
  "priority_fee_ratio": 0.1
}}

{"jsonrpc": "2.0", "result": {
  "token_in": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
  "token_out": "0x4200000000000000000000000000000000000006",
  "amount_in": 50.0,
  "amount_out": 0.019984301571884605,
  "amount_in_subunits": "50000000",
  "amount_out_subunits": "19984301571884605",
  "price_out_per_in": 0.0003996860314376921,
  "book_timestamp_ms": 1788700122765,
  "landed": false
}, "id": 1}

{"jsonrpc": "2.0", "method": "tidefi_subscribe", "params": ["orderbook_updates"], "id": null}

{
  "symbol": "WETH",
  "base_token": "0x4200000000000000000000000000000000000006",
  "timestamp_ms": 1788700122581,
  "landed": false,
  "mid_price": 2500.3857,
  "bids": [{"price": 2499.848876953125, "quantity": 0.06342601776123047}],
  "asks": [{"price": 2500.936279296875, "quantity": 0.06865961104631424}],
  "stale_timestamp_ms": 1788700182000
}

//! Minimal taker API client: connects, subscribes to orderbook updates, prints every
//! message, reconnects on disconnect. With the quote flags: requests one quote instead,
//! prints the reply, exits.

use std::time::Duration;

use clap::Parser;
use futures::{SinkExt, StreamExt};
use serde_json::{Value, json};
use tokio_tungstenite::{
    connect_async,
    tungstenite::{Message, client::IntoClientRequest},
};

#[derive(Debug, Parser)]
struct Cli {
    /// The taker API websocket URL.
    #[arg(long)]
    url: String,

    /// The bearer token.
    #[arg(long)]
    auth_token: String,

    /// Request a quote on connect: the token in address.
    #[arg(long, requires_all = ["quote_token_out", "quote_amount_in", "quote_caller", "quote_priority_fee_ratio"])]
    quote_token_in: Option<String>,

    /// The token out address.
    #[arg(long)]
    quote_token_out: Option<String>,

    /// The amount in, whole token units.
    #[arg(long)]
    quote_amount_in: Option<f64>,

    /// The address that will call TideFi.swap.
    #[arg(long)]
    quote_caller: Option<String>,

    /// Priority fee as a fraction of the base fee.
    #[arg(long)]
    quote_priority_fee_ratio: Option<f64>,
}

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let cli = Cli::parse();
    let subscribe = json!({
        "jsonrpc": "2.0",
        "method": "tidefi_subscribe",
        "params": ["orderbook_updates"],
        "id": null,
    })
    .to_string();

    let quote = cli.quote_token_in.as_ref().map(|quote_token_in| {
        json!({
            "jsonrpc": "2.0",
            "method": "tidefi_quote",
            "params": {
                "token_in": quote_token_in,
                "token_out": cli.quote_token_out,
                "amount_in": cli.quote_amount_in,
                "caller": cli.quote_caller,
                "priority_fee_ratio": cli.quote_priority_fee_ratio,
            },
            "id": 1,
        })
        .to_string()
    });

    loop {
        let mut request = cli.url.as_str().into_client_request()?;
        request.headers_mut().insert(
            "authorization",
            format!("Bearer {}", cli.auth_token).parse()?,
        );
        let mut ws = match connect_async(request).await {
            Ok((ws, _)) => ws,
            Err(err) => {
                eprintln!("connection failed, retrying: {err}");
                tokio::time::sleep(Duration::from_secs(1)).await;
                continue;
            }
        };

        loop {
            let Some(message) = ws.next().await else {
                eprintln!("connection closed, reconnecting");
                break;
            };
            let message = match message {
                Ok(message) => message,
                Err(err) => {
                    eprintln!("connection error, reconnecting: {err}");
                    break;
                }
            };
            if !message.is_text() {
                continue;
            }
            let message: Value = serde_json::from_str(message.to_text()?)?;
            match message["method"].as_str() {
                Some("tidefi_error") => eyre::bail!("{}", message["params"]["error"]),
                Some("tidefi_markets") => match &quote {
                    Some(quote) => ws.send(Message::text(quote.clone())).await?,
                    None => {
                        println!("tidefi_markets {}", message["params"]);
                        ws.send(Message::text(subscribe.clone())).await?;
                    }
                },
                Some(method) => println!("{method} {}", message["params"]),
                // The quote reply carries `result` or `error` instead of a method.
                None => {
                    println!("{message}");
                    return Ok(());
                }
            }
        }
    }
}

cargo run --example client -- --url <Taker API endpoint> --auth-token <token>

cargo run --example client -- \
    --url <Taker API endpoint> \
    --auth-token <token> \
    --quote-token-in 0x833589fcd6edb6e08f4c7c32d4f71b54bda02913 \
    --quote-token-out 0x4200000000000000000000000000000000000006 \
    --quote-amount-in 50 \
    --quote-caller <your router address> \
    --quote-priority-fee-ratio 0.1