Pool Functions

import { Hadron, Q32_ONE } from "@hadron-so/sdk";

const { instructions, poolAddress, seed } = Hadron.initialize(payer, {
  mintX,
  mintY,
  authority: payer,
  initialMidpriceQ32: Q32_ONE, // midprice = 1.0
});

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

// After confirmation, load the pool
const pool = await Hadron.load(connection, poolAddress);

const pool = await Hadron.load(connection, poolAddress);

const pool = await Hadron.loadFromSeed(connection, seed, mintX, mintY);

await pool.refetchStates();

const mid = pool.getMidprice(); // e.g. 1.0023

const factor = pool.getSpreadFactor(); // e.g. 0.9995
const bps = pool.getSpreadBps();       // e.g. 5

const slots = pool.getActiveCurveSlots();
// { priceBid: 0, priceAsk: 0, riskBid: 0, riskAsk: 0 }

const curves = pool.getActiveCurves();
// curves.priceBid.points, curves.priceAsk.points, etc.

const curve = pool.getCurveSlot(CurveType.PriceBid, 1);

const ix = pool.swap(user, {
  isX: true,             // true = sell token X for Y, false = sell Y for X
  amountIn: 1_000_000n,
  minOut: 0n,
  feeRecipient: feePk,
});

const ix = pool.deposit(user, {
  amountX: 1_000_000n,
  amountY: 2_000_000n,
});

const ix = pool.withdraw(user, {
  amountX: 500_000n,
  amountY: 1_000_000n,
});

const ix = pool.setCurve(authority, {
  side: Side.Bid,
  defaultInterpolation: Interpolation.Linear,
  points: [
    { amountIn: 100_000n, priceFactor: 0.99 },
    { amountIn: 500_000n, priceFactor: 0.95 },
  ],
  slot: 0,
});

pool.switchPriceCurve(authority, { side: Side.Bid, slot: 1 });
pool.switchRiskCurve(authority, { side: Side.Ask, slot: 2 });

pool.submitCurveUpdates(authority, [
  { curveType: CurveType.PriceBid, opKind: CurveUpdateOpKind.Edit, pointIndex: 0, ... },
]);
pool.applyCurveUpdates(authority);

pool.updateMidprice(authority, { midpriceQ32: newMidQ32 });

pool.updateBaseSpread(authority, { spreadFactorQ32: newSpreadQ32 });

pool.updateMidpriceAndBaseSpread(authority, {
  midpriceQ32: newMidQ32,
  spreadFactorQ32: newSpreadQ32,
});

pool.nominateAuthority(authority, { newAuthority: newPk, expirySlot: 300_000_000n });
// ... newAuthority signs:
pool.acceptAuthority(newPk);

pool.setPoolState(authority, { newState: PoolState.Paused });

pool.updateDeltaStaleness(authority, { deltaStaleness: 150 });

pool.closePool(authority);