Pool Functions

use hadron_sdk::hadron::Hadron;
use hadron_sdk::types::InitializeParams;
use hadron_sdk::helpers::math::to_q32;
use hadron_sdk::constants::HADRON_PROGRAM_ID;

let (instructions, pool_address, seed) = Hadron::initialize(&payer, &InitializeParams {
    seed: None,                              // auto-generated
    mint_x,
    mint_y,
    authority: payer,
    initial_midprice_q32: to_q32(1.0),       // midprice = 1.0
    oracle_mode: None,                       // default: Authority
    max_prefab_slots: None,                  // default: 10
    max_curve_points: None,                  // default: 16
    token_program_x: None,                   // default: SPL Token
    token_program_y: None,                   // default: SPL Token
}, &HADRON_PROGRAM_ID);

// Send the instructions (group into transactions as needed)

use hadron_sdk::hadron::Hadron;

let pool = Hadron::from_accounts(
    pool_address,
    &config_data,
    &oracle_data,
    &curve_meta_data,
    &curve_prefabs_data,
)?;

let mid = pool.get_midprice(); // e.g. 1.0023

let factor = pool.get_spread_factor(); // e.g. 0.9995
let bps    = pool.get_spread_bps();    // e.g. 5.0

let slots = pool.get_active_curve_slots();
// ActiveCurveSlots { price_bid: 0, price_ask: 0, risk_bid: 0, risk_ask: 0 }

let curves = pool.get_active_curves()?;
// curves.price_bid.points, curves.price_ask.points, etc.

use hadron_sdk::types::CurveType;

let curve = pool.get_curve_slot(CurveType::PriceBid, 1)?;

use hadron_sdk::types::SwapParams;

let ix = pool.swap(&user, &SwapParams {
    is_x: true,               // true = sell X for Y, false = sell Y for X
    amount_in: 1_000_000,
    min_out: 0,                // set > 0 for slippage protection
    fee_recipient,
    expiration: None,
});

use hadron_sdk::types::DepositParams;

let ix = pool.deposit(&user, &DepositParams {
    amount_x: 1_000_000,
    amount_y: 2_000_000,
    expiration: None,
});

use hadron_sdk::types::WithdrawParams;

let ix = pool.withdraw(&user, &WithdrawParams {
    amount_x: 500_000,
    amount_y: 1_000_000,
    expiration: None,
});

use hadron_sdk::types::*;
use hadron_sdk::helpers::math::to_q32;

let ix = pool.set_curve(&authority, &SetCurveParams {
    side: Side::Bid,
    default_interpolation: Interpolation::Linear,
    points: vec![
        SetCurvePointInput {
            amount_in: 100_000,
            price_factor_q32: to_q32(0.99),
            interpolation: None,
            params: None,
        },
        SetCurvePointInput {
            amount_in: 500_000,
            price_factor_q32: to_q32(0.95),
            interpolation: None,
            params: None,
        },
    ],
    slot: Some(0),
    x_mode: None,
});

let ix1 = pool.switch_price_curve(&authority, &SwitchCurveParams { side: Side::Bid, slot: 1 });
let ix2 = pool.switch_risk_curve(&authority, &SwitchCurveParams { side: Side::Ask, slot: 2 });

let ix1 = pool.submit_curve_updates(&authority, &[
    CurveUpdateOp {
        curve_type: CurveType::PriceBid,
        op_kind: CurveUpdateOpKind::Edit,
        point_index: 0,
        interpolation: Interpolation::Linear,
        amount_in: 200_000,
        price_factor_q32: to_q32(0.98),
        params: [0; 4],
    },
]);
let ix2 = pool.apply_curve_updates(&authority);

use hadron_sdk::types::UpdateMidpriceParams;

let ix = pool.update_midprice(&authority, &UpdateMidpriceParams {
    midprice_q32: to_q32(1.05),
    sequence: None,
});

use hadron_sdk::types::UpdateBaseSpreadParams;

let ix = pool.update_base_spread(&authority, &UpdateBaseSpreadParams {
    spread_factor_q32: spread_bps_to_q32(5), // 5 bps
    sequence: None,
});

use hadron_sdk::types::UpdateMidpriceAndBaseSpreadParams;

let ix = pool.update_midprice_and_base_spread(&authority, &UpdateMidpriceAndBaseSpreadParams {
    midprice_q32: to_q32(1.05),
    spread_factor_q32: spread_bps_to_q32(5),
    sequence: None,
});

use hadron_sdk::types::NominateAuthorityParams;

let ix1 = pool.nominate_authority(&authority, &NominateAuthorityParams {
    new_authority: new_pk,
    expiry_slot: 300_000_000,
});
// ... new_authority signs:
let ix2 = pool.accept_authority(&new_pk);

use hadron_sdk::types::{SetPoolStateParams, PoolState};

let ix = pool.set_pool_state(&authority, &SetPoolStateParams {
    new_state: PoolState::Paused,
});

use hadron_sdk::types::UpdateDeltaStalenessParams;

let ix = pool.update_delta_staleness(&authority, &UpdateDeltaStalenessParams {
    delta_staleness: 150,
});

let ix = pool.close_pool(&authority);