@hadron-fi/sdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,676 @@
+import { PublicKey, Connection, TransactionInstruction } from '@solana/web3.js';
+
+declare enum PoolState {
+    Uninitialized = 0,
+    Initialized = 1,
+    Paused = 2,
+    WithdrawOnly = 3
+}
+declare enum OracleMode {
+    /** Off-chain authority updates the oracle */
+    Authority = 0,
+    /** Midprice computed from vault ratio (vault_y / vault_x) */
+    Relative = 1
+}
+declare enum Interpolation {
+    Step = 0,
+    Linear = 1,
+    MarginalStep = 2,
+    Hyperbolic = 3,
+    Quadratic = 4,
+    Cubic = 5
+}
+declare enum CurveType {
+    PriceBid = 0,
+    PriceAsk = 1,
+    RiskBid = 2,
+    RiskAsk = 3
+}
+declare enum CurveXMode {
+    /** Price: absolute tokens. Risk: percent Q32. */
+    Native = 0,
+    /** Price: percent of vault Q32. Risk: absolute tokens. */
+    Alternate = 1
+}
+declare enum RiskMode {
+    Virtual = 0,
+    Integrated = 1
+}
+declare enum CurveUpdateOpKind {
+    Edit = 0,
+    Add = 1,
+    Remove = 2
+}
+declare enum Side {
+    Bid = 0,
+    Ask = 1
+}
+interface DecodedConfig {
+    state: PoolState;
+    seed: bigint;
+    authority: PublicKey;
+    mintX: PublicKey;
+    mintY: PublicKey;
+    configBump: number;
+    curveMeta: PublicKey;
+    spreadConfigInitialized: boolean;
+    deltaStaleness: number;
+    oracleMode: OracleMode;
+    pendingAuthority: PublicKey;
+    nominationExpiry: bigint;
+    tokenProgramX: PublicKey;
+    tokenProgramY: PublicKey;
+}
+interface DecodedMidpriceOracle {
+    authority: PublicKey;
+    sequence: bigint;
+    midpriceQ32: bigint;
+    baseSpreadQ32: bigint;
+    lastUpdateSlot: bigint;
+}
+interface DecodedCurveMeta {
+    authority: PublicKey;
+    activePriceBidSlot: number;
+    activePriceAskSlot: number;
+    activeRiskBidSlot: number;
+    activeRiskAskSlot: number;
+    initializedSlots: Uint8Array;
+    maxPrefabSlots: number;
+    maxCurvePoints: number;
+}
+interface DecodedFeeConfig {
+    initialized: boolean;
+    feePpm: number;
+    bump: number;
+    feeAdmin: PublicKey;
+    feeRecipient: PublicKey;
+}
+interface DecodedCurveUpdates {
+    authority: PublicKey;
+    curveMeta: PublicKey;
+    numOps: number;
+    ops: CurveUpdateOp[];
+}
+interface CurvePoint {
+    xIn: bigint;
+    priceFactorQ32: bigint;
+    interpolation: Interpolation;
+    params: Uint8Array;
+}
+interface CurveSide {
+    numPoints: number;
+    defaultInterpolation: Interpolation;
+    xMode: CurveXMode;
+    riskMode: RiskMode;
+    points: CurvePoint[];
+}
+interface CurveUpdateOp {
+    curveType: CurveType;
+    opKind: CurveUpdateOpKind;
+    pointIndex: number;
+    interpolation: Interpolation;
+    xIn: bigint;
+    priceFactorQ32: bigint;
+    params: Uint8Array;
+}
+interface InitializeParams {
+    /** Pool seed. If omitted, a random seed is generated automatically. */
+    seed?: bigint;
+    mintX: PublicKey;
+    mintY: PublicKey;
+    authority: PublicKey;
+    initialMidpriceQ32: bigint;
+    oracleMode?: OracleMode;
+    maxPrefabSlots?: number;
+    maxCurvePoints?: number;
+    /** Token program for mint X (defaults to TOKEN_PROGRAM_ID) */
+    tokenProgramX?: PublicKey;
+    /** Token program for mint Y (defaults to TOKEN_PROGRAM_ID) */
+    tokenProgramY?: PublicKey;
+}
+interface DepositParams {
+    amountX: bigint;
+    amountY: bigint;
+    expiration?: number;
+}
+interface WithdrawParams {
+    amountX: bigint;
+    amountY: bigint;
+    expiration?: number;
+}
+interface SwapParams {
+    isX: boolean;
+    amountIn: bigint;
+    minOut: bigint;
+    feeRecipient: PublicKey;
+    expiration?: number;
+}
+interface SetCurvePointInput {
+    xIn: bigint;
+    /** Price factor as floating point (e.g. 0.99). Converted to Q32 internally. */
+    priceFactor: number;
+    interpolation?: Interpolation;
+    params?: Uint8Array;
+}
+interface SetCurveParams {
+    side: Side;
+    defaultInterpolation: Interpolation;
+    points: SetCurvePointInput[];
+    slot?: number;
+    xMode?: CurveXMode;
+}
+/** Params for setting price curve on both bid and ask in one call (returns two instructions). */
+interface SetCurveBothParams {
+    bid: Omit<SetCurveParams, "side">;
+    ask: Omit<SetCurveParams, "side">;
+}
+interface SetRiskCurvePointInput {
+    /** Percent of base vault (0.0 to 1.0) — converted to Q32 internally */
+    pctBase: number;
+    /** Price factor as floating point */
+    priceFactor: number;
+    interpolation?: Interpolation;
+    params?: Uint8Array;
+}
+interface SetRiskCurveAbsolutePointInput {
+    /** Absolute vault balance in token atoms */
+    vaultBalance: bigint;
+    priceFactor: number;
+    interpolation?: Interpolation;
+    params?: Uint8Array;
+}
+interface SetRiskCurveParams {
+    side: Side;
+    defaultInterpolation: Interpolation;
+    points: SetRiskCurvePointInput[];
+    slot?: number;
+    xMode?: CurveXMode;
+    riskMode?: RiskMode;
+}
+/** Params for setting risk curve (percent x-axis) on both bid and ask in one call. */
+interface SetRiskCurveBothParams {
+    bid: Omit<SetRiskCurveParams, "side">;
+    ask: Omit<SetRiskCurveParams, "side">;
+}
+interface SetRiskCurveAbsoluteParams {
+    side: Side;
+    defaultInterpolation: Interpolation;
+    points: SetRiskCurveAbsolutePointInput[];
+    slot?: number;
+    riskMode?: RiskMode;
+}
+/** Params for setting risk curve (absolute x-axis) on both bid and ask in one call. */
+interface SetRiskCurveAbsoluteBothParams {
+    bid: Omit<SetRiskCurveAbsoluteParams, "side">;
+    ask: Omit<SetRiskCurveAbsoluteParams, "side">;
+}
+interface UpdateMidpriceParams {
+    midpriceQ32: bigint;
+    sequence?: bigint;
+}
+interface UpdateBaseSpreadParams {
+    baseSpreadQ32: bigint;
+    sequence?: bigint;
+}
+interface UpdateMidpriceAndBaseSpreadParams {
+    midpriceQ32: bigint;
+    baseSpreadQ32: bigint;
+    sequence?: bigint;
+}
+interface SwitchCurveParams {
+    side: Side;
+    slot: number;
+}
+interface NominateAuthorityParams {
+    newAuthority: PublicKey;
+    expirySlot: bigint;
+}
+interface SetQuotingAuthorityParams {
+    newQuotingAuthority: PublicKey;
+    /** If provided, also updates SpreadConfig.admin */
+    spreadConfigPda?: PublicKey;
+}
+interface InitializeFeeConfigParams {
+    feePpm: number;
+    feeAdmin: PublicKey;
+    feeRecipient: PublicKey;
+}
+interface UpdateFeeConfigParams {
+    /** Pass null for no change (sends u32::MAX) */
+    feePpm: number | null;
+    /** Pass null for no change (sends zeros) */
+    feeRecipient: PublicKey | null;
+}
+interface RotateFeeAdminParams {
+    newFeeAdmin: PublicKey;
+}
+interface SetPoolStateParams {
+    newState: PoolState;
+}
+interface UpdateDeltaStalenessParams {
+    deltaStaleness: number;
+}
+interface InitializeSpreadConfigParams {
+    admin: PublicKey;
+}
+interface SpreadTriggerInput {
+    account: PublicKey;
+    spreadBps: number;
+}
+interface UpdateSpreadConfigParams {
+    triggers: SpreadTriggerInput[];
+}
+interface AllocateCurvePrefabsParams {
+    seed: bigint;
+    mintX: PublicKey;
+    mintY: PublicKey;
+    maxPrefabSlots?: number;
+    maxCurvePoints?: number;
+}
+interface PoolAddresses {
+    config: PublicKey;
+    configBump: number;
+    midpriceOracle: PublicKey;
+    curveMeta: PublicKey;
+    curvePrefabs: PublicKey;
+    curveUpdates: PublicKey;
+    vaultX: PublicKey;
+    vaultY: PublicKey;
+}
+
+/**
+ * Main SDK class for interacting with a Hadron pool.
+ *
+ * Usage:
+ * ```ts
+ * const pool = await Hadron.load(connection, poolAddress);
+ * const midprice = pool.getMidprice();
+ * const ix = pool.swap(user, params);
+ * ```
+ */
+declare class Hadron {
+    readonly programId: PublicKey;
+    readonly poolAddress: PublicKey;
+    readonly addresses: PoolAddresses;
+    config: DecodedConfig;
+    oracle: DecodedMidpriceOracle;
+    curveMeta: DecodedCurveMeta;
+    curvePrefabsData: Uint8Array;
+    private connection;
+    constructor(connection: Connection, poolAddress: PublicKey, addresses: PoolAddresses, config: DecodedConfig, oracle: DecodedMidpriceOracle, curveMeta: DecodedCurveMeta, curvePrefabsData: Uint8Array, programId?: PublicKey);
+    /**
+     * Load a Hadron instance from an existing pool address.
+     * Fetches all required accounts from the chain.
+     */
+    static load(connection: Connection, poolAddress: PublicKey): Promise<Hadron>;
+    /**
+     * Load a Hadron instance from pool identity (seed + mints).
+     */
+    static loadFromSeed(connection: Connection, seed: bigint, mintX: PublicKey, mintY: PublicKey): Promise<Hadron>;
+    /**
+     * Build all instructions needed to initialize a new pool.
+     *
+     * Returns the allocate + initialize instructions and the derived pool address.
+     * The caller is responsible for grouping them into transactions and sending.
+     * The allocate instruction(s) must be confirmed before the initialize instruction.
+     *
+     * After the pool is live on-chain, load it with `Hadron.load(connection, poolAddress)`.
+     *
+     * ```ts
+     * const { instructions, poolAddress, seed } = Hadron.initialize(payer, {
+     *   mintX,
+     *   mintY,
+     *   authority: payer,
+     *   initialMidpriceQ32: Q32_ONE,
+     * });
+     * ```
+     */
+    static initialize(payer: PublicKey, params: InitializeParams): {
+        instructions: TransactionInstruction[];
+        poolAddress: PublicKey;
+        seed: bigint;
+    };
+    /** Generate a random u64 seed. */
+    private static randomSeed;
+    /** Re-fetch all account state from the chain. */
+    refetchStates(): Promise<void>;
+    /** Get midprice as a floating-point number. */
+    getMidprice(): number;
+    /** Get base spread as a floating-point number. */
+    getBaseSpread(): number;
+    /** Get the currently active curve slot indices. */
+    getActiveCurveSlots(): {
+        priceBid: number;
+        priceAsk: number;
+        riskBid: number;
+        riskAsk: number;
+    };
+    /** Decode the currently active curves from prefabs data. */
+    getActiveCurves(): {
+        priceBid: CurveSide;
+        priceAsk: CurveSide;
+        riskBid: CurveSide;
+        riskAsk: CurveSide;
+    };
+    /** Decode a specific curve slot. */
+    getCurveSlot(curveType: CurveType, slot: number): CurveSide;
+    /** Build deposit instruction. */
+    deposit(user: PublicKey, params: DepositParams): TransactionInstruction;
+    /** Build withdraw instruction. */
+    withdraw(user: PublicKey, params: WithdrawParams): TransactionInstruction;
+    /** Build swap instruction. */
+    swap(user: PublicKey, params: SwapParams): TransactionInstruction;
+    /** Build set curve instruction. */
+    setCurve(authority: PublicKey, params: SetCurveParams): TransactionInstruction;
+    /** Build set risk curve instruction (percent-based x-axis). */
+    setRiskCurve(authority: PublicKey, params: SetRiskCurveParams): TransactionInstruction;
+    /** Build set risk curve instruction (absolute x-axis). */
+    setRiskCurveAbsolute(authority: PublicKey, params: SetRiskCurveAbsoluteParams): TransactionInstruction;
+    /** Build set curve instructions for both bid and ask. Returns [bidIx, askIx]. */
+    setCurveBoth(authority: PublicKey, params: SetCurveBothParams): [TransactionInstruction, TransactionInstruction];
+    /** Build set risk curve instructions for both bid and ask. Returns [bidIx, askIx]. */
+    setRiskCurveBoth(authority: PublicKey, params: SetRiskCurveBothParams): [TransactionInstruction, TransactionInstruction];
+    /** Build set risk curve (absolute x-axis) instructions for both bid and ask. Returns [bidIx, askIx]. */
+    setRiskCurveAbsoluteBoth(authority: PublicKey, params: SetRiskCurveAbsoluteBothParams): [TransactionInstruction, TransactionInstruction];
+    /** Build update midprice instruction. */
+    updateMidprice(authority: PublicKey, params: UpdateMidpriceParams): TransactionInstruction;
+    /** Build update base spread instruction. */
+    updateBaseSpread(authority: PublicKey, params: UpdateBaseSpreadParams): TransactionInstruction;
+    /** Build atomic update of midprice + base spread. */
+    updateMidpriceAndBaseSpread(authority: PublicKey, params: UpdateMidpriceAndBaseSpreadParams): TransactionInstruction;
+    /** Build switch price curve instruction (hot path). */
+    switchPriceCurve(authority: PublicKey, params: SwitchCurveParams): TransactionInstruction;
+    /** Build switch risk curve instruction (hot path). */
+    switchRiskCurve(authority: PublicKey, params: SwitchCurveParams): TransactionInstruction;
+    /** Build submit curve updates instruction (hot path). */
+    submitCurveUpdates(authority: PublicKey, ops: CurveUpdateOp[]): TransactionInstruction;
+    /** Build apply curve updates instruction. */
+    applyCurveUpdates(authority: PublicKey): TransactionInstruction;
+    /** Build nominate authority instruction. */
+    nominateAuthority(authority: PublicKey, params: NominateAuthorityParams): TransactionInstruction;
+    /** Build accept authority instruction. */
+    acceptAuthority(newAuthority: PublicKey): TransactionInstruction;
+    /** Build set pool state instruction. */
+    setPoolState(authority: PublicKey, params: SetPoolStateParams): TransactionInstruction;
+    /** Build update delta staleness instruction. */
+    updateDeltaStaleness(authority: PublicKey, params: UpdateDeltaStalenessParams): TransactionInstruction;
+    /** Build close pool instruction. */
+    closePool(authority: PublicKey): TransactionInstruction;
+}
+
+declare const HADRON_PROGRAM_ID: PublicKey;
+declare const CONFIG_SEED: Buffer<ArrayBuffer>;
+declare const MIDPRICE_ORACLE_SEED: Buffer<ArrayBuffer>;
+declare const CURVE_META_SEED: Buffer<ArrayBuffer>;
+declare const CURVE_PREFABS_SEED: Buffer<ArrayBuffer>;
+declare const CURVE_UPDATES_SEED: Buffer<ArrayBuffer>;
+declare const FEE_CONFIG_SEED: Buffer<ArrayBuffer>;
+declare const SPREAD_CONFIG_SEED: Buffer<ArrayBuffer>;
+declare const CONFIG_SIZE = 248;
+declare const MIDPRICE_ORACLE_SIZE = 64;
+declare const CURVE_META_SIZE = 48;
+declare const FEE_CONFIG_SIZE = 72;
+declare const CURVE_UPDATES_SIZE = 258;
+declare const CURVE_SIDE_HEADER = 8;
+declare const CURVE_POINT_LEN = 24;
+declare const DEFAULT_MAX_PREFAB_SLOTS = 10;
+declare const DEFAULT_MAX_CURVE_POINTS = 16;
+declare const ABSOLUTE_MAX_PREFAB_SLOTS = 16;
+declare const ABSOLUTE_MAX_CURVE_POINTS = 128;
+declare const MAX_SETCURVE_POINTS = 32;
+declare const MAX_CURVE_UPDATE_OPS = 8;
+/** Q32.32 representation of 1.0 */
+declare const Q32_ONE: bigint;
+declare const Discriminator: {
+    readonly Initialize: 0;
+    readonly Deposit: 1;
+    readonly Withdraw: 2;
+    readonly SwapExactIn: 3;
+    readonly SetCurve: 4;
+    readonly UpdateMidprice: 5;
+    readonly InitializeFeeConfig: 6;
+    readonly UpdateFeeConfig: 7;
+    readonly SetRiskCurve: 8;
+    readonly UpdateBaseSpread: 9;
+    readonly UpdateMidpriceAndBaseSpread: 10;
+    readonly SwitchPriceCurve: 11;
+    readonly SwitchRiskCurve: 12;
+    readonly InitializeSpreadConfig: 13;
+    readonly UpdateSpreadConfig: 14;
+    readonly UpdateDeltaStaleness: 15;
+    readonly NominateAuthority: 16;
+    readonly AcceptAuthority: 17;
+    readonly SubmitCurveUpdates: 18;
+    readonly ApplyCurveUpdates: 19;
+    readonly ClosePool: 20;
+    readonly SetPoolState: 21;
+    readonly AllocateCurvePrefabs: 22;
+    readonly SetQuotingAuthority: 23;
+    readonly RotateFeeAdmin: 24;
+};
+/** Per-point data in SetCurve/SetRiskCurve: u64 + u64 + u8 + 4 params = 21 bytes */
+declare const POINT_DATA_SIZE = 21;
+/** Per-op data in SubmitCurveUpdates: curve_type(1)+op_kind(1)+point_index(1)+interp(1)+x_in(8)+price(8)+params(4) = 24 bytes */
+declare const CURVE_UPDATE_OP_SIZE = 24;
+/** Compute CurvePrefabs account size for given pool parameters. */
+declare function curvePrefabsSize(maxSlots: number, maxPoints: number): number;
+
+declare function decodeConfig(data: Uint8Array): DecodedConfig;
+declare function decodeMidpriceOracle(data: Uint8Array): DecodedMidpriceOracle;
+declare function decodeCurveMeta(data: Uint8Array): DecodedCurveMeta;
+/**
+ * Check if a specific slot is initialized in the CurveMeta bitmap.
+ */
+declare function isSlotInitialized(initializedSlots: Uint8Array, curveType: CurveType, slot: number, maxSlots: number): boolean;
+declare function decodeFeeConfig(data: Uint8Array): DecodedFeeConfig;
+declare function decodeCurveUpdates(data: Uint8Array): DecodedCurveUpdates;
+/**
+ * Decode a single curve side from a CurvePrefabs account.
+ */
+declare function decodeCurveSide(data: Uint8Array, curveType: CurveType, slot: number, maxSlots: number, maxPoints: number): CurveSide;
+/**
+ * Decode all active curve slots from a CurvePrefabs account using CurveMeta info.
+ */
+declare function decodeActiveCurves(prefabsData: Uint8Array, meta: DecodedCurveMeta): {
+    priceBid: CurveSide;
+    priceAsk: CurveSide;
+    riskBid: CurveSide;
+    riskAsk: CurveSide;
+};
+
+declare function getConfigAddress(seed: bigint, mintX: PublicKey, mintY: PublicKey, programId?: PublicKey): [PublicKey, number];
+declare function getMidpriceOracleAddress(seed: bigint, mintX: PublicKey, mintY: PublicKey, programId?: PublicKey): [PublicKey, number];
+declare function getCurveMetaAddress(seed: bigint, mintX: PublicKey, mintY: PublicKey, programId?: PublicKey): [PublicKey, number];
+declare function getCurvePrefabsAddress(seed: bigint, mintX: PublicKey, mintY: PublicKey, programId?: PublicKey): [PublicKey, number];
+declare function getCurveUpdatesAddress(seed: bigint, mintX: PublicKey, mintY: PublicKey, programId?: PublicKey): [PublicKey, number];
+declare function getFeeConfigAddress(programId?: PublicKey): [PublicKey, number];
+declare function getSpreadConfigAddress(configPda: PublicKey, programId?: PublicKey): [PublicKey, number];
+/**
+ * Derive all PDA addresses for a pool.
+ */
+declare function derivePoolAddresses(seed: bigint, mintX: PublicKey, mintY: PublicKey, tokenProgramX: PublicKey, tokenProgramY: PublicKey, programId?: PublicKey): PoolAddresses;
+
+/** Convert a floating-point number to Q32.32 fixed point (bigint). */
+declare function toQ32(value: number): bigint;
+/** Convert a Q32.32 fixed-point bigint to a floating-point number.
+ *  Splits into integer + fractional parts to avoid precision loss
+ *  when the integer part exceeds 2^21 (~2 million). */
+declare function fromQ32(q32: bigint): number;
+/** Convert a percentage (0.0 to 1.0) to Q32.32. */
+declare function pctToQ32(pct: number): bigint;
+
+/**
+ * Get the ATA address, and optionally return a create instruction if it doesn't exist.
+ */
+declare function getOrCreateAta(connection: Connection, mint: PublicKey, owner: PublicKey, payer: PublicKey, tokenProgram?: PublicKey, allowOwnerOffCurve?: boolean): Promise<{
+    address: PublicKey;
+    instruction: TransactionInstruction | null;
+}>;
+
+/**
+ * Build an Initialize instruction.
+ * Creates the pool: Config, MidpriceOracle, CurveMeta, CurveUpdates.
+ * CurvePrefabs must be pre-allocated (use buildAllocateCurvePrefabs).
+ */
+declare function buildInitialize(payer: PublicKey, params: InitializeParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build an AllocateCurvePrefabs instruction.
+ * Must be called before Initialize (possibly twice if size > 10240).
+ */
+declare function buildAllocateCurvePrefabs(payer: PublicKey, params: AllocateCurvePrefabsParams, programId?: PublicKey): TransactionInstruction;
+
+/**
+ * Build a Deposit instruction.
+ */
+declare function buildDeposit(user: PublicKey, configPda: PublicKey, mintX: PublicKey, mintY: PublicKey, tokenProgramX: PublicKey, tokenProgramY: PublicKey, params: DepositParams, programId?: PublicKey): TransactionInstruction;
+
+/**
+ * Build a Withdraw instruction.
+ */
+declare function buildWithdraw(user: PublicKey, configPda: PublicKey, mintX: PublicKey, mintY: PublicKey, tokenProgramX: PublicKey, tokenProgramY: PublicKey, params: WithdrawParams, programId?: PublicKey): TransactionInstruction;
+
+/**
+ * Build a SwapExactIn instruction.
+ *
+ * Account order (16 base): token_program_x, token_program_y, config,
+ * midprice_oracle, curve_meta, curve_prefabs, authority(=pool address PDA), user,
+ * user_source, vault_source, vault_dest, user_dest, fee_config,
+ * fee_recipient_ata, clock, curve_updates.
+ *
+ * Optional (for introspection): spread_config, instructions_sysvar.
+ */
+declare function buildSwapExactIn(user: PublicKey, poolAddresses: PoolAddresses, mintX: PublicKey, mintY: PublicKey, tokenProgramX: PublicKey, tokenProgramY: PublicKey, params: SwapParams, programId?: PublicKey): TransactionInstruction;
+
+/**
+ * Build a SetCurve instruction (price curve).
+ * Accounts: authority, curve_meta, curve_prefabs.
+ */
+declare function buildSetCurve(authority: PublicKey, curveMetaPda: PublicKey, curvePrefabsPda: PublicKey, params: SetCurveParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build a SetRiskCurve instruction (risk curve, percent-based x-axis by default).
+ * Accounts: authority, curve_meta, curve_prefabs.
+ */
+declare function buildSetRiskCurve(authority: PublicKey, curveMetaPda: PublicKey, curvePrefabsPda: PublicKey, params: SetRiskCurveParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build a SetRiskCurve instruction with absolute x-axis (CurveXMode::Alternate).
+ */
+declare function buildSetRiskCurveAbsolute(authority: PublicKey, curveMetaPda: PublicKey, curvePrefabsPda: PublicKey, params: SetRiskCurveAbsoluteParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build SetCurve instructions for both bid and ask in one call.
+ * Returns [bidIx, askIx] — add both to the same transaction.
+ */
+declare function buildSetCurveBoth(authority: PublicKey, curveMetaPda: PublicKey, curvePrefabsPda: PublicKey, params: SetCurveBothParams, programId?: PublicKey): [TransactionInstruction, TransactionInstruction];
+/**
+ * Build SetRiskCurve instructions for both bid and ask in one call.
+ * Returns [bidIx, askIx].
+ */
+declare function buildSetRiskCurveBoth(authority: PublicKey, curveMetaPda: PublicKey, curvePrefabsPda: PublicKey, params: SetRiskCurveBothParams, programId?: PublicKey): [TransactionInstruction, TransactionInstruction];
+/**
+ * Build SetRiskCurve (absolute x-axis) instructions for both bid and ask in one call.
+ * Returns [bidIx, askIx].
+ */
+declare function buildSetRiskCurveAbsoluteBoth(authority: PublicKey, curveMetaPda: PublicKey, curvePrefabsPda: PublicKey, params: SetRiskCurveAbsoluteBothParams, programId?: PublicKey): [TransactionInstruction, TransactionInstruction];
+
+/**
+ * Build an UpdateMidprice instruction.
+ * Accounts: authority, midprice_oracle, clock.
+ */
+declare function buildUpdateMidprice(authority: PublicKey, midpriceOraclePda: PublicKey, params: UpdateMidpriceParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build an UpdateBaseSpread instruction.
+ * Accounts: authority, midprice_oracle, clock.
+ */
+declare function buildUpdateBaseSpread(authority: PublicKey, midpriceOraclePda: PublicKey, params: UpdateBaseSpreadParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build an UpdateMidpriceAndBaseSpread instruction (atomic update of both).
+ * Accounts: authority, midprice_oracle, clock.
+ */
+declare function buildUpdateMidpriceAndBaseSpread(authority: PublicKey, midpriceOraclePda: PublicKey, params: UpdateMidpriceAndBaseSpreadParams, programId?: PublicKey): TransactionInstruction;
+
+/**
+ * Build a SwitchPriceCurve instruction (hot path).
+ * Accounts: authority, curve_meta.
+ */
+declare function buildSwitchPriceCurve(authority: PublicKey, curveMetaPda: PublicKey, params: SwitchCurveParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build a SwitchRiskCurve instruction (hot path).
+ * Accounts: authority, curve_meta.
+ */
+declare function buildSwitchRiskCurve(authority: PublicKey, curveMetaPda: PublicKey, params: SwitchCurveParams, programId?: PublicKey): TransactionInstruction;
+
+/**
+ * Build a SubmitCurveUpdates instruction (hot path, 2 accounts).
+ * Accounts: authority, curve_updates.
+ */
+declare function buildSubmitCurveUpdates(authority: PublicKey, curveUpdatesPda: PublicKey, ops: CurveUpdateOp[], programId?: PublicKey): TransactionInstruction;
+/**
+ * Build an ApplyCurveUpdates instruction.
+ * Accounts: authority, curve_meta, curve_prefabs, curve_updates.
+ */
+declare function buildApplyCurveUpdates(authority: PublicKey, curveMetaPda: PublicKey, curvePrefabsPda: PublicKey, curveUpdatesPda: PublicKey, programId?: PublicKey): TransactionInstruction;
+
+/**
+ * Build a NominateAuthority instruction (step 1 of 2-step authority transfer).
+ * Accounts: authority, config, clock.
+ */
+declare function buildNominateAuthority(authority: PublicKey, configPda: PublicKey, params: NominateAuthorityParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build an AcceptAuthority instruction (step 2 of 2-step authority transfer).
+ * Only updates Config.authority. Quoting authority is managed via SetQuotingAuthority.
+ * Accounts: new_authority, config, clock.
+ */
+declare function buildAcceptAuthority(newAuthority: PublicKey, configPda: PublicKey, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build a SetQuotingAuthority instruction.
+ * Pool authority sets a new quoting authority on MidpriceOracle, CurveMeta,
+ * CurveUpdates, and optionally SpreadConfig.
+ * Accounts: authority, config, midprice_oracle, curve_meta, curve_updates, [spread_config?].
+ */
+declare function buildSetQuotingAuthority(authority: PublicKey, configPda: PublicKey, oraclePda: PublicKey, curveMetaPda: PublicKey, curveUpdatesPda: PublicKey, params: SetQuotingAuthorityParams, programId?: PublicKey): TransactionInstruction;
+
+/**
+ * Build an InitializeFeeConfig instruction (one-time global setup).
+ * Accounts: payer, authority, fee_config, system_program.
+ */
+declare function buildInitializeFeeConfig(payer: PublicKey, authority: PublicKey, params: InitializeFeeConfigParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build an UpdateFeeConfig instruction.
+ * Accounts: fee_admin, fee_config.
+ */
+declare function buildUpdateFeeConfig(feeAdmin: PublicKey, params: UpdateFeeConfigParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build a RotateFeeAdmin instruction.
+ * Accounts: fee_admin (signer), fee_config (mut).
+ */
+declare function buildRotateFeeAdmin(feeAdmin: PublicKey, params: RotateFeeAdminParams, programId?: PublicKey): TransactionInstruction;
+
+/**
+ * Build an InitializeSpreadConfig instruction.
+ * Accounts: payer, authority, config, spread_config, system_program.
+ */
+declare function buildInitializeSpreadConfig(payer: PublicKey, authority: PublicKey, configPda: PublicKey, params: InitializeSpreadConfigParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build an UpdateSpreadConfig instruction.
+ * Accounts: admin, config, spread_config.
+ */
+declare function buildUpdateSpreadConfig(admin: PublicKey, configPda: PublicKey, params: UpdateSpreadConfigParams, programId?: PublicKey): TransactionInstruction;
+
+/**
+ * Build a SetPoolState instruction.
+ * Accounts: authority, config.
+ */
+declare function buildSetPoolState(authority: PublicKey, configPda: PublicKey, params: SetPoolStateParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build an UpdateDeltaStaleness instruction.
+ * Accounts: authority, config.
+ */
+declare function buildUpdateDeltaStaleness(authority: PublicKey, configPda: PublicKey, params: UpdateDeltaStalenessParams, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build a ClosePool instruction.
+ * Accounts: authority, config, midprice_oracle, curve_meta, curve_prefabs,
+ * curve_updates, vault_x, vault_y, token_program_x, token_program_y,
+ * [optional: spread_config if initialized].
+ */
+declare function buildClosePool(authority: PublicKey, configPda: PublicKey, midpriceOraclePda: PublicKey, curveMetaPda: PublicKey, curvePrefabsPda: PublicKey, curveUpdatesPda: PublicKey, vaultX: PublicKey, vaultY: PublicKey, tokenProgramX: PublicKey, tokenProgramY: PublicKey, spreadConfigInitialized?: boolean, programId?: PublicKey): TransactionInstruction;
+
+export { ABSOLUTE_MAX_CURVE_POINTS, ABSOLUTE_MAX_PREFAB_SLOTS, type AllocateCurvePrefabsParams, CONFIG_SEED, CONFIG_SIZE, CURVE_META_SEED, CURVE_META_SIZE, CURVE_POINT_LEN, CURVE_PREFABS_SEED, CURVE_SIDE_HEADER, CURVE_UPDATES_SEED, CURVE_UPDATES_SIZE, CURVE_UPDATE_OP_SIZE, type CurvePoint, type CurveSide, CurveType, type CurveUpdateOp, CurveUpdateOpKind, CurveXMode, DEFAULT_MAX_CURVE_POINTS, DEFAULT_MAX_PREFAB_SLOTS, type DecodedConfig, type DecodedCurveMeta, type DecodedCurveUpdates, type DecodedFeeConfig, type DecodedMidpriceOracle, type DepositParams, Discriminator, FEE_CONFIG_SEED, FEE_CONFIG_SIZE, HADRON_PROGRAM_ID, Hadron, type InitializeFeeConfigParams, type InitializeParams, type InitializeSpreadConfigParams, Interpolation, MAX_CURVE_UPDATE_OPS, MAX_SETCURVE_POINTS, MIDPRICE_ORACLE_SEED, MIDPRICE_ORACLE_SIZE, type NominateAuthorityParams, OracleMode, POINT_DATA_SIZE, type PoolAddresses, PoolState, Q32_ONE, RiskMode, type RotateFeeAdminParams, SPREAD_CONFIG_SEED, type SetCurveBothParams, type SetCurveParams, type SetCurvePointInput, type SetPoolStateParams, type SetQuotingAuthorityParams, type SetRiskCurveAbsoluteBothParams, type SetRiskCurveAbsoluteParams, type SetRiskCurveAbsolutePointInput, type SetRiskCurveBothParams, type SetRiskCurveParams, type SetRiskCurvePointInput, Side, type SpreadTriggerInput, type SwapParams, type SwitchCurveParams, type UpdateBaseSpreadParams, type UpdateDeltaStalenessParams, type UpdateFeeConfigParams, type UpdateMidpriceAndBaseSpreadParams, type UpdateMidpriceParams, type UpdateSpreadConfigParams, type WithdrawParams, buildAcceptAuthority, buildAllocateCurvePrefabs, buildApplyCurveUpdates, buildClosePool, buildDeposit, buildInitialize, buildInitializeFeeConfig, buildInitializeSpreadConfig, buildNominateAuthority, buildRotateFeeAdmin, buildSetCurve, buildSetCurveBoth, buildSetPoolState, buildSetQuotingAuthority, buildSetRiskCurve, buildSetRiskCurveAbsolute, buildSetRiskCurveAbsoluteBoth, buildSetRiskCurveBoth, buildSubmitCurveUpdates, buildSwapExactIn, buildSwitchPriceCurve, buildSwitchRiskCurve, buildUpdateBaseSpread, buildUpdateDeltaStaleness, buildUpdateFeeConfig, buildUpdateMidprice, buildUpdateMidpriceAndBaseSpread, buildUpdateSpreadConfig, buildWithdraw, curvePrefabsSize, decodeActiveCurves, decodeConfig, decodeCurveMeta, decodeCurveSide, decodeCurveUpdates, decodeFeeConfig, decodeMidpriceOracle, derivePoolAddresses, fromQ32, getConfigAddress, getCurveMetaAddress, getCurvePrefabsAddress, getCurveUpdatesAddress, getFeeConfigAddress, getMidpriceOracleAddress, getOrCreateAta, getSpreadConfigAddress, isSlotInitialized, pctToQ32, toQ32 };