@hadron-fi/sdk 0.2.0 → 0.3.1

package/dist/index.js

@@ -309,6 +309,24 @@ function decodeFeeConfig(data) {
     feeRecipient: new (0, _web3js.PublicKey)(buf.subarray(40, 72))
   };
 }
+var SPREAD_TRIGGER_LEN = 40;
+function decodeSpreadConfig(data) {
+  const buf = Buffer.from(data);
+  const initialized = buf.readUInt8(0) !== 0;
+  const bump = buf.readUInt8(1);
+  const numTriggers = buf.readUInt8(2);
+  const admin = new (0, _web3js.PublicKey)(buf.subarray(8, 40));
+  const config = new (0, _web3js.PublicKey)(buf.subarray(40, 72));
+  const triggers = [];
+  const triggersStart = 72;
+  for (let i = 0; i < numTriggers; i++) {
+    const off = triggersStart + i * SPREAD_TRIGGER_LEN;
+    const account = new (0, _web3js.PublicKey)(buf.subarray(off, off + 32));
+    const spreadBps = buf.readUInt16LE(off + 32);
+    triggers.push({ account, spreadBps });
+  }
+  return { initialized, bump, numTriggers, admin, config, triggers };
+}
 function decodeCurveUpdates(data) {
   const buf = Buffer.from(data);
   let offset = 0;
@@ -1519,6 +1537,66 @@ var Hadron = class _Hadron {
       this.programId
     );
   }
