@whetstone-research/doppler-sdk 0.0.24 → 1.0.1

package/dist/chunk-LIXSTCMM.js

@@ -0,0 +1,974 @@
+import { MAX_SENTINEL_ALLOWLIST, MAX_ORACLE_OBSERVATIONS, ACCOUNT_DISCRIMINATORS, PROGRAM_ID, Q64_ONE, BPS_DENOM, TOKEN_PROGRAM_ID, INSTRUCTION_DISCRIMINATORS, ACCOUNT_ROLE_WRITABLE, ACCOUNT_ROLE_SIGNER, ACCOUNT_ROLE_READONLY, getPoolAddress, sortMints, getPositionAddress, getOracleAddress } from './chunk-T46KDO65.js';
+import { getAddressCodec, getBooleanCodec, getU8Codec, getU16Codec, getU32Codec, getU64Codec, getU128Codec, transformCodec, getArrayCodec, fixCodecSize, getBytesCodec, getStructCodec, getHiddenPrefixDecoder, getConstantDecoder, getOptionCodec, unwrapOption, mergeBytes } from '@solana/kit';
+
+var addressCodec = getAddressCodec();
+var boolCodec = getBooleanCodec();
+var u8Codec = getU8Codec();
+var u16Codec = getU16Codec();
+var u32Codec = getU32Codec();
+var u64Codec = getU64Codec();
+var u128Codec = getU128Codec();
+var u256Codec = transformCodec(
+  getArrayCodec(u64Codec, { size: 4 }),
+  (value) => {
+    if (value < 0n) {
+      throw new Error("u256 cannot be negative");
+    }
+    if (value >> 256n !== 0n) {
+      throw new Error("u256 overflow");
+    }
+    const mask = (1n << 64n) - 1n;
+    return [
+      value & mask,
+      value >> 64n & mask,
+      value >> 128n & mask,
+      value >> 192n & mask
+    ];
+  },
+  (value) => {
+    let out = 0n;
+    for (let i = 0; i < 4; i += 1) {
+      out |= value[i] << 64n * BigInt(i);
+    }
+    return out;
+  }
+);
+var reservedBytesCodec = transformCodec(
+  fixCodecSize(getBytesCodec(), 7),
+  (value) => value,
+  (value) => new Uint8Array(value)
+);
+var observationCodec = getStructCodec([
+  ["timestamp", u32Codec],
+  ["price0Cumulative", u256Codec],
+  ["price1Cumulative", u256Codec]
+]);
+var ammConfigDataCodec = getStructCodec([
+  ["admin", addressCodec],
+  ["paused", boolCodec],
+  ["numeraireMint", addressCodec],
+  ["sentinelAllowlistLen", u8Codec],
+  [
+    "sentinelAllowlist",
+    getArrayCodec(addressCodec, { size: MAX_SENTINEL_ALLOWLIST })
+  ],
+  ["maxSwapFeeBps", u16Codec],
+  ["maxFeeSplitBps", u16Codec],
+  ["maxRouteHops", u8Codec],
+  ["protocolFeeEnabled", boolCodec],
+  ["protocolFeeBps", u16Codec],
+  ["version", u8Codec],
+  ["reserved", reservedBytesCodec]
+]);
+var poolDataCodec = getStructCodec([
+  ["config", addressCodec],
+  ["token0Mint", addressCodec],
+  ["token1Mint", addressCodec],
+  ["vault0", addressCodec],
+  ["vault1", addressCodec],
+  ["authority", addressCodec],
+  ["bump", u8Codec],
+  ["reserve0", u64Codec],
+  ["reserve1", u64Codec],
+  ["totalShares", u128Codec],
+  ["swapFeeBps", u16Codec],
+  ["feeSplitBps", u16Codec],
+  ["feeGrowthGlobal0Q64", u128Codec],
+  ["feeGrowthGlobal1Q64", u128Codec],
+  ["feesUnclaimed0", u64Codec],
+  ["feesUnclaimed1", u64Codec],
+  ["sentinelProgram", addressCodec],
+  ["sentinelFlags", u32Codec],
+  ["numeraireMint", addressCodec],
+  ["liquidityMeasureSide", u8Codec],
+  ["routeNextPool", addressCodec],
+  ["routeBridgeMint", addressCodec],
+  ["kLast", u128Codec],
+  ["protocolPosition", addressCodec],
+  ["locked", u8Codec],
+  ["version", u8Codec],
+  ["reserved", reservedBytesCodec]
+]);
+var positionDataCodec = getStructCodec([
+  ["pool", addressCodec],
+  ["owner", addressCodec],
+  ["positionId", u64Codec],
+  ["shares", u128Codec],
+  ["feeGrowthLast0Q64", u128Codec],
+  ["feeGrowthLast1Q64", u128Codec],
+  ["feeOwed0", u64Codec],
+  ["feeOwed1", u64Codec],
+  ["version", u8Codec],
+  ["reserved", reservedBytesCodec]
+]);
+var oracleStateDataCodec = getStructCodec([
+  ["pool", addressCodec],
+  ["initialized", boolCodec],
+  ["maxPriceChangeRatioQ64", u128Codec],
+  ["lastSlot", u64Codec],
+  ["truncPrice0Q64", u128Codec],
+  ["truncPrice1Q64", u128Codec],
+  ["deviation0Q64", u128Codec],
+  ["deviation1Q64", u128Codec],
+  ["price0Cumulative", u256Codec],
+  ["price1Cumulative", u256Codec],
+  ["lastTimestamp", u32Codec],
+  ["lastObservationTimestamp", u32Codec],
+  ["observationIntervalSec", u32Codec],
+  ["observationIndex", u16Codec],
+  [
+    "observations",
+    getArrayCodec(observationCodec, { size: MAX_ORACLE_OBSERVATIONS })
+  ],
+  ["version", u8Codec],
+  ["reserved", reservedBytesCodec]
+]);
+var ammConfigDecoder = getHiddenPrefixDecoder(ammConfigDataCodec, [
+  getConstantDecoder(ACCOUNT_DISCRIMINATORS.AmmConfig)
+]);
+var poolDecoder = getHiddenPrefixDecoder(poolDataCodec, [
+  getConstantDecoder(ACCOUNT_DISCRIMINATORS.Pool)
+]);
+var positionDecoder = getHiddenPrefixDecoder(positionDataCodec, [
+  getConstantDecoder(ACCOUNT_DISCRIMINATORS.Position)
+]);
+var oracleStateDecoder = getHiddenPrefixDecoder(oracleStateDataCodec, [
+  getConstantDecoder(ACCOUNT_DISCRIMINATORS.OracleState)
+]);
+function decodeAmmConfig(data) {
+  return ammConfigDecoder.decode(data);
+}
+function decodePool(data) {
+  return poolDecoder.decode(data);
+}
+function decodePosition(data) {
+  return positionDecoder.decode(data);
+}
+function decodeOracleState(data) {
+  return oracleStateDecoder.decode(data);
+}
+function encodeInstructionData(discriminator, codec, args) {
+  const encodedArgs = (() => {
+    if (!codec) {
+      return new Uint8Array();
+    }
+    if (args === void 0) {
+      throw new Error("Instruction args are required for codec encoders");
+    }
+    return new Uint8Array(codec.encode(args));
+  })();
+  return mergeBytes([discriminator, encodedArgs]);
+}
+var optionAddressCodec = transformCodec(
+  getOptionCodec(addressCodec, { prefix: u8Codec }),
+  (value) => value,
+  (value) => unwrapOption(value)
+);
+var swapExactInArgsCodec = getStructCodec([
+  ["amountIn", u64Codec],
+  ["minAmountOut", u64Codec],
+  ["direction", u8Codec],
+  ["updateOracle", boolCodec]
+]);
+var addLiquidityArgsWithOracleCodec = getStructCodec([
+  ["amount0Max", u64Codec],
+  ["amount1Max", u64Codec],
+  ["minSharesOut", u128Codec],
+  ["updateOracle", boolCodec]
+]);
+transformCodec(
+  addLiquidityArgsWithOracleCodec,
+  (value) => ({
+    ...value,
+    updateOracle: value.updateOracle ?? false
+  }),
+  (value) => value
+);
+var removeLiquidityArgsCodec = getStructCodec([
+  ["sharesIn", u128Codec],
+  ["minAmount0Out", u64Codec],
+  ["minAmount1Out", u64Codec],
+  ["updateOracle", boolCodec]
+]);
+var collectFeesArgsCodec = getStructCodec([
+  ["max0", u64Codec],
+  ["max1", u64Codec]
+]);
+var collectProtocolFeesArgsCodec = getStructCodec([
+  ["max0", u64Codec],
+  ["max1", u64Codec]
+]);
+var createPositionArgsCodec = getStructCodec([["positionId", u64Codec]]);
+var initializeConfigArgsCodec = getStructCodec([
+  ["admin", addressCodec],
+  ["numeraireMint", addressCodec],
+  ["maxSwapFeeBps", u16Codec],
+  ["maxFeeSplitBps", u16Codec],
+  ["maxRouteHops", u8Codec],
+  ["protocolFeeEnabled", boolCodec],
+  ["protocolFeeBps", u16Codec],
+  ["sentinelAllowlist", getArrayCodec(addressCodec, { size: u32Codec })]
+]);
+var initializePoolArgsCodec = getStructCodec([
+  ["mintA", addressCodec],
+  ["mintB", addressCodec],
+  ["initialSwapFeeBps", u16Codec],
+  ["initialFeeSplitBps", u16Codec],
+  ["liquidityMeasureSide", u8Codec],
+  ["numeraireMintOverride", optionAddressCodec]
+]);
+var initializeOracleArgsCodec = getStructCodec([
+  ["maxPriceChangeRatioQ64", u128Codec],
+  ["observationIntervalSec", u32Codec],
+  ["numObservations", u16Codec]
+]);
+var setSentinelArgsCodec = getStructCodec([
+  ["sentinelProgram", addressCodec],
+  ["sentinelFlags", u32Codec]
+]);
+var setFeesArgsCodec = getStructCodec([
+  ["swapFeeBps", u16Codec],
+  ["feeSplitBps", u16Codec]
+]);
+var setRouteArgsCodec = getStructCodec([
+  ["routeNextPool", addressCodec],
+  ["routeBridgeMint", addressCodec]
+]);
+var transferAdminArgsCodec = getStructCodec([
+  ["newAdmin", addressCodec]
+]);
+var oracleConsultArgsCodec = getStructCodec([
+  ["windowSeconds", u32Codec]
+]);
+var quoteToNumeraireArgsCodec = getStructCodec([
+  ["amount", u128Codec],
+  ["side", u8Codec],
+  ["maxHops", u8Codec],
+  ["useTwap", boolCodec],
+  ["windowSeconds", u32Codec]
+]);
+
+// src/solana/core/math.ts
+function q64ToNumber(q64) {
+  const intPart = q64 >> 64n;
+  const fracPart = q64 & (1n << 64n) - 1n;
+  return Number(intPart) + Number(fracPart) / Number(Q64_ONE);
+}
+function numberToQ64(n) {
+  const intPart = Math.floor(n);
+  const fracPart = n - intPart;
+  return (BigInt(intPart) << 64n) + BigInt(Math.round(fracPart * Number(Q64_ONE)));
+}
+function q64Mul(a, b) {
+  return a * b >> 64n;
+}
+function q64Div(a, b) {
+  return (a << 64n) / b;
+}
+function computePrice0Q64(reserve0, reserve1) {
+  if (reserve0 === 0n) return 0n;
+  return (reserve1 << 64n) / reserve0;
+}
+function computePrice1Q64(reserve0, reserve1) {
+  if (reserve1 === 0n) return 0n;
+  return (reserve0 << 64n) / reserve1;
+}
+function isqrt(n) {
+  if (n < 0n) throw new Error("isqrt: negative input");
+  if (n === 0n) return 0n;
+  let x = n;
+  let y = (x + 1n) / 2n;
+  while (y < x) {
+    x = y;
+    y = (x + n / x) / 2n;
+  }
+  return x;
+}
+function ceilDiv(a, b) {
+  return (a + b - 1n) / b;
+}
+function minBigInt(a, b) {
+  return a < b ? a : b;
+}
+function maxBigInt(a, b) {
+  return a > b ? a : b;
+}
+function ratioToNumber(numerator, denominator) {
+  if (denominator === 0n) return 0;
+  const q64 = (numerator << 64n) / denominator;
+  return q64ToNumber(q64);
+}
+function getSwapQuote(pool, amountIn, direction) {
+  if (amountIn === 0n) {
+    return {
+      amountOut: 0n,
+      feeTotal: 0n,
+      feeDist: 0n,
+      feeComp: 0n,
+      priceImpact: 0,
+      executionPrice: 0
+    };
+  }
+  const [reserveIn, reserveOut] = direction === 0 ? [pool.reserve0, pool.reserve1] : [pool.reserve1, pool.reserve0];
+  if (reserveIn === 0n || reserveOut === 0n) {
+    throw new Error("Pool has zero liquidity");
+  }
+  const feeTotal = amountIn * BigInt(pool.swapFeeBps) / BPS_DENOM;
+  const feeDist = feeTotal * BigInt(pool.feeSplitBps) / BPS_DENOM;
+  const feeComp = feeTotal - feeDist;
+  const amountInEff = amountIn - feeTotal;
+  const amountOut = amountInEff * reserveOut / (reserveIn + amountInEff);
+  const spotPrice = ratioToNumber(reserveOut, reserveIn);
+  const executionPrice = ratioToNumber(amountOut, amountIn);
+  const priceImpact = spotPrice === 0 ? 0 : Math.abs(spotPrice - executionPrice) / spotPrice;
+  return {
+    amountOut,
+    feeTotal,
+    feeDist,
+    feeComp,
+    priceImpact,
+    executionPrice
+  };
+}
+function getSwapQuoteExactOut(pool, amountOut, direction) {
+  const [reserveIn, reserveOut] = direction === 0 ? [pool.reserve0, pool.reserve1] : [pool.reserve1, pool.reserve0];
+  if (reserveIn === 0n || reserveOut === 0n) {
+    throw new Error("Pool has zero liquidity");
+  }
+  if (amountOut >= reserveOut) {
+    throw new Error("Insufficient liquidity for output amount");
+  }
+  const amountInEff = ceilDiv(amountOut * reserveIn, reserveOut - amountOut);
+  const amountIn = ceilDiv(
+    amountInEff * BPS_DENOM,
+    BPS_DENOM - BigInt(pool.swapFeeBps)
+  );
+  const feeTotal = amountIn - amountInEff;
+  return { amountIn, feeTotal };
+}
+function getAddLiquidityQuote(pool, amount0Max, amount1Max) {
+  if (pool.totalShares === 0n) {
+    const rawShares = isqrt(amount0Max * amount1Max);
+    if (rawShares === 0n) {
+      throw new Error("Initial liquidity too small");
+    }
+    const sharesOut2 = rawShares;
+    return {
+      sharesOut: sharesOut2,
+      amount0: amount0Max,
+      amount1: amount1Max,
+      poolShare: ratioToNumber(sharesOut2, rawShares)
+    };
+  }
+  if (pool.reserve0 === 0n || pool.reserve1 === 0n) {
+    throw new Error("Invalid pool state: zero reserves with non-zero shares");
+  }
+  const shares0 = amount0Max * pool.totalShares / pool.reserve0;
+  const shares1 = amount1Max * pool.totalShares / pool.reserve1;
+  const sharesOut = minBigInt(shares0, shares1);
+  const amount0 = ceilDiv(sharesOut * pool.reserve0, pool.totalShares);
+  const amount1 = ceilDiv(sharesOut * pool.reserve1, pool.totalShares);
+  const newTotalShares = pool.totalShares + sharesOut;
+  const poolShare = ratioToNumber(sharesOut, newTotalShares);
+  return {
+    sharesOut,
+    amount0,
+    amount1,
+    poolShare
+  };
+}
+function getRemoveLiquidityQuote(pool, sharesIn) {
+  if (pool.totalShares === 0n) {
+    throw new Error("Pool has no shares");
+  }
+  if (sharesIn > pool.totalShares) {
+    throw new Error("Shares exceed total supply");
+  }
+  const amount0 = sharesIn * pool.reserve0 / pool.totalShares;
+  const amount1 = sharesIn * pool.reserve1 / pool.totalShares;
+  return { amount0, amount1 };
+}
+function calculateAccruedFees(shares, feeGrowthLastQ64, feeGrowthGlobalQ64) {
+  const delta = feeGrowthGlobalQ64 - feeGrowthLastQ64;
+  return shares * delta >> 64n;
+}
+function getPendingFees(pool, position) {
+  const accrued0 = calculateAccruedFees(
+    position.shares,
+    position.feeGrowthLast0Q64,
+    pool.feeGrowthGlobal0Q64
+  );
+  const accrued1 = calculateAccruedFees(
+    position.shares,
+    position.feeGrowthLast1Q64,
+    pool.feeGrowthGlobal1Q64
+  );
+  return {
+    pending0: position.feeOwed0 + accrued0,
+    pending1: position.feeOwed1 + accrued1
+  };
+}
+function getSpotPrice0(pool) {
+  if (pool.reserve0 === 0n) return 0;
+  return q64ToNumber(computePrice0Q64(pool.reserve0, pool.reserve1));
+}
+function getSpotPrice1(pool) {
+  if (pool.reserve1 === 0n) return 0;
+  return q64ToNumber(computePrice1Q64(pool.reserve0, pool.reserve1));
+}
+function getK(pool) {
+  return pool.reserve0 * pool.reserve1;
+}
+function getTvl(pool, side = 0) {
+  if (side === 0) {
+    return 2n * pool.reserve0;
+  } else {
+    return 2n * pool.reserve1;
+  }
+}
+function calculateTwap(cumulativeStart, cumulativeEnd, timestampStart, timestampEnd) {
+  const dt = BigInt(timestampEnd - timestampStart);
+  if (dt === 0n) return 0n;
+  const cumulativeDiff = cumulativeEnd >= cumulativeStart ? cumulativeEnd - cumulativeStart : (1n << 256n) - cumulativeStart + cumulativeEnd;
+  return cumulativeDiff / dt;
+}
+function calculateTwapNumber(cumulativeStart, cumulativeEnd, timestampStart, timestampEnd) {
+  const twapQ64 = calculateTwap(
+    cumulativeStart,
+    cumulativeEnd,
+    timestampStart,
+    timestampEnd
+  );
+  return q64ToNumber(twapQ64);
+}
+
+// src/solana/instructions/collectFees.ts
+function createCollectFeesInstruction(accounts, args, programId = PROGRAM_ID) {
+  const {
+    pool,
+    position,
+    owner,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    user0,
+    user1,
+    tokenProgram = TOKEN_PROGRAM_ID
+  } = accounts;
+  const keys = [
+    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
+    { address: position, role: ACCOUNT_ROLE_WRITABLE },
+    { address: owner, role: ACCOUNT_ROLE_SIGNER },
+    { address: authority, role: ACCOUNT_ROLE_READONLY },
+    { address: vault0, role: ACCOUNT_ROLE_WRITABLE },
+    { address: vault1, role: ACCOUNT_ROLE_WRITABLE },
+    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: user0, role: ACCOUNT_ROLE_WRITABLE },
+    { address: user1, role: ACCOUNT_ROLE_WRITABLE },
+    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.collectFees,
+    collectFeesArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+var MAX_FEE_AMOUNT = BigInt("18446744073709551615");
+
+// src/solana/client/pool.ts
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToBytes(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function fetchPool(rpc, address, config) {
+  const response = await rpc.getAccountInfo(address, {
+    encoding: "base64",
+    commitment: config?.commitment
+  }).send();
+  if (!response.value) {
+    return null;
+  }
+  return decodePool(base64ToBytes(response.value.data[0]));
+}
+async function fetchAllPools(rpc, config) {
+  const programId = config?.programId ?? PROGRAM_ID;
+  const discriminatorFilter = {
+    memcmp: {
+      offset: 0n,
+      bytes: bytesToBase64(ACCOUNT_DISCRIMINATORS.Pool),
+      encoding: "base64"
+    }
+  };
+  const response = await rpc.getProgramAccounts(programId, {
+    encoding: "base64",
+    commitment: config?.commitment,
+    filters: [discriminatorFilter]
+  }).send();
+  const accounts = Array.isArray(response) ? response : response.value;
+  const pools = [];
+  for (const account of accounts) {
+    try {
+      const pool = decodePool(base64ToBytes(account.account.data[0]));
+      pools.push({
+        address: account.pubkey,
+        account: pool
+      });
+    } catch {
+      console.warn(`Failed to decode pool account: ${account.pubkey}`);
+    }
+  }
+  return pools;
+}
+async function getPoolByMints(rpc, mint0, mint1, config) {
+  const programId = config?.programId ?? PROGRAM_ID;
+  const [poolAddress] = await getPoolAddress(mint0, mint1, programId);
+  const pool = await fetchPool(rpc, poolAddress, config);
+  if (!pool) {
+    return null;
+  }
+  return {
+    address: poolAddress,
+    account: pool
+  };
+}
+async function fetchPoolsBatch(rpc, addresses, config) {
+  const pools = /* @__PURE__ */ new Map();
+  const results = await Promise.all(
+    addresses.map((addr) => fetchPool(rpc, addr, config))
+  );
+  for (let i = 0; i < addresses.length; i++) {
+    const pool = results[i];
+    if (pool) {
+      pools.set(addresses[i], pool);
+    }
+  }
+  return pools;
+}
+async function poolExists(rpc, mint0, mint1, config) {
+  const result = await getPoolByMints(rpc, mint0, mint1, config);
+  return result !== null;
+}
+async function getPoolAddressFromMints(mint0, mint1, programId = PROGRAM_ID) {
+  const [token0, token1] = sortMints(mint0, mint1);
+  const [poolAddress] = await getPoolAddress(mint0, mint1, programId);
+  return {
+    poolAddress,
+    token0,
+    token1
+  };
+}
+function filterPoolsByMint(pools, mint) {
+  return pools.filter(
+    ({ account }) => account.token0Mint === mint || account.token1Mint === mint
+  );
+}
+function sortPoolsByReserves(pools, descending = true) {
+  return [...pools].sort((a, b) => {
+    const totalA = a.account.reserve0 + a.account.reserve1;
+    const totalB = b.account.reserve0 + b.account.reserve1;
+    const cmp = totalA < totalB ? -1 : totalA > totalB ? 1 : 0;
+    return descending ? -cmp : cmp;
+  });
+}
+
+// src/solana/client/position.ts
+function bytesToBase642(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToBytes2(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function fetchPosition(rpc, address, config) {
+  const response = await rpc.getAccountInfo(address, {
+    encoding: "base64",
+    commitment: config?.commitment
+  }).send();
+  if (!response.value) {
+    return null;
+  }
+  return decodePosition(base64ToBytes2(response.value.data[0]));
+}
+async function fetchUserPositions(rpc, owner, pool, config) {
+  const programId = config?.programId ?? PROGRAM_ID;
+  const filters = [
+    // Discriminator filter (first 8 bytes)
+    {
+      memcmp: {
+        offset: 0n,
+        bytes: bytesToBase642(
+          ACCOUNT_DISCRIMINATORS.Position
+        ),
+        encoding: "base64"
+      }
+    },
+    // Owner filter (after 8-byte discriminator + 32-byte pool = offset 40)
+    {
+      memcmp: {
+        offset: 40n,
+        bytes: owner,
+        encoding: "base58"
+      }
+    }
+  ];
+  if (pool) {
+    filters.push({
+      memcmp: {
+        offset: 8n,
+        bytes: pool,
+        encoding: "base58"
+      }
+    });
+  }
+  const response = await rpc.getProgramAccounts(programId, {
+    encoding: "base64",
+    commitment: config?.commitment,
+    filters
+  }).send();
+  const accounts = Array.isArray(response) ? response : response.value;
+  const positions = [];
+  for (const account of accounts) {
+    try {
+      const position = decodePosition(base64ToBytes2(account.account.data[0]));
+      positions.push({
+        address: account.pubkey,
+        account: position
+      });
+    } catch {
+      console.warn(`Failed to decode position account: ${account.pubkey}`);
+    }
+  }
+  return positions;
+}
+async function fetchPoolPositions(rpc, pool, config) {
+  const programId = config?.programId ?? PROGRAM_ID;
+  const filters = [
+    // Discriminator filter
+    {
+      memcmp: {
+        offset: 0n,
+        bytes: bytesToBase642(
+          ACCOUNT_DISCRIMINATORS.Position
+        ),
+        encoding: "base64"
+      }
+    },
+    // Pool filter (after 8-byte discriminator = offset 8)
+    {
+      memcmp: {
+        offset: 8n,
+        bytes: pool,
+        encoding: "base58"
+      }
+    }
+  ];
+  const response = await rpc.getProgramAccounts(programId, {
+    encoding: "base64",
+    commitment: config?.commitment,
+    filters
+  }).send();
+  const accounts = Array.isArray(response) ? response : response.value;
+  const positions = [];
+  for (const account of accounts) {
+    try {
+      const position = decodePosition(base64ToBytes2(account.account.data[0]));
+      positions.push({
+        address: account.pubkey,
+        account: position
+      });
+    } catch {
+      console.warn(`Failed to decode position account: ${account.pubkey}`);
+    }
+  }
+  return positions;
+}
+function getPositionValue(pool, position) {
+  if (pool.totalShares === 0n) {
+    return {
+      amount0: 0n,
+      amount1: 0n,
+      pendingFees0: 0n,
+      pendingFees1: 0n,
+      totalValue0: 0n,
+      totalValue1: 0n,
+      poolShare: 0
+    };
+  }
+  const amount0 = position.shares * pool.reserve0 / pool.totalShares;
+  const amount1 = position.shares * pool.reserve1 / pool.totalShares;
+  const { pending0, pending1 } = getPendingFees(pool, position);
+  const poolShare = ratioToNumber(position.shares, pool.totalShares);
+  return {
+    amount0,
+    amount1,
+    pendingFees0: pending0,
+    pendingFees1: pending1,
+    totalValue0: amount0 + pending0,
+    totalValue1: amount1 + pending1,
+    poolShare
+  };
+}
+async function fetchPositionByParams(rpc, pool, owner, positionId, config) {
+  const programId = config?.programId ?? PROGRAM_ID;
+  const [address] = await getPositionAddress(
+    pool,
+    owner,
+    positionId,
+    programId
+  );
+  const position = await fetchPosition(rpc, address, config);
+  if (!position) {
+    return null;
+  }
+  return {
+    address,
+    account: position
+  };
+}
+async function getPositionAddressFromParams(pool, owner, positionId, programId = PROGRAM_ID) {
+  const [address] = await getPositionAddress(
+    pool,
+    owner,
+    positionId,
+    programId
+  );
+  return address;
+}
+async function fetchPositionsBatch(rpc, addresses, config) {
+  const positions = /* @__PURE__ */ new Map();
+  const results = await Promise.all(
+    addresses.map((addr) => fetchPosition(rpc, addr, config))
+  );
+  for (let i = 0; i < addresses.length; i++) {
+    const position = results[i];
+    if (position) {
+      positions.set(addresses[i], position);
+    }
+  }
+  return positions;
+}
+function filterActivePositions(positions) {
+  return positions.filter(({ account }) => account.shares > 0n);
+}
+function sortPositionsByShares(positions, descending = true) {
+  return [...positions].sort((a, b) => {
+    const cmp = a.account.shares < b.account.shares ? -1 : a.account.shares > b.account.shares ? 1 : 0;
+    return descending ? -cmp : cmp;
+  });
+}
+
+// src/solana/client/oracle.ts
+function base64ToBytes3(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function fetchOracle(rpc, address, config) {
+  const response = await rpc.getAccountInfo(address, {
+    encoding: "base64",
+    commitment: config?.commitment
+  }).send();
+  if (!response.value) {
+    return null;
+  }
+  return decodeOracleState(base64ToBytes3(response.value.data[0]));
+}
+async function getOracleForPool(rpc, pool, config) {
+  const programId = config?.programId ?? PROGRAM_ID;
+  const [oracleAddress] = await getOracleAddress(pool, programId);
+  const oracle = await fetchOracle(rpc, oracleAddress, config);
+  if (!oracle) {
+    return null;
+  }
+  return {
+    address: oracleAddress,
+    account: oracle
+  };
+}
+async function getOracleAddressFromPool(pool, programId = PROGRAM_ID) {
+  const [address] = await getOracleAddress(pool, programId);
+  return address;
+}
+function consultTwap(oracle, windowSeconds, currentTimestamp) {
+  if (!oracle.initialized || oracle.lastTimestamp === 0) {
+    return null;
+  }
+  const nowTs = Math.max(0, Math.floor(currentTimestamp ?? Date.now() / 1e3));
+  const dtSinceLast = Math.max(0, nowTs - oracle.lastTimestamp);
+  const cum0Now = oracle.price0Cumulative + oracle.truncPrice0Q64 * BigInt(dtSinceLast);
+  const cum1Now = oracle.price1Cumulative + oracle.truncPrice1Q64 * BigInt(dtSinceLast);
+  if (windowSeconds === 0) {
+    return {
+      price0Q64: oracle.truncPrice0Q64,
+      price1Q64: oracle.truncPrice1Q64,
+      price0: q64ToNumber(oracle.truncPrice0Q64),
+      price1: q64ToNumber(oracle.truncPrice1Q64)
+    };
+  }
+  const targetTs = Math.max(0, nowTs - windowSeconds);
+  const sample = selectSample(oracle, targetTs);
+  if (!sample) {
+    return null;
+  }
+  const dt = Math.max(0, nowTs - sample.timestamp);
+  if (dt === 0) {
+    return null;
+  }
+  const price0Q64 = (cum0Now - sample.price0Cumulative) / BigInt(dt);
+  const price1Q64 = (cum1Now - sample.price1Cumulative) / BigInt(dt);
+  return {
+    price0Q64,
+    price1Q64,
+    price0: q64ToNumber(price0Q64),
+    price1: q64ToNumber(price1Q64)
+  };
+}
+function selectSample(oracle, targetTimestamp) {
+  let best = null;
+  const base = {
+    timestamp: oracle.lastTimestamp,
+    price0Cumulative: oracle.price0Cumulative,
+    price1Cumulative: oracle.price1Cumulative
+  };
+  if (base.timestamp !== 0 && base.timestamp <= targetTimestamp) {
+    best = base;
+  }
+  for (const obs of oracle.observations) {
+    if (obs.timestamp === 0) {
+      continue;
+    }
+    if (obs.timestamp <= targetTimestamp) {
+      if (!best || obs.timestamp > best.timestamp) {
+        best = obs;
+      }
+    }
+  }
+  if (best) {
+    return best;
+  }
+  let oldest = base.timestamp !== 0 ? base : null;
+  for (const obs of oracle.observations) {
+    if (obs.timestamp === 0) {
+      continue;
+    }
+    if (!oldest || obs.timestamp < oldest.timestamp) {
+      oldest = obs;
+    }
+  }
+  return oldest;
+}
+function getOracleSpotPrices(oracle) {
+  return {
+    price0Q64: oracle.truncPrice0Q64,
+    price1Q64: oracle.truncPrice1Q64,
+    price0: q64ToNumber(oracle.truncPrice0Q64),
+    price1: q64ToNumber(oracle.truncPrice1Q64)
+  };
+}
+function getOracleDeviation(oracle) {
+  return {
+    deviation0Q64: oracle.deviation0Q64,
+    deviation1Q64: oracle.deviation1Q64,
+    deviation0: q64ToNumber(oracle.deviation0Q64),
+    deviation1: q64ToNumber(oracle.deviation1Q64)
+  };
+}
+function getOracleAge(oracle, currentTimestamp) {
+  const now = currentTimestamp ?? Math.floor(Date.now() / 1e3);
+  return now - oracle.lastTimestamp;
+}
+function isOracleStale(oracle, maxAgeSeconds, currentTimestamp) {
+  return getOracleAge(oracle, currentTimestamp) > maxAgeSeconds;
+}
+function getOracleBufferStats(oracle) {
+  const observations = oracle.observations;
+  const capacity = observations.length;
+  const currentIndex = oracle.observationIndex;
+  let filledCount = 0;
+  let oldestTimestamp = 0;
+  let newestTimestamp = 0;
+  for (let i = 0; i < capacity; i++) {
+    const obs = observations[i];
+    if (obs.timestamp > 0) {
+      filledCount++;
+      if (oldestTimestamp === 0 || obs.timestamp < oldestTimestamp) {
+        oldestTimestamp = obs.timestamp;
+      }
+      if (obs.timestamp > newestTimestamp) {
+        newestTimestamp = obs.timestamp;
+      }
+    }
+  }
+  return {
+    capacity,
+    filledCount,
+    currentIndex,
+    oldestTimestamp,
+    newestTimestamp,
+    timeSpanSeconds: newestTimestamp > oldestTimestamp ? newestTimestamp - oldestTimestamp : 0
+  };
+}
+async function fetchOraclesBatch(rpc, pools, config) {
+  const programId = config?.programId ?? PROGRAM_ID;
+  const oracles = /* @__PURE__ */ new Map();
+  const oracleAddresses = await Promise.all(
+    pools.map((pool) => getOracleAddress(pool, programId))
+  );
+  const results = await Promise.all(
+    oracleAddresses.map(([addr]) => fetchOracle(rpc, addr, config))
+  );
+  for (let i = 0; i < pools.length; i++) {
+    const oracle = results[i];
+    if (oracle) {
+      oracles.set(pools[i], {
+        address: oracleAddresses[i][0],
+        account: oracle
+      });
+    }
+  }
+  return oracles;
+}
+function comparePoolAndOraclePrices(pool, oracle) {
+  const poolPrice0 = pool.reserve0 > 0n ? Number(pool.reserve1) / Number(pool.reserve0) : 0;
+  const oraclePrice0 = q64ToNumber(oracle.truncPrice0Q64);
+  const divergencePct = oraclePrice0 > 0 ? (poolPrice0 - oraclePrice0) / oraclePrice0 * 100 : 0;
+  return {
+    poolPrice0,
+    oraclePrice0,
+    divergencePct
+  };
+}
+
+export { MAX_FEE_AMOUNT, calculateAccruedFees, calculateTwap, calculateTwapNumber, ceilDiv, collectProtocolFeesArgsCodec, comparePoolAndOraclePrices, computePrice0Q64, computePrice1Q64, consultTwap, createCollectFeesInstruction, createPositionArgsCodec, decodeAmmConfig, decodeOracleState, decodePool, decodePosition, encodeInstructionData, fetchAllPools, fetchOracle, fetchOraclesBatch, fetchPool, fetchPoolPositions, fetchPoolsBatch, fetchPosition, fetchPositionByParams, fetchPositionsBatch, fetchUserPositions, filterActivePositions, filterPoolsByMint, getAddLiquidityQuote, getK, getOracleAddressFromPool, getOracleAge, getOracleBufferStats, getOracleDeviation, getOracleForPool, getOracleSpotPrices, getPendingFees, getPoolAddressFromMints, getPoolByMints, getPositionAddressFromParams, getPositionValue, getRemoveLiquidityQuote, getSpotPrice0, getSpotPrice1, getSwapQuote, getSwapQuoteExactOut, getTvl, initializeConfigArgsCodec, initializeOracleArgsCodec, initializePoolArgsCodec, isOracleStale, isqrt, maxBigInt, minBigInt, numberToQ64, oracleConsultArgsCodec, poolExists, q64Div, q64Mul, q64ToNumber, quoteToNumeraireArgsCodec, ratioToNumber, removeLiquidityArgsCodec, setFeesArgsCodec, setRouteArgsCodec, setSentinelArgsCodec, sortPoolsByReserves, sortPositionsByShares, swapExactInArgsCodec, transferAdminArgsCodec };
+//# sourceMappingURL=chunk-LIXSTCMM.js.map
+//# sourceMappingURL=chunk-LIXSTCMM.js.map