@hadron-fi/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1653 @@
+// src/constants/index.ts
+import { PublicKey } from "@solana/web3.js";
+var HADRON_PROGRAM_ID = new PublicKey(
+  "Q72w4coozA552keKDdeeh2EyQw32qfMFsHPu6cbatom"
+);
+var CONFIG_SEED = Buffer.from("hadron-config");
+var MIDPRICE_ORACLE_SEED = Buffer.from("hadron-midprice");
+var CURVE_META_SEED = Buffer.from("hadron-curve-meta");
+var CURVE_PREFABS_SEED = Buffer.from("hadron-curve-prefabs");
+var CURVE_UPDATES_SEED = Buffer.from("hadron-curve-updates");
+var FEE_CONFIG_SEED = Buffer.from("fee_config");
+var SPREAD_CONFIG_SEED = Buffer.from("spread_config");
+var CONFIG_SIZE = 248;
+var MIDPRICE_ORACLE_SIZE = 64;
+var CURVE_META_SIZE = 48;
+var FEE_CONFIG_SIZE = 72;
+var CURVE_UPDATES_SIZE = 258;
+var CURVE_SIDE_HEADER = 8;
+var CURVE_POINT_LEN = 24;
+var DEFAULT_MAX_PREFAB_SLOTS = 10;
+var DEFAULT_MAX_CURVE_POINTS = 16;
+var ABSOLUTE_MAX_PREFAB_SLOTS = 16;
+var ABSOLUTE_MAX_CURVE_POINTS = 128;
+var MAX_SETCURVE_POINTS = 32;
+var MAX_CURVE_UPDATE_OPS = 8;
+var Q32_ONE = BigInt(1) << BigInt(32);
+var Discriminator = {
+  Initialize: 0,
+  Deposit: 1,
+  Withdraw: 2,
+  SwapExactIn: 3,
+  SetCurve: 4,
+  UpdateMidprice: 5,
+  InitializeFeeConfig: 6,
+  UpdateFeeConfig: 7,
+  SetRiskCurve: 8,
+  UpdateBaseSpread: 9,
+  UpdateMidpriceAndBaseSpread: 10,
+  SwitchPriceCurve: 11,
+  SwitchRiskCurve: 12,
+  InitializeSpreadConfig: 13,
+  UpdateSpreadConfig: 14,
+  UpdateDeltaStaleness: 15,
+  NominateAuthority: 16,
+  AcceptAuthority: 17,
+  SubmitCurveUpdates: 18,
+  ApplyCurveUpdates: 19,
+  ClosePool: 20,
+  SetPoolState: 21,
+  AllocateCurvePrefabs: 22,
+  SetQuotingAuthority: 23,
+  RotateFeeAdmin: 24
+};
+var POINT_DATA_SIZE = 21;
+var CURVE_UPDATE_OP_SIZE = 24;
+function curvePrefabsSize(maxSlots, maxPoints) {
+  return 32 + 4 * maxSlots * (CURVE_SIDE_HEADER + maxPoints * CURVE_POINT_LEN);
+}
+
+// src/helpers/derive.ts
+import { PublicKey as PublicKey2 } from "@solana/web3.js";
+import { getAssociatedTokenAddressSync } from "@solana/spl-token";
+function seedToBuffer(seed) {
+  const buf = Buffer.alloc(8);
+  buf.writeBigUInt64LE(seed);
+  return buf;
+}
+function getConfigAddress(seed, mintX, mintY, programId = HADRON_PROGRAM_ID) {
+  return PublicKey2.findProgramAddressSync(
+    [CONFIG_SEED, seedToBuffer(seed), mintX.toBuffer(), mintY.toBuffer()],
+    programId
+  );
+}
+function getMidpriceOracleAddress(seed, mintX, mintY, programId = HADRON_PROGRAM_ID) {
+  return PublicKey2.findProgramAddressSync(
+    [
+      MIDPRICE_ORACLE_SEED,
+      seedToBuffer(seed),
+      mintX.toBuffer(),
+      mintY.toBuffer()
+    ],
+    programId
+  );
+}
+function getCurveMetaAddress(seed, mintX, mintY, programId = HADRON_PROGRAM_ID) {
+  return PublicKey2.findProgramAddressSync(
+    [CURVE_META_SEED, seedToBuffer(seed), mintX.toBuffer(), mintY.toBuffer()],
+    programId
+  );
+}
+function getCurvePrefabsAddress(seed, mintX, mintY, programId = HADRON_PROGRAM_ID) {
+  return PublicKey2.findProgramAddressSync(
+    [
+      CURVE_PREFABS_SEED,
+      seedToBuffer(seed),
+      mintX.toBuffer(),
+      mintY.toBuffer()
+    ],
+    programId
+  );
+}
+function getCurveUpdatesAddress(seed, mintX, mintY, programId = HADRON_PROGRAM_ID) {
+  return PublicKey2.findProgramAddressSync(
+    [
+      CURVE_UPDATES_SEED,
+      seedToBuffer(seed),
+      mintX.toBuffer(),
+      mintY.toBuffer()
+    ],
+    programId
+  );
+}
+function getFeeConfigAddress(programId = HADRON_PROGRAM_ID) {
+  return PublicKey2.findProgramAddressSync([FEE_CONFIG_SEED], programId);
+}
+function getSpreadConfigAddress(configPda, programId = HADRON_PROGRAM_ID) {
+  return PublicKey2.findProgramAddressSync(
+    [SPREAD_CONFIG_SEED, configPda.toBuffer()],
+    programId
+  );
+}
+function derivePoolAddresses(seed, mintX, mintY, tokenProgramX, tokenProgramY, programId = HADRON_PROGRAM_ID) {
+  const [config, configBump] = getConfigAddress(seed, mintX, mintY, programId);
+  const [midpriceOracle] = getMidpriceOracleAddress(
+    seed,
+    mintX,
+    mintY,
+    programId
+  );
+  const [curveMeta] = getCurveMetaAddress(seed, mintX, mintY, programId);
+  const [curvePrefabs] = getCurvePrefabsAddress(seed, mintX, mintY, programId);
+  const [curveUpdates] = getCurveUpdatesAddress(seed, mintX, mintY, programId);
+  const vaultX = getAssociatedTokenAddressSync(
+    mintX,
+    config,
+    true,
+    tokenProgramX
+  );
+  const vaultY = getAssociatedTokenAddressSync(
+    mintY,
+    config,
+    true,
+    tokenProgramY
+  );
+  return {
+    config,
+    configBump,
+    midpriceOracle,
+    curveMeta,
+    curvePrefabs,
+    curveUpdates,
+    vaultX,
+    vaultY
+  };
+}
+
+// src/helpers/math.ts
+function toQ32(value) {
+  return BigInt(Math.floor(value * Number(Q32_ONE)));
+}
+function fromQ32(q32) {
+  const intPart = q32 >> 32n;
+  const fracPart = q32 & 0xFFFFFFFFn;
+  return Number(intPart) + Number(fracPart) / Number(Q32_ONE);
+}
+function pctToQ32(pct) {
+  return toQ32(pct);
+}
+
+// src/accounts/index.ts
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
+
+// src/types/index.ts
+var PoolState = /* @__PURE__ */ ((PoolState3) => {
+  PoolState3[PoolState3["Uninitialized"] = 0] = "Uninitialized";
+  PoolState3[PoolState3["Initialized"] = 1] = "Initialized";
+  PoolState3[PoolState3["Paused"] = 2] = "Paused";
+  PoolState3[PoolState3["WithdrawOnly"] = 3] = "WithdrawOnly";
+  return PoolState3;
+})(PoolState || {});
+var OracleMode = /* @__PURE__ */ ((OracleMode3) => {
+  OracleMode3[OracleMode3["Authority"] = 0] = "Authority";
+  OracleMode3[OracleMode3["Relative"] = 1] = "Relative";
+  return OracleMode3;
+})(OracleMode || {});
+var Interpolation = /* @__PURE__ */ ((Interpolation4) => {
+  Interpolation4[Interpolation4["Step"] = 0] = "Step";
+  Interpolation4[Interpolation4["Linear"] = 1] = "Linear";
+  Interpolation4[Interpolation4["MarginalStep"] = 2] = "MarginalStep";
+  Interpolation4[Interpolation4["Hyperbolic"] = 3] = "Hyperbolic";
+  Interpolation4[Interpolation4["Quadratic"] = 4] = "Quadratic";
+  Interpolation4[Interpolation4["Cubic"] = 5] = "Cubic";
+  return Interpolation4;
+})(Interpolation || {});
+var CurveType = /* @__PURE__ */ ((CurveType2) => {
+  CurveType2[CurveType2["PriceBid"] = 0] = "PriceBid";
+  CurveType2[CurveType2["PriceAsk"] = 1] = "PriceAsk";
+  CurveType2[CurveType2["RiskBid"] = 2] = "RiskBid";
+  CurveType2[CurveType2["RiskAsk"] = 3] = "RiskAsk";
+  return CurveType2;
+})(CurveType || {});
+var CurveXMode = /* @__PURE__ */ ((CurveXMode3) => {
+  CurveXMode3[CurveXMode3["Native"] = 0] = "Native";
+  CurveXMode3[CurveXMode3["Alternate"] = 1] = "Alternate";
+  return CurveXMode3;
+})(CurveXMode || {});
+var RiskMode = /* @__PURE__ */ ((RiskMode3) => {
+  RiskMode3[RiskMode3["Virtual"] = 0] = "Virtual";
+  RiskMode3[RiskMode3["Integrated"] = 1] = "Integrated";
+  return RiskMode3;
+})(RiskMode || {});
+var CurveUpdateOpKind = /* @__PURE__ */ ((CurveUpdateOpKind3) => {
+  CurveUpdateOpKind3[CurveUpdateOpKind3["Edit"] = 0] = "Edit";
+  CurveUpdateOpKind3[CurveUpdateOpKind3["Add"] = 1] = "Add";
+  CurveUpdateOpKind3[CurveUpdateOpKind3["Remove"] = 2] = "Remove";
+  return CurveUpdateOpKind3;
+})(CurveUpdateOpKind || {});
+var Side = /* @__PURE__ */ ((Side2) => {
+  Side2[Side2["Bid"] = 0] = "Bid";
+  Side2[Side2["Ask"] = 1] = "Ask";
+  return Side2;
+})(Side || {});
+
+// src/accounts/index.ts
+function decodeConfig(data) {
+  const buf = Buffer.from(data);
+  let offset = 0;
+  const state = buf.readUInt8(offset);
+  offset += 1;
+  const seed = buf.readBigUInt64LE(offset);
+  offset += 8;
+  const authority = new PublicKey3(buf.subarray(offset, offset + 32));
+  offset += 32;
+  const mintX = new PublicKey3(buf.subarray(offset, offset + 32));
+  offset += 32;
+  const mintY = new PublicKey3(buf.subarray(offset, offset + 32));
+  offset += 32;
+  const configBump = buf.readUInt8(offset);
+  offset += 1;
+  const curveMeta = new PublicKey3(buf.subarray(offset, offset + 32));
+  offset += 32;
+  const spreadConfigInitialized = buf.readUInt8(offset) !== 0;
+  offset += 1;
+  const deltaStaleness = buf.readUInt8(offset);
+  offset += 1;
+  const oracleMode = buf.readUInt8(offset);
+  offset += 1;
+  offset += 3;
+  const pendingAuthority = new PublicKey3(buf.subarray(offset, offset + 32));
+  offset += 32;
+  const nominationExpiry = buf.readBigUInt64LE(offset);
+  offset += 8;
+  const tokenProgramX = new PublicKey3(buf.subarray(offset, offset + 32));
+  offset += 32;
+  const tokenProgramY = new PublicKey3(buf.subarray(offset, offset + 32));
+  return {
+    state,
+    seed,
+    authority,
+    mintX,
+    mintY,
+    configBump,
+    curveMeta,
+    spreadConfigInitialized,
+    deltaStaleness,
+    oracleMode,
+    pendingAuthority,
+    nominationExpiry,
+    tokenProgramX,
+    tokenProgramY
+  };
+}
+function decodeMidpriceOracle(data) {
+  const buf = Buffer.from(data);
+  const authority = new PublicKey3(buf.subarray(0, 32));
+  const sequence = buf.readBigUInt64LE(32);
+  const midpriceQ32 = buf.readBigUInt64LE(40);
+  const baseSpreadQ32 = buf.readBigUInt64LE(48);
+  const lastUpdateSlot = buf.length >= MIDPRICE_ORACLE_SIZE ? buf.readBigUInt64LE(56) : 0n;
+  return { authority, sequence, midpriceQ32, baseSpreadQ32, lastUpdateSlot };
+}
+function decodeCurveMeta(data) {
+  const buf = Buffer.from(data);
+  return {
+    authority: new PublicKey3(buf.subarray(0, 32)),
+    activePriceBidSlot: buf.readUInt8(32),
+    activePriceAskSlot: buf.readUInt8(33),
+    activeRiskBidSlot: buf.readUInt8(34),
+    activeRiskAskSlot: buf.readUInt8(35),
+    initializedSlots: new Uint8Array(buf.subarray(36, 44)),
+    maxPrefabSlots: buf.readUInt8(44),
+    maxCurvePoints: buf.readUInt8(45)
+  };
+}
+function isSlotInitialized(initializedSlots, curveType, slot, maxSlots) {
+  const bitIndex = curveType * maxSlots + slot;
+  const byteIndex = Math.floor(bitIndex / 8);
+  const bitOffset = bitIndex % 8;
+  return (initializedSlots[byteIndex] & 1 << bitOffset) !== 0;
+}
+function decodeFeeConfig(data) {
+  const buf = Buffer.from(data);
+  return {
+    initialized: buf.readUInt8(0) !== 0,
+    feePpm: buf.readUInt32LE(1),
+    bump: buf.readUInt8(5),
+    // skip 2 bytes padding
+    feeAdmin: new PublicKey3(buf.subarray(8, 40)),
+    feeRecipient: new PublicKey3(buf.subarray(40, 72))
+  };
+}
+function decodeCurveUpdates(data) {
+  const buf = Buffer.from(data);
+  let offset = 0;
+  const authority = new PublicKey3(buf.subarray(offset, offset + 32));
+  offset += 32;
+  const curveMeta = new PublicKey3(buf.subarray(offset, offset + 32));
+  offset += 32;
+  const numOps = buf.readUInt8(offset);
+  offset += 1;
+  offset += 1;
+  const ops = [];
+  for (let i = 0; i < numOps && i < MAX_CURVE_UPDATE_OPS; i++) {
+    const opOffset = offset + i * CURVE_UPDATE_OP_SIZE;
+    ops.push({
+      curveType: buf.readUInt8(opOffset),
+      opKind: buf.readUInt8(opOffset + 1),
+      pointIndex: buf.readUInt8(opOffset + 2),
+      interpolation: buf.readUInt8(opOffset + 3),
+      xIn: buf.readBigUInt64LE(opOffset + 4),
+      priceFactorQ32: buf.readBigUInt64LE(opOffset + 12),
+      params: new Uint8Array(buf.subarray(opOffset + 20, opOffset + 24))
+    });
+  }
+  return { authority, curveMeta, numOps, ops };
+}
+function decodeCurveSide(data, curveType, slot, maxSlots, maxPoints) {
+  const sideSize = CURVE_SIDE_HEADER + maxPoints * CURVE_POINT_LEN;
+  const offset = 32 + (curveType * maxSlots + slot) * sideSize;
+  const buf = Buffer.from(data);
+  const numPoints = buf.readUInt8(offset);
+  const defaultInterpolation = buf.readUInt8(offset + 1);
+  const xMode = buf.readUInt8(offset + 2);
+  const riskMode = buf.readUInt8(offset + 3);
+  const points = [];
+  const pointsStart = offset + CURVE_SIDE_HEADER;
+  const n = Math.min(numPoints, maxPoints);
+  for (let i = 0; i < n; i++) {
+    const pOff = pointsStart + i * CURVE_POINT_LEN;
+    points.push({
+      xIn: buf.readBigUInt64LE(pOff),
+      priceFactorQ32: buf.readBigUInt64LE(pOff + 8),
+      interpolation: buf.readUInt8(pOff + 16),
+      params: new Uint8Array(buf.subarray(pOff + 17, pOff + 21))
+    });
+  }
+  return { numPoints, defaultInterpolation, xMode, riskMode, points };
+}
+function decodeActiveCurves(prefabsData, meta) {
+  const { maxPrefabSlots, maxCurvePoints } = meta;
+  return {
+    priceBid: decodeCurveSide(
+      prefabsData,
+      0 /* PriceBid */,
+      meta.activePriceBidSlot,
+      maxPrefabSlots,
+      maxCurvePoints
+    ),
+    priceAsk: decodeCurveSide(
+      prefabsData,
+      1 /* PriceAsk */,
+      meta.activePriceAskSlot,
+      maxPrefabSlots,
+      maxCurvePoints
+    ),
+    riskBid: decodeCurveSide(
+      prefabsData,
+      2 /* RiskBid */,
+      meta.activeRiskBidSlot,
+      maxPrefabSlots,
+      maxCurvePoints
+    ),
+    riskAsk: decodeCurveSide(
+      prefabsData,
+      3 /* RiskAsk */,
+      meta.activeRiskAskSlot,
+      maxPrefabSlots,
+      maxCurvePoints
+    )
+  };
+}
+
+// src/instructions/initialize.ts
+import {
+  PublicKey as PublicKey4,
+  SystemProgram,
+  TransactionInstruction
+} from "@solana/web3.js";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+function buildInitialize(payer, params, programId = HADRON_PROGRAM_ID) {
+  const seed = params.seed;
+  if (seed === void 0) throw new Error("seed is required \u2014 use Hadron.initialize() to auto-generate one");
+  const tokenProgramX = params.tokenProgramX ?? TOKEN_PROGRAM_ID;
+  const tokenProgramY = params.tokenProgramY ?? TOKEN_PROGRAM_ID;
+  const maxPrefabSlots = params.maxPrefabSlots ?? DEFAULT_MAX_PREFAB_SLOTS;
+  const maxCurvePoints = params.maxCurvePoints ?? DEFAULT_MAX_CURVE_POINTS;
+  const oracleMode = params.oracleMode ?? 0;
+  const addrs = derivePoolAddresses(
+    seed,
+    params.mintX,
+    params.mintY,
+    tokenProgramX,
+    tokenProgramY,
+    programId
+  );
+  const hasCustomSlots = params.maxPrefabSlots !== void 0 || params.maxCurvePoints !== void 0;
+  const hasOracleMode = oracleMode !== 0 || hasCustomSlots;
+  const trailingLen = hasCustomSlots ? 3 : hasOracleMode ? 1 : 0;
+  const data = Buffer.alloc(1 + 8 + 32 + 32 + 32 + 8 + trailingLen);
+  let offset = 0;
+  data.writeUInt8(Discriminator.Initialize, offset);
+  offset += 1;
+  data.writeBigUInt64LE(seed, offset);
+  offset += 8;
+  params.mintX.toBuffer().copy(data, offset);
+  offset += 32;
+  params.mintY.toBuffer().copy(data, offset);
+  offset += 32;
+  params.authority.toBuffer().copy(data, offset);
+  offset += 32;
+  data.writeBigUInt64LE(params.initialMidpriceQ32, offset);
+  offset += 8;
+  if (hasOracleMode) {
+    data.writeUInt8(oracleMode, offset);
+    offset += 1;
+  }
+  if (hasCustomSlots) {
+    data.writeUInt8(maxPrefabSlots, offset);
+    offset += 1;
+    data.writeUInt8(maxCurvePoints, offset);
+  }
+  return new TransactionInstruction({
+    programId,
+    keys: [
+      { pubkey: payer, isSigner: true, isWritable: true },
+      { pubkey: addrs.config, isSigner: false, isWritable: true },
+      { pubkey: params.mintX, isSigner: false, isWritable: false },
+      { pubkey: params.mintY, isSigner: false, isWritable: false },
+      { pubkey: addrs.vaultX, isSigner: false, isWritable: true },
+      { pubkey: addrs.vaultY, isSigner: false, isWritable: true },
+      { pubkey: tokenProgramX, isSigner: false, isWritable: false },
+      { pubkey: tokenProgramY, isSigner: false, isWritable: false },
+      {
+        pubkey: ASSOCIATED_TOKEN_PROGRAM_ID,
+        isSigner: false,
+        isWritable: false
+      },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+      { pubkey: addrs.midpriceOracle, isSigner: false, isWritable: true },
+      { pubkey: addrs.curveMeta, isSigner: false, isWritable: true },
+      { pubkey: addrs.curvePrefabs, isSigner: false, isWritable: true },
+      { pubkey: addrs.curveUpdates, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+function buildAllocateCurvePrefabs(payer, params, programId = HADRON_PROGRAM_ID) {
+  const maxPrefabSlots = params.maxPrefabSlots ?? DEFAULT_MAX_PREFAB_SLOTS;
+  const maxCurvePoints = params.maxCurvePoints ?? DEFAULT_MAX_CURVE_POINTS;
+  const data = Buffer.alloc(1 + 8 + 32 + 32 + 1 + 1);
+  let offset = 0;
+  data.writeUInt8(Discriminator.AllocateCurvePrefabs, offset);
+  offset += 1;
+  data.writeBigUInt64LE(params.seed, offset);
+  offset += 8;
+  params.mintX.toBuffer().copy(data, offset);
+  offset += 32;
+  params.mintY.toBuffer().copy(data, offset);
+  offset += 32;
+  data.writeUInt8(maxPrefabSlots, offset);
+  offset += 1;
+  data.writeUInt8(maxCurvePoints, offset);
+  const [curvePrefabsPda] = PublicKey4.findProgramAddressSync(
+    [
+      Buffer.from("hadron-curve-prefabs"),
+      (() => {
+        const b = Buffer.alloc(8);
+        b.writeBigUInt64LE(params.seed);
+        return b;
+      })(),
+      params.mintX.toBuffer(),
+      params.mintY.toBuffer()
+    ],
+    programId
+  );
+  return new TransactionInstruction({
+    programId,
+    keys: [
+      { pubkey: payer, isSigner: true, isWritable: true },
+      { pubkey: curvePrefabsPda, isSigner: false, isWritable: true },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+    ],
+    data
+  });
+}
+
+// src/instructions/deposit.ts
+import { TransactionInstruction as TransactionInstruction2 } from "@solana/web3.js";
+import { getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2 } from "@solana/spl-token";
+function buildDeposit(user, configPda, mintX, mintY, tokenProgramX, tokenProgramY, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 8 + 8 + 8);
+  let offset = 0;
+  data.writeUInt8(Discriminator.Deposit, offset);
+  offset += 1;
+  data.writeBigUInt64LE(params.amountX, offset);
+  offset += 8;
+  data.writeBigUInt64LE(params.amountY, offset);
+  offset += 8;
+  const exp = params.expiration ?? Math.floor(Date.now() / 1e3) + 3600;
+  data.writeBigInt64LE(BigInt(exp), offset);
+  const userX = getAssociatedTokenAddressSync2(mintX, user, false, tokenProgramX);
+  const userY = getAssociatedTokenAddressSync2(mintY, user, false, tokenProgramY);
+  const vaultX = getAssociatedTokenAddressSync2(mintX, configPda, true, tokenProgramX);
+  const vaultY = getAssociatedTokenAddressSync2(mintY, configPda, true, tokenProgramY);
+  return new TransactionInstruction2({
+    programId,
+    keys: [
+      { pubkey: user, isSigner: true, isWritable: false },
+      { pubkey: vaultX, isSigner: false, isWritable: true },
+      { pubkey: vaultY, isSigner: false, isWritable: true },
+      { pubkey: userX, isSigner: false, isWritable: true },
+      { pubkey: userY, isSigner: false, isWritable: true },
+      { pubkey: configPda, isSigner: false, isWritable: false },
+      { pubkey: tokenProgramX, isSigner: false, isWritable: false },
+      { pubkey: tokenProgramY, isSigner: false, isWritable: false }
+    ],
+    data
+  });
+}
+
+// src/instructions/withdraw.ts
+import { TransactionInstruction as TransactionInstruction3 } from "@solana/web3.js";
+import { getAssociatedTokenAddressSync as getAssociatedTokenAddressSync3 } from "@solana/spl-token";
+function buildWithdraw(user, configPda, mintX, mintY, tokenProgramX, tokenProgramY, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 8 + 8 + 8);
+  let offset = 0;
+  data.writeUInt8(Discriminator.Withdraw, offset);
+  offset += 1;
+  data.writeBigUInt64LE(params.amountX, offset);
+  offset += 8;
+  data.writeBigUInt64LE(params.amountY, offset);
+  offset += 8;
+  const exp = params.expiration ?? Math.floor(Date.now() / 1e3) + 3600;
+  data.writeBigInt64LE(BigInt(exp), offset);
+  const userX = getAssociatedTokenAddressSync3(mintX, user, false, tokenProgramX);
+  const userY = getAssociatedTokenAddressSync3(mintY, user, false, tokenProgramY);
+  const vaultX = getAssociatedTokenAddressSync3(mintX, configPda, true, tokenProgramX);
+  const vaultY = getAssociatedTokenAddressSync3(mintY, configPda, true, tokenProgramY);
+  return new TransactionInstruction3({
+    programId,
+    keys: [
+      { pubkey: user, isSigner: true, isWritable: false },
+      { pubkey: vaultX, isSigner: false, isWritable: true },
+      { pubkey: vaultY, isSigner: false, isWritable: true },
+      { pubkey: userX, isSigner: false, isWritable: true },
+      { pubkey: userY, isSigner: false, isWritable: true },
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: tokenProgramX, isSigner: false, isWritable: false },
+      { pubkey: tokenProgramY, isSigner: false, isWritable: false }
+    ],
+    data
+  });
+}
+
+// src/instructions/swap.ts
+import {
+  SYSVAR_CLOCK_PUBKEY,
+  TransactionInstruction as TransactionInstruction4
+} from "@solana/web3.js";
+import { getAssociatedTokenAddressSync as getAssociatedTokenAddressSync4 } from "@solana/spl-token";
+function buildSwapExactIn(user, poolAddresses, mintX, mintY, tokenProgramX, tokenProgramY, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 1 + 8 + 8 + 8);
+  let offset = 0;
+  data.writeUInt8(Discriminator.SwapExactIn, offset);
+  offset += 1;
+  data.writeUInt8(params.isX ? 1 : 0, offset);
+  offset += 1;
+  data.writeBigUInt64LE(params.amountIn, offset);
+  offset += 8;
+  data.writeBigUInt64LE(params.minOut, offset);
+  offset += 8;
+  const exp = params.expiration ?? Math.floor(Date.now() / 1e3) + 3600;
+  data.writeBigInt64LE(BigInt(exp), offset);
+  const userX = getAssociatedTokenAddressSync4(mintX, user, false, tokenProgramX);
+  const userY = getAssociatedTokenAddressSync4(mintY, user, false, tokenProgramY);
+  const [userSource, vaultSource, vaultDest, userDest] = params.isX ? [userX, poolAddresses.vaultX, poolAddresses.vaultY, userY] : [userY, poolAddresses.vaultY, poolAddresses.vaultX, userX];
+  const [feeConfigPda] = getFeeConfigAddress(programId);
+  const inputMint = params.isX ? mintX : mintY;
+  const inputMintProgram = params.isX ? tokenProgramX : tokenProgramY;
+  const feeRecipientAta = getAssociatedTokenAddressSync4(
+    inputMint,
+    params.feeRecipient,
+    false,
+    inputMintProgram
+  );
+  return new TransactionInstruction4({
+    programId,
+    keys: [
+      { pubkey: tokenProgramX, isSigner: false, isWritable: false },
+      { pubkey: tokenProgramY, isSigner: false, isWritable: false },
+      { pubkey: poolAddresses.config, isSigner: false, isWritable: false },
+      {
+        pubkey: poolAddresses.midpriceOracle,
+        isSigner: false,
+        isWritable: false
+      },
+      { pubkey: poolAddresses.curveMeta, isSigner: false, isWritable: false },
+      {
+        pubkey: poolAddresses.curvePrefabs,
+        isSigner: false,
+        isWritable: true
+      },
+      { pubkey: poolAddresses.config, isSigner: false, isWritable: false },
+      // authority = pool address PDA
+      { pubkey: user, isSigner: true, isWritable: false },
+      { pubkey: userSource, isSigner: false, isWritable: true },
+      { pubkey: vaultSource, isSigner: false, isWritable: true },
+      { pubkey: vaultDest, isSigner: false, isWritable: true },
+      { pubkey: userDest, isSigner: false, isWritable: true },
+      { pubkey: feeConfigPda, isSigner: false, isWritable: false },
+      { pubkey: feeRecipientAta, isSigner: false, isWritable: true },
+      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
+      {
+        pubkey: poolAddresses.curveUpdates,
+        isSigner: false,
+        isWritable: true
+      }
+    ],
+    data
+  });
+}
+
+// src/instructions/setCurve.ts
+import { TransactionInstruction as TransactionInstruction5 } from "@solana/web3.js";
+function interpolationToByte(interp) {
+  return interp;
+}
+function buildSetCurve(authority, curveMetaPda, curvePrefabsPda, params, programId = HADRON_PROGRAM_ID) {
+  const slot = params.slot ?? 0;
+  const xMode = params.xMode ?? 0 /* Native */;
+  const numPoints = params.points.length;
+  const data = Buffer.alloc(1 + 1 + 1 + 1 + 1 + 1 + numPoints * POINT_DATA_SIZE);
+  let offset = 0;
+  data.writeUInt8(Discriminator.SetCurve, offset);
+  offset += 1;
+  data.writeUInt8(slot, offset);
+  offset += 1;
+  data.writeUInt8(params.side, offset);
+  offset += 1;
+  data.writeUInt8(interpolationToByte(params.defaultInterpolation), offset);
+  offset += 1;
+  data.writeUInt8(numPoints, offset);
+  offset += 1;
+  data.writeUInt8(xMode, offset);
+  offset += 1;
+  for (const p of params.points) {
+    data.writeBigUInt64LE(p.xIn, offset);
+    offset += 8;
+    data.writeBigUInt64LE(toQ32(p.priceFactor), offset);
+    offset += 8;
+    data.writeUInt8(
+      interpolationToByte(p.interpolation ?? params.defaultInterpolation),
+      offset
+    );
+    offset += 1;
+    const params_ = p.params ?? new Uint8Array(4);
+    Buffer.from(params_).copy(data, offset, 0, 4);
+    offset += 4;
+  }
+  return new TransactionInstruction5({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: curveMetaPda, isSigner: false, isWritable: true },
+      { pubkey: curvePrefabsPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+function buildSetRiskCurve(authority, curveMetaPda, curvePrefabsPda, params, programId = HADRON_PROGRAM_ID) {
+  const slot = params.slot ?? 0;
+  const xMode = params.xMode ?? 0 /* Native */;
+  const riskMode = params.riskMode ?? 0 /* Virtual */;
+  const numPoints = params.points.length;
+  const data = Buffer.alloc(
+    1 + 1 + 1 + 1 + 1 + 1 + 1 + numPoints * POINT_DATA_SIZE
+  );
+  let offset = 0;
+  data.writeUInt8(Discriminator.SetRiskCurve, offset);
+  offset += 1;
+  data.writeUInt8(slot, offset);
+  offset += 1;
+  data.writeUInt8(params.side, offset);
+  offset += 1;
+  data.writeUInt8(interpolationToByte(params.defaultInterpolation), offset);
+  offset += 1;
+  data.writeUInt8(numPoints, offset);
+  offset += 1;
+  data.writeUInt8(xMode, offset);
+  offset += 1;
+  data.writeUInt8(riskMode, offset);
+  offset += 1;
+  for (const p of params.points) {
+    data.writeBigUInt64LE(toQ32(p.pctBase), offset);
+    offset += 8;
+    data.writeBigUInt64LE(toQ32(p.priceFactor), offset);
+    offset += 8;
+    data.writeUInt8(
+      interpolationToByte(p.interpolation ?? params.defaultInterpolation),
+      offset
+    );
+    offset += 1;
+    const params_ = p.params ?? new Uint8Array(4);
+    Buffer.from(params_).copy(data, offset, 0, 4);
+    offset += 4;
+  }
+  return new TransactionInstruction5({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: curveMetaPda, isSigner: false, isWritable: true },
+      { pubkey: curvePrefabsPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+function buildSetRiskCurveAbsolute(authority, curveMetaPda, curvePrefabsPda, params, programId = HADRON_PROGRAM_ID) {
+  const slot = params.slot ?? 0;
+  const riskMode = params.riskMode ?? 0 /* Virtual */;
+  const numPoints = params.points.length;
+  const data = Buffer.alloc(
+    1 + 1 + 1 + 1 + 1 + 1 + 1 + numPoints * POINT_DATA_SIZE
+  );
+  let offset = 0;
+  data.writeUInt8(Discriminator.SetRiskCurve, offset);
+  offset += 1;
+  data.writeUInt8(slot, offset);
+  offset += 1;
+  data.writeUInt8(params.side, offset);
+  offset += 1;
+  data.writeUInt8(interpolationToByte(params.defaultInterpolation), offset);
+  offset += 1;
+  data.writeUInt8(numPoints, offset);
+  offset += 1;
+  data.writeUInt8(1 /* Alternate */, offset);
+  offset += 1;
+  data.writeUInt8(riskMode, offset);
+  offset += 1;
+  for (const p of params.points) {
+    data.writeBigUInt64LE(p.vaultBalance, offset);
+    offset += 8;
+    data.writeBigUInt64LE(toQ32(p.priceFactor), offset);
+    offset += 8;
+    data.writeUInt8(
+      interpolationToByte(p.interpolation ?? params.defaultInterpolation),
+      offset
+    );
+    offset += 1;
+    const params_ = p.params ?? new Uint8Array(4);
+    Buffer.from(params_).copy(data, offset, 0, 4);
+    offset += 4;
+  }
+  return new TransactionInstruction5({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: curveMetaPda, isSigner: false, isWritable: true },
+      { pubkey: curvePrefabsPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+function buildSetCurveBoth(authority, curveMetaPda, curvePrefabsPda, params, programId = HADRON_PROGRAM_ID) {
+  const bidIx = buildSetCurve(authority, curveMetaPda, curvePrefabsPda, { ...params.bid, side: 0 /* Bid */ }, programId);
+  const askIx = buildSetCurve(authority, curveMetaPda, curvePrefabsPda, { ...params.ask, side: 1 /* Ask */ }, programId);
+  return [bidIx, askIx];
+}
+function buildSetRiskCurveBoth(authority, curveMetaPda, curvePrefabsPda, params, programId = HADRON_PROGRAM_ID) {
+  const bidIx = buildSetRiskCurve(authority, curveMetaPda, curvePrefabsPda, { ...params.bid, side: 0 /* Bid */ }, programId);
+  const askIx = buildSetRiskCurve(authority, curveMetaPda, curvePrefabsPda, { ...params.ask, side: 1 /* Ask */ }, programId);
+  return [bidIx, askIx];
+}
+function buildSetRiskCurveAbsoluteBoth(authority, curveMetaPda, curvePrefabsPda, params, programId = HADRON_PROGRAM_ID) {
+  const bidIx = buildSetRiskCurveAbsolute(authority, curveMetaPda, curvePrefabsPda, { ...params.bid, side: 0 /* Bid */ }, programId);
+  const askIx = buildSetRiskCurveAbsolute(authority, curveMetaPda, curvePrefabsPda, { ...params.ask, side: 1 /* Ask */ }, programId);
+  return [bidIx, askIx];
+}
+
+// src/instructions/oracle.ts
+import {
+  SYSVAR_CLOCK_PUBKEY as SYSVAR_CLOCK_PUBKEY2,
+  TransactionInstruction as TransactionInstruction6
+} from "@solana/web3.js";
+function buildUpdateMidprice(authority, midpriceOraclePda, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 8 + 8);
+  data.writeUInt8(Discriminator.UpdateMidprice, 0);
+  data.writeBigUInt64LE(params.sequence ?? 0n, 1);
+  data.writeBigUInt64LE(params.midpriceQ32, 9);
+  return new TransactionInstruction6({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: midpriceOraclePda, isSigner: false, isWritable: true },
+      { pubkey: SYSVAR_CLOCK_PUBKEY2, isSigner: false, isWritable: false }
+    ],
+    data
+  });
+}
+function buildUpdateBaseSpread(authority, midpriceOraclePda, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 8 + 8);
+  data.writeUInt8(Discriminator.UpdateBaseSpread, 0);
+  data.writeBigUInt64LE(params.sequence ?? 0n, 1);
+  data.writeBigUInt64LE(params.baseSpreadQ32, 9);
+  return new TransactionInstruction6({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: midpriceOraclePda, isSigner: false, isWritable: true },
+      { pubkey: SYSVAR_CLOCK_PUBKEY2, isSigner: false, isWritable: false }
+    ],
+    data
+  });
+}
+function buildUpdateMidpriceAndBaseSpread(authority, midpriceOraclePda, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 8 + 8 + 8);
+  data.writeUInt8(Discriminator.UpdateMidpriceAndBaseSpread, 0);
+  data.writeBigUInt64LE(params.sequence ?? 0n, 1);
+  data.writeBigUInt64LE(params.midpriceQ32, 9);
+  data.writeBigUInt64LE(params.baseSpreadQ32, 17);
+  return new TransactionInstruction6({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: midpriceOraclePda, isSigner: false, isWritable: true },
+      { pubkey: SYSVAR_CLOCK_PUBKEY2, isSigner: false, isWritable: false }
+    ],
+    data
+  });
+}
+
+// src/instructions/switchCurve.ts
+import { TransactionInstruction as TransactionInstruction7 } from "@solana/web3.js";
+function buildSwitchPriceCurve(authority, curveMetaPda, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 1 + 1);
+  data.writeUInt8(Discriminator.SwitchPriceCurve, 0);
+  data.writeUInt8(params.side, 1);
+  data.writeUInt8(params.slot, 2);
+  return new TransactionInstruction7({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: curveMetaPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+function buildSwitchRiskCurve(authority, curveMetaPda, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 1 + 1);
+  data.writeUInt8(Discriminator.SwitchRiskCurve, 0);
+  data.writeUInt8(params.side, 1);
+  data.writeUInt8(params.slot, 2);
+  return new TransactionInstruction7({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: curveMetaPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+
+// src/instructions/curveUpdates.ts
+import { TransactionInstruction as TransactionInstruction8 } from "@solana/web3.js";
+function buildSubmitCurveUpdates(authority, curveUpdatesPda, ops, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 1 + ops.length * CURVE_UPDATE_OP_SIZE);
+  let offset = 0;
+  data.writeUInt8(Discriminator.SubmitCurveUpdates, offset);
+  offset += 1;
+  data.writeUInt8(ops.length, offset);
+  offset += 1;
+  for (const op of ops) {
+    data.writeUInt8(op.curveType, offset);
+    offset += 1;
+    data.writeUInt8(op.opKind, offset);
+    offset += 1;
+    data.writeUInt8(op.pointIndex, offset);
+    offset += 1;
+    data.writeUInt8(op.interpolation, offset);
+    offset += 1;
+    data.writeBigUInt64LE(op.xIn, offset);
+    offset += 8;
+    data.writeBigUInt64LE(op.priceFactorQ32, offset);
+    offset += 8;
+    const params = op.params ?? new Uint8Array(4);
+    Buffer.from(params).copy(data, offset, 0, 4);
+    offset += 4;
+  }
+  return new TransactionInstruction8({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: curveUpdatesPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+function buildApplyCurveUpdates(authority, curveMetaPda, curvePrefabsPda, curveUpdatesPda, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1);
+  data.writeUInt8(Discriminator.ApplyCurveUpdates, 0);
+  return new TransactionInstruction8({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: curveMetaPda, isSigner: false, isWritable: false },
+      { pubkey: curvePrefabsPda, isSigner: false, isWritable: true },
+      { pubkey: curveUpdatesPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+
+// src/instructions/authority.ts
+import {
+  SYSVAR_CLOCK_PUBKEY as SYSVAR_CLOCK_PUBKEY3,
+  TransactionInstruction as TransactionInstruction9
+} from "@solana/web3.js";
+function buildNominateAuthority(authority, configPda, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 32 + 8);
+  let offset = 0;
+  data.writeUInt8(Discriminator.NominateAuthority, offset);
+  offset += 1;
+  params.newAuthority.toBuffer().copy(data, offset);
+  offset += 32;
+  data.writeBigUInt64LE(params.expirySlot, offset);
+  return new TransactionInstruction9({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: SYSVAR_CLOCK_PUBKEY3, isSigner: false, isWritable: false }
+    ],
+    data
+  });
+}
+function buildAcceptAuthority(newAuthority, configPda, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1);
+  data.writeUInt8(Discriminator.AcceptAuthority, 0);
+  return new TransactionInstruction9({
+    programId,
+    keys: [
+      { pubkey: newAuthority, isSigner: true, isWritable: false },
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: SYSVAR_CLOCK_PUBKEY3, isSigner: false, isWritable: false }
+    ],
+    data
+  });
+}
+function buildSetQuotingAuthority(authority, configPda, oraclePda, curveMetaPda, curveUpdatesPda, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 32);
+  data.writeUInt8(Discriminator.SetQuotingAuthority, 0);
+  params.newQuotingAuthority.toBuffer().copy(data, 1);
+  const keys = [
+    { pubkey: authority, isSigner: true, isWritable: false },
+    { pubkey: configPda, isSigner: false, isWritable: false },
+    { pubkey: oraclePda, isSigner: false, isWritable: true },
+    { pubkey: curveMetaPda, isSigner: false, isWritable: true },
+    { pubkey: curveUpdatesPda, isSigner: false, isWritable: true }
+  ];
+  if (params.spreadConfigPda) {
+    keys.push({
+      pubkey: params.spreadConfigPda,
+      isSigner: false,
+      isWritable: true
+    });
+  }
+  return new TransactionInstruction9({
+    programId,
+    keys,
+    data
+  });
+}
+
+// src/instructions/feeConfig.ts
+import {
+  SystemProgram as SystemProgram2,
+  TransactionInstruction as TransactionInstruction10
+} from "@solana/web3.js";
+function buildInitializeFeeConfig(payer, authority, params, programId = HADRON_PROGRAM_ID) {
+  const [feeConfigPda] = getFeeConfigAddress(programId);
+  const data = Buffer.alloc(1 + 4 + 32 + 32);
+  let offset = 0;
+  data.writeUInt8(Discriminator.InitializeFeeConfig, offset);
+  offset += 1;
+  data.writeUInt32LE(params.feePpm, offset);
+  offset += 4;
+  params.feeAdmin.toBuffer().copy(data, offset);
+  offset += 32;
+  params.feeRecipient.toBuffer().copy(data, offset);
+  return new TransactionInstruction10({
+    programId,
+    keys: [
+      { pubkey: payer, isSigner: true, isWritable: true },
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: feeConfigPda, isSigner: false, isWritable: true },
+      { pubkey: SystemProgram2.programId, isSigner: false, isWritable: false }
+    ],
+    data
+  });
+}
+function buildUpdateFeeConfig(feeAdmin, params, programId = HADRON_PROGRAM_ID) {
+  const [feeConfigPda] = getFeeConfigAddress(programId);
+  const data = Buffer.alloc(1 + 4 + 32);
+  let offset = 0;
+  data.writeUInt8(Discriminator.UpdateFeeConfig, offset);
+  offset += 1;
+  data.writeUInt32LE(params.feePpm !== null ? params.feePpm : 4294967295, offset);
+  offset += 4;
+  if (params.feeRecipient) {
+    params.feeRecipient.toBuffer().copy(data, offset);
+  }
+  return new TransactionInstruction10({
+    programId,
+    keys: [
+      { pubkey: feeAdmin, isSigner: true, isWritable: false },
+      { pubkey: feeConfigPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+function buildRotateFeeAdmin(feeAdmin, params, programId = HADRON_PROGRAM_ID) {
+  const [feeConfigPda] = getFeeConfigAddress(programId);
+  const data = Buffer.alloc(1 + 32);
+  data.writeUInt8(Discriminator.RotateFeeAdmin, 0);
+  params.newFeeAdmin.toBuffer().copy(data, 1);
+  return new TransactionInstruction10({
+    programId,
+    keys: [
+      { pubkey: feeAdmin, isSigner: true, isWritable: false },
+      { pubkey: feeConfigPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+
+// src/instructions/spreadConfig.ts
+import {
+  SystemProgram as SystemProgram3,
+  TransactionInstruction as TransactionInstruction11
+} from "@solana/web3.js";
+function buildInitializeSpreadConfig(payer, authority, configPda, params, programId = HADRON_PROGRAM_ID) {
+  const [spreadConfigPda] = getSpreadConfigAddress(configPda, programId);
+  const data = Buffer.alloc(1 + 32);
+  data.writeUInt8(Discriminator.InitializeSpreadConfig, 0);
+  params.admin.toBuffer().copy(data, 1);
+  return new TransactionInstruction11({
+    programId,
+    keys: [
+      { pubkey: payer, isSigner: true, isWritable: true },
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: spreadConfigPda, isSigner: false, isWritable: true },
+      { pubkey: SystemProgram3.programId, isSigner: false, isWritable: false }
+    ],
+    data
+  });
+}
+function buildUpdateSpreadConfig(admin, configPda, params, programId = HADRON_PROGRAM_ID) {
+  const [spreadConfigPda] = getSpreadConfigAddress(configPda, programId);
+  const numTriggers = params.triggers.length;
+  const data = Buffer.alloc(1 + 1 + numTriggers * 34);
+  let offset = 0;
+  data.writeUInt8(Discriminator.UpdateSpreadConfig, offset);
+  offset += 1;
+  data.writeUInt8(numTriggers, offset);
+  offset += 1;
+  for (const t of params.triggers) {
+    t.account.toBuffer().copy(data, offset);
+    offset += 32;
+    data.writeUInt16LE(t.spreadBps, offset);
+    offset += 2;
+  }
+  return new TransactionInstruction11({
+    programId,
+    keys: [
+      { pubkey: admin, isSigner: true, isWritable: false },
+      { pubkey: configPda, isSigner: false, isWritable: false },
+      { pubkey: spreadConfigPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+
+// src/instructions/poolState.ts
+import {
+  TransactionInstruction as TransactionInstruction12
+} from "@solana/web3.js";
+function buildSetPoolState(authority, configPda, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 1);
+  data.writeUInt8(Discriminator.SetPoolState, 0);
+  data.writeUInt8(params.newState, 1);
+  return new TransactionInstruction12({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: configPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+function buildUpdateDeltaStaleness(authority, configPda, params, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1 + 1);
+  data.writeUInt8(Discriminator.UpdateDeltaStaleness, 0);
+  data.writeUInt8(params.deltaStaleness, 1);
+  return new TransactionInstruction12({
+    programId,
+    keys: [
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: configPda, isSigner: false, isWritable: true }
+    ],
+    data
+  });
+}
+function buildClosePool(authority, configPda, midpriceOraclePda, curveMetaPda, curvePrefabsPda, curveUpdatesPda, vaultX, vaultY, tokenProgramX, tokenProgramY, spreadConfigInitialized = false, programId = HADRON_PROGRAM_ID) {
+  const data = Buffer.alloc(1);
+  data.writeUInt8(Discriminator.ClosePool, 0);
+  const keys = [
+    { pubkey: authority, isSigner: true, isWritable: true },
+    { pubkey: configPda, isSigner: false, isWritable: true },
+    { pubkey: midpriceOraclePda, isSigner: false, isWritable: true },
+    { pubkey: curveMetaPda, isSigner: false, isWritable: true },
+    { pubkey: curvePrefabsPda, isSigner: false, isWritable: true },
+    { pubkey: curveUpdatesPda, isSigner: false, isWritable: true },
+    { pubkey: vaultX, isSigner: false, isWritable: true },
+    { pubkey: vaultY, isSigner: false, isWritable: true },
+    { pubkey: tokenProgramX, isSigner: false, isWritable: false },
+    { pubkey: tokenProgramY, isSigner: false, isWritable: false }
+  ];
+  if (spreadConfigInitialized) {
+    const [spreadConfigPda] = getSpreadConfigAddress(configPda, programId);
+    keys.push({
+      pubkey: spreadConfigPda,
+      isSigner: false,
+      isWritable: true
+    });
+  }
+  return new TransactionInstruction12({ programId, keys, data });
+}
+
+// src/hadron.ts
+var Hadron = class _Hadron {
+  constructor(connection, poolAddress, addresses, config, oracle, curveMeta, curvePrefabsData, programId = HADRON_PROGRAM_ID) {
+    this.connection = connection;
+    this.poolAddress = poolAddress;
+    this.addresses = addresses;
+    this.config = config;
+    this.oracle = oracle;
+    this.curveMeta = curveMeta;
+    this.curvePrefabsData = curvePrefabsData;
+    this.programId = programId;
+  }
+  // ==========================================================================
+  // Static Factory Methods
+  // ==========================================================================
+  /**
+   * Load a Hadron instance from an existing pool address.
+   * Fetches all required accounts from the chain.
+   */
+  static async load(connection, poolAddress) {
+    const programId = HADRON_PROGRAM_ID;
+    const configInfo = await connection.getAccountInfo(poolAddress);
+    if (!configInfo) throw new Error("Config account not found");
+    const config = decodeConfig(configInfo.data);
+    const tokenProgramX = config.tokenProgramX;
+    const tokenProgramY = config.tokenProgramY;
+    const addresses = derivePoolAddresses(
+      config.seed,
+      config.mintX,
+      config.mintY,
+      tokenProgramX,
+      tokenProgramY,
+      programId
+    );
+    const [oracleInfo, curveMetaInfo, curvePrefabsInfo] = await Promise.all([
+      connection.getAccountInfo(addresses.midpriceOracle),
+      connection.getAccountInfo(addresses.curveMeta),
+      connection.getAccountInfo(addresses.curvePrefabs)
+    ]);
+    if (!oracleInfo) throw new Error("MidpriceOracle account not found");
+    if (!curveMetaInfo) throw new Error("CurveMeta account not found");
+    if (!curvePrefabsInfo) throw new Error("CurvePrefabs account not found");
+    const oracle = decodeMidpriceOracle(oracleInfo.data);
+    const curveMeta = decodeCurveMeta(curveMetaInfo.data);
+    return new _Hadron(
+      connection,
+      poolAddress,
+      addresses,
+      config,
+      oracle,
+      curveMeta,
+      curvePrefabsInfo.data,
+      programId
+    );
+  }
+  /**
+   * Load a Hadron instance from pool identity (seed + mints).
+   */
+  static async loadFromSeed(connection, seed, mintX, mintY) {
+    const programId = HADRON_PROGRAM_ID;
+    const [poolAddress] = getConfigAddress(seed, mintX, mintY, programId);
+    return _Hadron.load(connection, poolAddress);
+  }
+  /**
+   * 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, params) {
+    const programId = HADRON_PROGRAM_ID;
+    const seed = params.seed ?? _Hadron.randomSeed();
+    const maxPrefabSlots = params.maxPrefabSlots ?? DEFAULT_MAX_PREFAB_SLOTS;
+    const maxCurvePoints = params.maxCurvePoints ?? DEFAULT_MAX_CURVE_POINTS;
+    const resolvedParams = { ...params, seed };
+    const [poolAddress] = getConfigAddress(
+      seed,
+      params.mintX,
+      params.mintY,
+      programId
+    );
+    const allocateParams = {
+      seed,
+      mintX: params.mintX,
+      mintY: params.mintY,
+      maxPrefabSlots,
+      maxCurvePoints
+    };
+    const instructions = [];
+    const size = curvePrefabsSize(maxPrefabSlots, maxCurvePoints);
+    const allocateCalls = size > 10240 ? 2 : 1;
+    for (let i = 0; i < allocateCalls; i++) {
+      instructions.push(buildAllocateCurvePrefabs(payer, allocateParams, programId));
+    }
+    instructions.push(buildInitialize(payer, resolvedParams, programId));
+    return { instructions, poolAddress, seed };
+  }
+  /** Generate a random u64 seed. */
+  static randomSeed() {
+    const buf = new Uint8Array(8);
+    crypto.getRandomValues(buf);
+    return new DataView(buf.buffer).getBigUint64(0, true);
+  }
+  // ==========================================================================
+  // State Queries
+  // ==========================================================================
+  /** Re-fetch all account state from the chain. */
+  async refetchStates() {
+    const [configInfo, oracleInfo, curveMetaInfo, curvePrefabsInfo] = await Promise.all([
+      this.connection.getAccountInfo(this.poolAddress),
+      this.connection.getAccountInfo(this.addresses.midpriceOracle),
+      this.connection.getAccountInfo(this.addresses.curveMeta),
+      this.connection.getAccountInfo(this.addresses.curvePrefabs)
+    ]);
+    if (configInfo) this.config = decodeConfig(configInfo.data);
+    if (oracleInfo) this.oracle = decodeMidpriceOracle(oracleInfo.data);
+    if (curveMetaInfo) this.curveMeta = decodeCurveMeta(curveMetaInfo.data);
+    if (curvePrefabsInfo) this.curvePrefabsData = curvePrefabsInfo.data;
+  }
+  /** Get midprice as a floating-point number. */
+  getMidprice() {
+    return fromQ32(this.oracle.midpriceQ32);
+  }
+  /** Get base spread as a floating-point number. */
+  getBaseSpread() {
+    return fromQ32(this.oracle.baseSpreadQ32);
+  }
+  /** Get the currently active curve slot indices. */
+  getActiveCurveSlots() {
+    return {
+      priceBid: this.curveMeta.activePriceBidSlot,
+      priceAsk: this.curveMeta.activePriceAskSlot,
+      riskBid: this.curveMeta.activeRiskBidSlot,
+      riskAsk: this.curveMeta.activeRiskAskSlot
+    };
+  }
+  /** Decode the currently active curves from prefabs data. */
+  getActiveCurves() {
+    return decodeActiveCurves(this.curvePrefabsData, this.curveMeta);
+  }
+  /** Decode a specific curve slot. */
+  getCurveSlot(curveType, slot) {
+    return decodeCurveSide(
+      this.curvePrefabsData,
+      curveType,
+      slot,
+      this.curveMeta.maxPrefabSlots,
+      this.curveMeta.maxCurvePoints
+    );
+  }
+  // ==========================================================================
+  // Instruction Builders (convenience wrappers)
+  // ==========================================================================
+  /** Build deposit instruction. */
+  deposit(user, params) {
+    return buildDeposit(
+      user,
+      this.poolAddress,
+      this.config.mintX,
+      this.config.mintY,
+      this.config.tokenProgramX,
+      this.config.tokenProgramY,
+      params,
+      this.programId
+    );
+  }
+  /** Build withdraw instruction. */
+  withdraw(user, params) {
+    return buildWithdraw(
+      user,
+      this.poolAddress,
+      this.config.mintX,
+      this.config.mintY,
+      this.config.tokenProgramX,
+      this.config.tokenProgramY,
+      params,
+      this.programId
+    );
+  }
+  /** Build swap instruction. */
+  swap(user, params) {
+    return buildSwapExactIn(
+      user,
+      this.addresses,
+      this.config.mintX,
+      this.config.mintY,
+      this.config.tokenProgramX,
+      this.config.tokenProgramY,
+      params,
+      this.programId
+    );
+  }
+  /** Build set curve instruction. */
+  setCurve(authority, params) {
+    return buildSetCurve(
+      authority,
+      this.addresses.curveMeta,
+      this.addresses.curvePrefabs,
+      params,
+      this.programId
+    );
+  }
+  /** Build set risk curve instruction (percent-based x-axis). */
+  setRiskCurve(authority, params) {
+    return buildSetRiskCurve(
+      authority,
+      this.addresses.curveMeta,
+      this.addresses.curvePrefabs,
+      params,
+      this.programId
+    );
+  }
+  /** Build set risk curve instruction (absolute x-axis). */
+  setRiskCurveAbsolute(authority, params) {
+    return buildSetRiskCurveAbsolute(
+      authority,
+      this.addresses.curveMeta,
+      this.addresses.curvePrefabs,
+      params,
+      this.programId
+    );
+  }
+  /** Build set curve instructions for both bid and ask. Returns [bidIx, askIx]. */
+  setCurveBoth(authority, params) {
+    return buildSetCurveBoth(
+      authority,
+      this.addresses.curveMeta,
+      this.addresses.curvePrefabs,
+      params,
+      this.programId
+    );
+  }
+  /** Build set risk curve instructions for both bid and ask. Returns [bidIx, askIx]. */
+  setRiskCurveBoth(authority, params) {
+    return buildSetRiskCurveBoth(
+      authority,
+      this.addresses.curveMeta,
+      this.addresses.curvePrefabs,
+      params,
+      this.programId
+    );
+  }
+  /** Build set risk curve (absolute x-axis) instructions for both bid and ask. Returns [bidIx, askIx]. */
+  setRiskCurveAbsoluteBoth(authority, params) {
+    return buildSetRiskCurveAbsoluteBoth(
+      authority,
+      this.addresses.curveMeta,
+      this.addresses.curvePrefabs,
+      params,
+      this.programId
+    );
+  }
+  /** Build update midprice instruction. */
+  updateMidprice(authority, params) {
+    return buildUpdateMidprice(
+      authority,
+      this.addresses.midpriceOracle,
+      params,
+      this.programId
+    );
+  }
+  /** Build update base spread instruction. */
+  updateBaseSpread(authority, params) {
+    return buildUpdateBaseSpread(
+      authority,
+      this.addresses.midpriceOracle,
+      params,
+      this.programId
+    );
+  }
+  /** Build atomic update of midprice + base spread. */
+  updateMidpriceAndBaseSpread(authority, params) {
+    return buildUpdateMidpriceAndBaseSpread(
+      authority,
+      this.addresses.midpriceOracle,
+      params,
+      this.programId
+    );
+  }
+  /** Build switch price curve instruction (hot path). */
+  switchPriceCurve(authority, params) {
+    return buildSwitchPriceCurve(
+      authority,
+      this.addresses.curveMeta,
+      params,
+      this.programId
+    );
+  }
+  /** Build switch risk curve instruction (hot path). */
+  switchRiskCurve(authority, params) {
+    return buildSwitchRiskCurve(
+      authority,
+      this.addresses.curveMeta,
+      params,
+      this.programId
+    );
+  }
+  /** Build submit curve updates instruction (hot path). */
+  submitCurveUpdates(authority, ops) {
+    return buildSubmitCurveUpdates(
+      authority,
+      this.addresses.curveUpdates,
+      ops,
+      this.programId
+    );
+  }
+  /** Build apply curve updates instruction. */
+  applyCurveUpdates(authority) {
+    return buildApplyCurveUpdates(
+      authority,
+      this.addresses.curveMeta,
+      this.addresses.curvePrefabs,
+      this.addresses.curveUpdates,
+      this.programId
+    );
+  }
+  /** Build nominate authority instruction. */
+  nominateAuthority(authority, params) {
+    return buildNominateAuthority(
+      authority,
+      this.poolAddress,
+      params,
+      this.programId
+    );
+  }
+  /** Build accept authority instruction. */
+  acceptAuthority(newAuthority) {
+    return buildAcceptAuthority(
+      newAuthority,
+      this.poolAddress,
+      this.programId
+    );
+  }
+  /** Build set pool state instruction. */
+  setPoolState(authority, params) {
+    return buildSetPoolState(
+      authority,
+      this.poolAddress,
+      params,
+      this.programId
+    );
+  }
+  /** Build update delta staleness instruction. */
+  updateDeltaStaleness(authority, params) {
+    return buildUpdateDeltaStaleness(
+      authority,
+      this.poolAddress,
+      params,
+      this.programId
+    );
+  }
+  /** Build close pool instruction. */
+  closePool(authority) {
+    return buildClosePool(
+      authority,
+      this.poolAddress,
+      this.addresses.midpriceOracle,
+      this.addresses.curveMeta,
+      this.addresses.curvePrefabs,
+      this.addresses.curveUpdates,
+      this.addresses.vaultX,
+      this.addresses.vaultY,
+      this.config.tokenProgramX,
+      this.config.tokenProgramY,
+      this.config.spreadConfigInitialized,
+      this.programId
+    );
+  }
+};
+
+// src/helpers/token.ts
+import {
+  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync5,
+  createAssociatedTokenAccountInstruction,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID2
+} from "@solana/spl-token";
+async function getOrCreateAta(connection, mint, owner, payer, tokenProgram = TOKEN_PROGRAM_ID2, allowOwnerOffCurve = false) {
+  const address = getAssociatedTokenAddressSync5(
+    mint,
+    owner,
+    allowOwnerOffCurve,
+    tokenProgram
+  );
+  const account = await connection.getAccountInfo(address);
+  if (account) {
+    return { address, instruction: null };
+  }
+  const instruction = createAssociatedTokenAccountInstruction(
+    payer,
+    address,
+    owner,
+    mint,
+    tokenProgram
+  );
+  return { address, instruction };
+}
+export {
+  ABSOLUTE_MAX_CURVE_POINTS,
+  ABSOLUTE_MAX_PREFAB_SLOTS,
+  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,
+  CurveType,
+  CurveUpdateOpKind,
+  CurveXMode,
+  DEFAULT_MAX_CURVE_POINTS,
+  DEFAULT_MAX_PREFAB_SLOTS,
+  Discriminator,
+  FEE_CONFIG_SEED,
+  FEE_CONFIG_SIZE,
+  HADRON_PROGRAM_ID,
+  Hadron,
+  Interpolation,
+  MAX_CURVE_UPDATE_OPS,
+  MAX_SETCURVE_POINTS,
+  MIDPRICE_ORACLE_SEED,
+  MIDPRICE_ORACLE_SIZE,
+  OracleMode,
+  POINT_DATA_SIZE,
+  PoolState,
+  Q32_ONE,
+  RiskMode,
+  SPREAD_CONFIG_SEED,
+  Side,
+  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
+};
+//# sourceMappingURL=index.mjs.map