+  /** Build initialize spread config instruction. */
+  initializeSpreadConfig(payer, authority, params) {
+    return buildInitializeSpreadConfig(
+      payer,
+      authority,
+      this.poolAddress,
+      params,
+      this.programId
+    );
+  }
+  /** Build update spread config instruction (full replacement). */
+  updateSpreadConfig(admin, params) {
+    return buildUpdateSpreadConfig(
+      admin,
+      this.poolAddress,
+      params,
+      this.programId
+    );
+  }
+  /**
+   * Fetch current spread triggers, append new ones, and return the update ix.
+   * If a trigger for the same account already exists, its spreadBps is updated.
+   */
+  async addSpreadTriggers(admin, triggers) {
+    const current = await this.fetchSpreadTriggers();
+    const merged = [...current];
+    for (const t of triggers) {
+      const existing = merged.findIndex(
+        (e) => e.account.equals(t.account)
+      );
+      if (existing >= 0) {
+        merged[existing] = t;
+      } else {
+        merged.push(t);
+      }
+    }
+    return this.updateSpreadConfig(admin, { triggers: merged });
+  }
+  /**
+   * Fetch current spread triggers, remove the given accounts, and return the update ix.
+   */
+  async removeSpreadTriggers(admin, accounts) {
+    const current = await this.fetchSpreadTriggers();
+    const removeSet = new Set(accounts.map((a) => a.toBase58()));
+    const filtered = current.filter(
+      (t) => !removeSet.has(t.account.toBase58())
+    );
+    return this.updateSpreadConfig(admin, { triggers: filtered });
+  }
+  /** Fetch and decode the current spread config triggers from chain. */
+  async fetchSpreadTriggers() {
+    const [spreadConfigPda] = getSpreadConfigAddress(
+      this.poolAddress,
+      this.programId
+    );
+    const info = await this.connection.getAccountInfo(spreadConfigPda);
+    if (!info) return [];
+    const decoded = decodeSpreadConfig(info.data);
+    return decoded.triggers;
+  }
   /** Build close pool instruction. */
   closePool(authority) {
     return buildClosePool(
@@ -1538,6 +1616,565 @@ var Hadron = class _Hadron {
   }
 };
 
+// src/orderbook.ts
+var MAX_ORDERS_PER_SIDE = MAX_SETCURVE_POINTS - 1;
+function tokensToAtoms(tokens, decimals) {
+  return BigInt(Math.round(tokens * 10 ** decimals));
+}
+function atomsToTokens(atoms, decimals) {
+  return Number(atoms) / 10 ** decimals;
+}
+var HadronOrderbook = class _HadronOrderbook {
+  constructor(pool, decimalsX, decimalsY, initialVaultX, initialVaultY) {
+    this.bidOrders = [];
+    this.askOrders = [];
+    this.bidsDirty = false;
+    this.asksDirty = false;
+    this.priceCurvesSet = false;
+    this.riskBidInitialized = false;
+    this.riskAskInitialized = false;
+    this.committedBidPoints = [];
+    this.committedAskPoints = [];
+    this.pool = pool;
+    this.decimalsX = decimalsX;
+    this.decimalsY = decimalsY;
+    this.initialVaultX = initialVaultX;
+    this.initialVaultY = initialVaultY;
+  }
+  // ==========================================================================
+  // Static Factories
+  // ==========================================================================
+  /**
+   * Load an orderbook from an existing on-chain pool.
+   * Fetches decimals and vault balances, and reconstructs staged orders
+   * from the active risk curves.
+   */
+  static async load(params) {
+    const { connection, pool: poolAddress } = params;
+    const hadron = await Hadron.load(connection, poolAddress);
+    const [mintXInfo, mintYInfo, vaultXInfo, vaultYInfo] = await Promise.all([
+      connection.getAccountInfo(hadron.config.mintX),
+      connection.getAccountInfo(hadron.config.mintY),
+      connection.getAccountInfo(hadron.addresses.vaultX),
+      connection.getAccountInfo(hadron.addresses.vaultY)
+    ]);
+    if (!mintXInfo || !mintYInfo) throw new Error("Mint account(s) not found");
+    if (!vaultXInfo || !vaultYInfo) throw new Error("Vault account(s) not found");
+    const decimalsX = mintXInfo.data[44];
+    const decimalsY = mintYInfo.data[44];
+    const vaultXBalance = new DataView(
+      vaultXInfo.data.buffer,
+      vaultXInfo.data.byteOffset
+    ).getBigUint64(64, true);
+    const vaultYBalance = new DataView(
+      vaultYInfo.data.buffer,
+      vaultYInfo.data.byteOffset
+    ).getBigUint64(64, true);
+    const book = new _HadronOrderbook(
+      hadron,
+      decimalsX,
+      decimalsY,
+      vaultXBalance,
+      vaultYBalance
+    );
+    book.reconstructFromCurves();
+    return book;
+  }
+  /**
+   * Wrap an existing Hadron instance as an orderbook.
+   * Useful for tests or when you already have the pool loaded.
+   */
+  static fromPool(pool, decimalsX, decimalsY, initialVaultX, initialVaultY) {
+    return new _HadronOrderbook(
+      pool,
+      decimalsX,
+      decimalsY,
+      initialVaultX,
+      initialVaultY
+    );
+  }
+  // ==========================================================================
+  // Order Management
+  // ==========================================================================
+  /**
+   * Place a new order. Orders are staged locally and pushed on-chain via `push()`.
+   * Orders on each side are sorted by spreadBps ascending (tightest first).
+   * @throws If more than 31 orders on a side.
+   */
+  placeOrder(params) {
+    const orders = params.side === "bid" ? this.bidOrders : this.askOrders;
+    if (orders.length >= MAX_ORDERS_PER_SIDE) {
+      throw new Error(
+        `Cannot place more than ${MAX_ORDERS_PER_SIDE} orders per side`
+      );
+    }
+    orders.push({ size: params.size, spreadBps: params.spreadBps });
+    orders.sort((a, b) => a.spreadBps - b.spreadBps);
+    if (params.side === "bid") this.bidsDirty = true;
+    else this.asksDirty = true;
+  }
+  /**
+   * Amend an existing order at the given level index.
+   * Re-sorts if spread changes.
+   * @throws On invalid index.
+   */
+  amendOrder(params) {
+    const orders = params.side === "bid" ? this.bidOrders : this.askOrders;
+    if (params.level < 0 || params.level >= orders.length) {
+      throw new Error(
+        `Invalid level ${params.level} for ${params.side} (have ${orders.length} orders)`
+      );
+    }
+    const order = orders[params.level];
+    if (params.spreadBps !== void 0) order.spreadBps = params.spreadBps;
+    if (params.size !== void 0) order.size = params.size;
+    orders.sort((a, b) => a.spreadBps - b.spreadBps);
+    if (params.side === "bid") this.bidsDirty = true;
+    else this.asksDirty = true;
+  }
+  /**
+   * Cancel the order at the given level index.
+   * @throws On invalid index.
+   */
+  cancelOrder(params) {
+    const orders = params.side === "bid" ? this.bidOrders : this.askOrders;
+    if (params.level < 0 || params.level >= orders.length) {
+      throw new Error(
+        `Invalid level ${params.level} for ${params.side} (have ${orders.length} orders)`
+      );
+    }
+    orders.splice(params.level, 1);
+    if (params.side === "bid") this.bidsDirty = true;
+    else this.asksDirty = true;
+  }
+  /** Cancel all orders on one or both sides. */
+  cancelAll(side) {
+    if (!side || side === "bid") {
+      this.bidOrders = [];
+      this.bidsDirty = true;
+    }
+    if (!side || side === "ask") {
+      this.askOrders = [];
+      this.asksDirty = true;
+    }
+  }
+  /** Read-only access to staged bid orders. */
+  getBids() {
+    return this.bidOrders;
+  }
+  /** Read-only access to staged ask orders. */
+  getAsks() {
+    return this.askOrders;
+  }
+  // ==========================================================================
+  // Push (orders → on-chain risk curves)
+  // ==========================================================================
+  /**
+   * Build transaction instructions to push the current staged orders on-chain.
+   *
+   * 1. On first push, sets flat price curves (factor=1.0, Step interpolation).
+   * 2. If risk curves not yet initialized, uses setRiskCurveAbsolute (sets headers).
+   * 3. On subsequent pushes, computes a minimal diff and uses curve updates
+   *    (submit + apply) when possible, falling back to full rewrite for large diffs.
+   */
+  push(authority) {
+    const ixs = [];
+    if (!this.priceCurvesSet) {
+      const flatPoints = [
+        { amountIn: 0n, priceFactor: 1, interpolation: 0 /* Step */ },
+        {
+          amountIn: BigInt("1000000000000000000"),
+          priceFactor: 1,
+          interpolation: 0 /* Step */
+        }
+      ];
+      const [bidPriceIx, askPriceIx] = this.pool.setCurveBoth(authority, {
+        bid: { defaultInterpolation: 0 /* Step */, points: flatPoints },
+        ask: { defaultInterpolation: 0 /* Step */, points: flatPoints }
+      });
+      ixs.push(bidPriceIx, askPriceIx);
+      this.priceCurvesSet = true;
+    }
+    if (!this.riskBidInitialized || !this.riskAskInitialized) {
+      ixs.push(...this.buildFullRiskCurveIxs(authority));
+      this.bidsDirty = false;
+      this.asksDirty = false;
+      return ixs;
+    }
+    const updateIxs = this.buildCurveUpdateIxs(authority);
+    ixs.push(...updateIxs);
+    this.bidsDirty = false;
+    this.asksDirty = false;
+    return ixs;
+  }
+  // ==========================================================================
+  // Delegated Methods
+  // ==========================================================================
+  /** Build an updateMidprice instruction. */
+  updateMidprice(authority, midprice, sequence) {
+    const params = {
+      midpriceQ32: BigInt(Math.floor(midprice * 2 ** 32)),
+      sequence
+    };
+    return this.pool.updateMidprice(authority, params);
+  }
+  /** Build a deposit instruction. */
+  deposit(user, params) {
+    return this.pool.deposit(user, params);
+  }
+  /** Build a withdraw instruction. */
+  withdraw(user, params) {
+    return this.pool.withdraw(user, params);
+  }
+  /** Build a setPoolState instruction. */
+  setPoolState(authority, params) {
+    return this.pool.setPoolState(authority, params);
+  }
+  /**
+   * Get the current book state by reading on-chain risk curves + midprice.
+   * Reconstructs levels from curve points.
+   */
+  getBookState() {
+    const midprice = this.pool.getMidprice();
+    const curves = this.pool.getActiveCurves();
+    const bids = this.curveSideToLevels(
+      curves.riskBid,
+      midprice,
+      "bid",
+      this.decimalsX
+    );
+    const asks = this.curveSideToLevels(
+      curves.riskAsk,
+      midprice,
+      "ask",
+      this.decimalsY
+    );
+    const base = atomsToTokens(this.initialVaultX, this.decimalsX);
+    const quote = atomsToTokens(this.initialVaultY, this.decimalsY);
+    return { midprice, bids, asks, inventory: { base, quote } };
+  }
+  // ==========================================================================
+  // Curve Update Diff Algorithm
+  // ==========================================================================
+  /**
+   * Compute the minimal set of curve update ops to transform `committed` into `desired`.
+   *
+   * Algorithm:
+   * 1. Scan left-to-right for factor-only diffs (amountIn unchanged) → Edit ops.
+   * 2. At the first structural diff (amountIn changed or length mismatch),
+   *    truncate-and-rebuild: remove all from that index to end, then add desired.
+   * 3. Returns the ops array.
+   */
+  static computeCurveOps(committed, desired, curveType) {
+    const ops = [];
+    const minLen = Math.min(committed.length, desired.length);
+    let structuralDiffIndex = minLen;
+    for (let i = 0; i < minLen; i++) {
+      const c = committed[i];
+      const d = desired[i];
+      if (c.amountIn !== d.amountIn) {
+        structuralDiffIndex = i;
+        break;
+      }
+      if (c.priceFactorQ32 !== d.priceFactorQ32 || c.interpolation !== d.interpolation) {
+        ops.push({
+          curveType,
+          opKind: 0 /* Edit */,
+          pointIndex: i,
+          interpolation: d.interpolation,
+          amountIn: d.amountIn,
+          priceFactorQ32: d.priceFactorQ32,
+          params: d.params
+        });
+      }
+    }
+    if (structuralDiffIndex === minLen && committed.length !== desired.length) {
+      structuralDiffIndex = minLen;
+    }
+    if (structuralDiffIndex === minLen && committed.length === desired.length) {
+      return ops;
+    }
+    const numToRemove = committed.length - structuralDiffIndex;
+    for (let i = 0; i < numToRemove; i++) {
+      ops.push({
+        curveType,
+        opKind: 2 /* Remove */,
+        pointIndex: structuralDiffIndex,
+        interpolation: 0 /* Step */,
+        amountIn: 0n,
+        priceFactorQ32: 0n,
+        params: new Uint8Array(4)
+      });
+    }
+    for (let i = structuralDiffIndex; i < desired.length; i++) {
+      const d = desired[i];
+      ops.push({
+        curveType,
+        opKind: 1 /* Add */,
+        pointIndex: i,
+        interpolation: d.interpolation,
+        amountIn: d.amountIn,
+        priceFactorQ32: d.priceFactorQ32,
+        params: d.params
+      });
+    }
+    return ops;
+  }
+  // ==========================================================================
+  // Internal Helpers
+  // ==========================================================================
+  /** Convert SetRiskCurveAbsolutePointInput[] to CurvePoint[] for diffing. */
+  static toCommittedPoints(points) {
+    return points.map((p) => ({
+      amountIn: p.vaultBalance,
+      priceFactorQ32: toQ32(p.priceFactor),
+      interpolation: _nullishCoalesce(p.interpolation, () => ( 0)) /* Step */,
+      params: _nullishCoalesce(p.params, () => ( new Uint8Array(4)))
+    }));
+  }
+  /**
+   * Build full setRiskCurveAbsolute instructions for sides that need initialization.
+   * After sending, snapshots committed points and marks sides as initialized.
+   */
+  buildFullRiskCurveIxs(authority) {
+    const ixs = [];
+    const hasBids = this.bidOrders.length > 0;
+    const hasAsks = this.askOrders.length > 0;
+    const bidPoints = hasBids ? this.buildBidRiskPoints() : void 0;
+    const askPoints = hasAsks ? this.buildAskRiskPoints() : void 0;
+    if (bidPoints && askPoints && !this.riskBidInitialized && !this.riskAskInitialized) {
+      const [bidIx, askIx] = this.pool.setRiskCurveAbsoluteBoth(authority, {
+        bid: {
+          defaultInterpolation: 0 /* Step */,
+          points: bidPoints,
+          riskMode: 1 /* Integrated */
+        },
+        ask: {
+          defaultInterpolation: 0 /* Step */,
+          points: askPoints,
+          riskMode: 1 /* Integrated */
+        }
+      });
+      ixs.push(bidIx, askIx);
+      this.committedBidPoints = _HadronOrderbook.toCommittedPoints(bidPoints);
+      this.committedAskPoints = _HadronOrderbook.toCommittedPoints(askPoints);
+      this.riskBidInitialized = true;
+      this.riskAskInitialized = true;
+    } else {
+      if (bidPoints && !this.riskBidInitialized) {
+        ixs.push(
+          this.pool.setRiskCurveAbsolute(authority, {
+            side: 0 /* Bid */,
+            defaultInterpolation: 0 /* Step */,
+            points: bidPoints,
+            riskMode: 1 /* Integrated */
+          })
+        );
+        this.committedBidPoints = _HadronOrderbook.toCommittedPoints(bidPoints);
+        this.riskBidInitialized = true;
+      }
+      if (askPoints && !this.riskAskInitialized) {
+        ixs.push(
+          this.pool.setRiskCurveAbsolute(authority, {
+            side: 1 /* Ask */,
+            defaultInterpolation: 0 /* Step */,
+            points: askPoints,
+            riskMode: 1 /* Integrated */
+          })
+        );
+        this.committedAskPoints = _HadronOrderbook.toCommittedPoints(askPoints);
+        this.riskAskInitialized = true;
+      }
+    }
+    return ixs;
+  }
+  /**
+   * Build curve update instructions (submit + apply pairs) for both sides.
+   * Falls back to full setRiskCurve rewrite if diff is too large.
+   */
+  buildCurveUpdateIxs(authority) {
+    const bidPoints = this.buildBidRiskPoints();
+    const askPoints = this.buildAskRiskPoints();
+    const desiredBid = _HadronOrderbook.toCommittedPoints(bidPoints);
+    const desiredAsk = _HadronOrderbook.toCommittedPoints(askPoints);
+    const bidOps = _HadronOrderbook.computeCurveOps(
+      this.committedBidPoints,
+      desiredBid,
+      2 /* RiskBid */
+    );
+    const askOps = _HadronOrderbook.computeCurveOps(
+      this.committedAskPoints,
+      desiredAsk,
+      3 /* RiskAsk */
+    );
+    const allOps = [...bidOps, ...askOps];
+    if (allOps.length === 0) {
+      return [];
+    }
+    if (allOps.length > MAX_CURVE_UPDATE_OPS * 4) {
+      return this.buildFallbackRewrite(authority, bidPoints, askPoints);
+    }
+    const ixs = [];
+    for (let i = 0; i < allOps.length; i += MAX_CURVE_UPDATE_OPS) {
+      const batch = allOps.slice(i, i + MAX_CURVE_UPDATE_OPS);
+      ixs.push(this.pool.submitCurveUpdates(authority, batch));
+      ixs.push(this.pool.applyCurveUpdates(authority));
+    }
+    this.committedBidPoints = desiredBid;
+    this.committedAskPoints = desiredAsk;
+    return ixs;
+  }
+  /** Fallback: full setRiskCurve rewrite for both sides. */
+  buildFallbackRewrite(authority, bidPoints, askPoints) {
+    const [bidIx, askIx] = this.pool.setRiskCurveAbsoluteBoth(authority, {
+      bid: {
+        defaultInterpolation: 0 /* Step */,
+        points: bidPoints,
+        riskMode: 1 /* Integrated */
+      },
+      ask: {
+        defaultInterpolation: 0 /* Step */,
+        points: askPoints,
+        riskMode: 1 /* Integrated */
+      }
+    });
+    this.committedBidPoints = _HadronOrderbook.toCommittedPoints(bidPoints);
+    this.committedAskPoints = _HadronOrderbook.toCommittedPoints(askPoints);
+    return [bidIx, askIx];
+  }
+  buildBidRiskPoints() {
+    const points = [];
+    let cumulativeAtoms = this.initialVaultX;
+    for (const order of this.bidOrders) {
+      const priceFactor = 1 - order.spreadBps / 1e4;
+      points.push({
+        vaultBalance: cumulativeAtoms,
+        priceFactor,
+        interpolation: 0 /* Step */
+      });
+      cumulativeAtoms += tokensToAtoms(order.size, this.decimalsX);
+    }
+    const lastFactor = this.bidOrders.length > 0 ? 1 - this.bidOrders[this.bidOrders.length - 1].spreadBps / 1e4 : 1;
+    points.push({
+      vaultBalance: cumulativeAtoms,
+      priceFactor: lastFactor,
+      interpolation: 0 /* Step */
+    });
+    return points;
+  }
+  buildAskRiskPoints() {
+    const points = [];
+    let cumulativeAtoms = this.initialVaultY;
+    const midprice = this.pool.getMidprice();
+    for (const order of this.askOrders) {
+      const priceFactor = 1 + order.spreadBps / 1e4;
+      points.push({
+        vaultBalance: cumulativeAtoms,
+        priceFactor,
+        interpolation: 0 /* Step */
+      });
+      const quoteSizeTokens = order.size * midprice;
+      cumulativeAtoms += tokensToAtoms(quoteSizeTokens, this.decimalsY);
+    }
+    const lastFactor = this.askOrders.length > 0 ? 1 + this.askOrders[this.askOrders.length - 1].spreadBps / 1e4 : 1;
+    points.push({
+      vaultBalance: cumulativeAtoms,
+      priceFactor: lastFactor,
+      interpolation: 0 /* Step */
+    });
+    return points;
+  }
+  /**
+   * Reconstruct staged orders from on-chain risk curves (after load).
+   * Assumes curves were set via this class (CurveXMode.Alternate, RiskMode.Integrated, Step).
+   */
+  reconstructFromCurves() {
+    const curves = this.pool.getActiveCurves();
+    if (curves.riskBid.xMode === 1 /* Alternate */ && curves.riskBid.riskMode === 1 /* Integrated */ && curves.riskBid.numPoints >= 2) {
+      this.riskBidInitialized = true;
+      this.priceCurvesSet = true;
+      this.committedBidPoints = curves.riskBid.points.map((p) => ({
+        amountIn: p.amountIn,
+        priceFactorQ32: p.priceFactorQ32,
+        interpolation: p.interpolation,
+        params: new Uint8Array(p.params)
+      }));
+    }
+    if (curves.riskAsk.xMode === 1 /* Alternate */ && curves.riskAsk.riskMode === 1 /* Integrated */ && curves.riskAsk.numPoints >= 2) {
+      this.riskAskInitialized = true;
+      this.priceCurvesSet = true;
+      this.committedAskPoints = curves.riskAsk.points.map((p) => ({
+        amountIn: p.amountIn,
+        priceFactorQ32: p.priceFactorQ32,
+        interpolation: p.interpolation,
+        params: new Uint8Array(p.params)
+      }));
+    }
+    this.bidOrders = this.reconstructSide(
+      curves.riskBid,
+      "bid",
+      this.initialVaultX,
+      this.decimalsX
+    );
+    this.askOrders = this.reconstructSide(
+      curves.riskAsk,
+      "ask",
+      this.initialVaultY,
+      this.decimalsY
+    );
+  }
+  reconstructSide(curve, side, initialVault, decimals) {
+    if (curve.xMode !== 1 /* Alternate */ || curve.riskMode !== 1 /* Integrated */) {
+      return [];
+    }
+    const orders = [];
+    const points = curve.points;
+    for (let i = 0; i < points.length - 1; i++) {
+      const pt = points[i];
+      const nextPt = points[i + 1];
+      const priceFactor = fromQ32(pt.priceFactorQ32);
+      let spreadBps;
+      if (side === "bid") {
+        spreadBps = Math.round((1 - priceFactor) * 1e4);
+      } else {
+        spreadBps = Math.round((priceFactor - 1) * 1e4);
+      }
+      const sizeAtoms = nextPt.amountIn - pt.amountIn;
+      let sizeTokens;
+      if (side === "ask") {
+        const midprice = this.pool.getMidprice();
+        sizeTokens = atomsToTokens(sizeAtoms, decimals) / midprice;
+      } else {
+        sizeTokens = atomsToTokens(sizeAtoms, decimals);
+      }
+      orders.push({ size: sizeTokens, spreadBps });
+    }
+    return orders;
+  }
+  curveSideToLevels(curve, midprice, side, decimals) {
+    if (curve.numPoints < 2) return [];
+    const levels = [];
+    let cumulative = 0;
+    const points = curve.points;
+    for (let i = 0; i < points.length - 1; i++) {
+      const pt = points[i];
+      const nextPt = points[i + 1];
+      const priceFactor = fromQ32(pt.priceFactorQ32);
+      const price = midprice * priceFactor;
+      const sizeAtoms = nextPt.amountIn - pt.amountIn;
+      let sizeTokens;
+      if (side === "ask") {
+        sizeTokens = atomsToTokens(sizeAtoms, decimals) / midprice;
+      } else {
+        sizeTokens = atomsToTokens(sizeAtoms, decimals);
+      }
+      cumulative += sizeTokens;
+      levels.push({ price, size: sizeTokens, cumulative });
+    }
+    return levels;
+  }
+};
+
 // src/helpers/token.ts
 
 
@@ -1649,5 +2286,7 @@ async function getOrCreateAta(connection, mint, owner, payer, tokenProgram = _sp
 
 
 
-exports.ABSOLUTE_MAX_CURVE_POINTS = ABSOLUTE_MAX_CURVE_POINTS; exports.ABSOLUTE_MAX_PREFAB_SLOTS = ABSOLUTE_MAX_PREFAB_SLOTS; exports.CONFIG_SEED = CONFIG_SEED; exports.CONFIG_SIZE = CONFIG_SIZE; exports.CURVE_META_SEED = CURVE_META_SEED; exports.CURVE_META_SIZE = CURVE_META_SIZE; exports.CURVE_POINT_LEN = CURVE_POINT_LEN; exports.CURVE_PREFABS_SEED = CURVE_PREFABS_SEED; exports.CURVE_SIDE_HEADER = CURVE_SIDE_HEADER; exports.CURVE_UPDATES_SEED = CURVE_UPDATES_SEED; exports.CURVE_UPDATES_SIZE = CURVE_UPDATES_SIZE; exports.CURVE_UPDATE_OP_SIZE = CURVE_UPDATE_OP_SIZE; exports.CurveType = CurveType; exports.CurveUpdateOpKind = CurveUpdateOpKind; exports.CurveXMode = CurveXMode; exports.DEFAULT_MAX_CURVE_POINTS = DEFAULT_MAX_CURVE_POINTS; exports.DEFAULT_MAX_PREFAB_SLOTS = DEFAULT_MAX_PREFAB_SLOTS; exports.Discriminator = Discriminator; exports.FEE_CONFIG_SEED = FEE_CONFIG_SEED; exports.FEE_CONFIG_SIZE = FEE_CONFIG_SIZE; exports.HADRON_PROGRAM_ID = HADRON_PROGRAM_ID; exports.Hadron = Hadron; exports.Interpolation = Interpolation; exports.MAX_CURVE_UPDATE_OPS = MAX_CURVE_UPDATE_OPS; exports.MAX_SETCURVE_POINTS = MAX_SETCURVE_POINTS; exports.MIDPRICE_ORACLE_SEED = MIDPRICE_ORACLE_SEED; exports.MIDPRICE_ORACLE_SIZE = MIDPRICE_ORACLE_SIZE; exports.OracleMode = OracleMode; exports.POINT_DATA_SIZE = POINT_DATA_SIZE; exports.PoolState = PoolState; exports.Q32_ONE = Q32_ONE; exports.RiskMode = RiskMode; exports.SPREAD_CONFIG_SEED = SPREAD_CONFIG_SEED; exports.Side = Side; exports.buildAcceptAuthority = buildAcceptAuthority; exports.buildAllocateCurvePrefabs = buildAllocateCurvePrefabs; exports.buildApplyCurveUpdates = buildApplyCurveUpdates; exports.buildClosePool = buildClosePool; exports.buildDeposit = buildDeposit; exports.buildInitialize = buildInitialize; exports.buildInitializeFeeConfig = buildInitializeFeeConfig; exports.buildInitializeSpreadConfig = buildInitializeSpreadConfig; exports.buildNominateAuthority = buildNominateAuthority; exports.buildRotateFeeAdmin = buildRotateFeeAdmin; exports.buildSetCurve = buildSetCurve; exports.buildSetCurveBoth = buildSetCurveBoth; exports.buildSetPoolState = buildSetPoolState; exports.buildSetQuotingAuthority = buildSetQuotingAuthority; exports.buildSetRiskCurve = buildSetRiskCurve; exports.buildSetRiskCurveAbsolute = buildSetRiskCurveAbsolute; exports.buildSetRiskCurveAbsoluteBoth = buildSetRiskCurveAbsoluteBoth; exports.buildSetRiskCurveBoth = buildSetRiskCurveBoth; exports.buildSubmitCurveUpdates = buildSubmitCurveUpdates; exports.buildSwapExactIn = buildSwapExactIn; exports.buildSwitchPriceCurve = buildSwitchPriceCurve; exports.buildSwitchRiskCurve = buildSwitchRiskCurve; exports.buildUpdateBaseSpread = buildUpdateBaseSpread; exports.buildUpdateDeltaStaleness = buildUpdateDeltaStaleness; exports.buildUpdateFeeConfig = buildUpdateFeeConfig; exports.buildUpdateMidprice = buildUpdateMidprice; exports.buildUpdateMidpriceAndBaseSpread = buildUpdateMidpriceAndBaseSpread; exports.buildUpdateSpreadConfig = buildUpdateSpreadConfig; exports.buildWithdraw = buildWithdraw; exports.curvePrefabsSize = curvePrefabsSize; exports.decodeActiveCurves = decodeActiveCurves; exports.decodeConfig = decodeConfig; exports.decodeCurveMeta = decodeCurveMeta; exports.decodeCurveSide = decodeCurveSide; exports.decodeCurveUpdates = decodeCurveUpdates; exports.decodeFeeConfig = decodeFeeConfig; exports.decodeMidpriceOracle = decodeMidpriceOracle; exports.derivePoolAddresses = derivePoolAddresses; exports.fromQ32 = fromQ32; exports.getConfigAddress = getConfigAddress; exports.getCurveMetaAddress = getCurveMetaAddress; exports.getCurvePrefabsAddress = getCurvePrefabsAddress; exports.getCurveUpdatesAddress = getCurveUpdatesAddress; exports.getFeeConfigAddress = getFeeConfigAddress; exports.getMidpriceOracleAddress = getMidpriceOracleAddress; exports.getOrCreateAta = getOrCreateAta; exports.getSpreadConfigAddress = getSpreadConfigAddress; exports.isSlotInitialized = isSlotInitialized; exports.pctToQ32 = pctToQ32; exports.toQ32 = toQ32;
+
+
+exports.ABSOLUTE_MAX_CURVE_POINTS = ABSOLUTE_MAX_CURVE_POINTS; exports.ABSOLUTE_MAX_PREFAB_SLOTS = ABSOLUTE_MAX_PREFAB_SLOTS; exports.CONFIG_SEED = CONFIG_SEED; exports.CONFIG_SIZE = CONFIG_SIZE; exports.CURVE_META_SEED = CURVE_META_SEED; exports.CURVE_META_SIZE = CURVE_META_SIZE; exports.CURVE_POINT_LEN = CURVE_POINT_LEN; exports.CURVE_PREFABS_SEED = CURVE_PREFABS_SEED; exports.CURVE_SIDE_HEADER = CURVE_SIDE_HEADER; exports.CURVE_UPDATES_SEED = CURVE_UPDATES_SEED; exports.CURVE_UPDATES_SIZE = CURVE_UPDATES_SIZE; exports.CURVE_UPDATE_OP_SIZE = CURVE_UPDATE_OP_SIZE; exports.CurveType = CurveType; exports.CurveUpdateOpKind = CurveUpdateOpKind; exports.CurveXMode = CurveXMode; exports.DEFAULT_MAX_CURVE_POINTS = DEFAULT_MAX_CURVE_POINTS; exports.DEFAULT_MAX_PREFAB_SLOTS = DEFAULT_MAX_PREFAB_SLOTS; exports.Discriminator = Discriminator; exports.FEE_CONFIG_SEED = FEE_CONFIG_SEED; exports.FEE_CONFIG_SIZE = FEE_CONFIG_SIZE; exports.HADRON_PROGRAM_ID = HADRON_PROGRAM_ID; exports.Hadron = Hadron; exports.HadronOrderbook = HadronOrderbook; exports.Interpolation = Interpolation; exports.MAX_CURVE_UPDATE_OPS = MAX_CURVE_UPDATE_OPS; exports.MAX_SETCURVE_POINTS = MAX_SETCURVE_POINTS; exports.MIDPRICE_ORACLE_SEED = MIDPRICE_ORACLE_SEED; exports.MIDPRICE_ORACLE_SIZE = MIDPRICE_ORACLE_SIZE; exports.OracleMode = OracleMode; exports.POINT_DATA_SIZE = POINT_DATA_SIZE; exports.PoolState = PoolState; exports.Q32_ONE = Q32_ONE; exports.RiskMode = RiskMode; exports.SPREAD_CONFIG_SEED = SPREAD_CONFIG_SEED; exports.Side = Side; exports.buildAcceptAuthority = buildAcceptAuthority; exports.buildAllocateCurvePrefabs = buildAllocateCurvePrefabs; exports.buildApplyCurveUpdates = buildApplyCurveUpdates; exports.buildClosePool = buildClosePool; exports.buildDeposit = buildDeposit; exports.buildInitialize = buildInitialize; exports.buildInitializeFeeConfig = buildInitializeFeeConfig; exports.buildInitializeSpreadConfig = buildInitializeSpreadConfig; exports.buildNominateAuthority = buildNominateAuthority; exports.buildRotateFeeAdmin = buildRotateFeeAdmin; exports.buildSetCurve = buildSetCurve; exports.buildSetCurveBoth = buildSetCurveBoth; exports.buildSetPoolState = buildSetPoolState; exports.buildSetQuotingAuthority = buildSetQuotingAuthority; exports.buildSetRiskCurve = buildSetRiskCurve; exports.buildSetRiskCurveAbsolute = buildSetRiskCurveAbsolute; exports.buildSetRiskCurveAbsoluteBoth = buildSetRiskCurveAbsoluteBoth; exports.buildSetRiskCurveBoth = buildSetRiskCurveBoth; exports.buildSubmitCurveUpdates = buildSubmitCurveUpdates; exports.buildSwapExactIn = buildSwapExactIn; exports.buildSwitchPriceCurve = buildSwitchPriceCurve; exports.buildSwitchRiskCurve = buildSwitchRiskCurve; exports.buildUpdateBaseSpread = buildUpdateBaseSpread; exports.buildUpdateDeltaStaleness = buildUpdateDeltaStaleness; exports.buildUpdateFeeConfig = buildUpdateFeeConfig; exports.buildUpdateMidprice = buildUpdateMidprice; exports.buildUpdateMidpriceAndBaseSpread = buildUpdateMidpriceAndBaseSpread; exports.buildUpdateSpreadConfig = buildUpdateSpreadConfig; exports.buildWithdraw = buildWithdraw; exports.curvePrefabsSize = curvePrefabsSize; exports.decodeActiveCurves = decodeActiveCurves; exports.decodeConfig = decodeConfig; exports.decodeCurveMeta = decodeCurveMeta; exports.decodeCurveSide = decodeCurveSide; exports.decodeCurveUpdates = decodeCurveUpdates; exports.decodeFeeConfig = decodeFeeConfig; exports.decodeMidpriceOracle = decodeMidpriceOracle; exports.decodeSpreadConfig = decodeSpreadConfig; exports.derivePoolAddresses = derivePoolAddresses; exports.fromQ32 = fromQ32; exports.getConfigAddress = getConfigAddress; exports.getCurveMetaAddress = getCurveMetaAddress; exports.getCurvePrefabsAddress = getCurvePrefabsAddress; exports.getCurveUpdatesAddress = getCurveUpdatesAddress; exports.getFeeConfigAddress = getFeeConfigAddress; exports.getMidpriceOracleAddress = getMidpriceOracleAddress; exports.getOrCreateAta = getOrCreateAta; exports.getSpreadConfigAddress = getSpreadConfigAddress; exports.isSlotInitialized = isSlotInitialized; exports.pctToQ32 = pctToQ32; exports.toQ32 = toQ32;
 //# sourceMappingURL=index.js.map