@whetstone-research/doppler-sdk 1.0.18 → 1.0.20

package/dist/chunk-KJ6W44WF.cjs

@@ -0,0 +1,4089 @@
+'use strict';
+
+var chunkY6TJIH33_cjs = require('./chunk-Y6TJIH33.cjs');
+var kit = require('@solana/kit');
+var programClientCore = require('@solana/program-client-core');
+
+var addressCodec = kit.getAddressCodec();
+var boolCodec = kit.getBooleanCodec();
+var u8Codec = kit.getU8Codec();
+var u16Codec = kit.getU16Codec();
+var u32Codec = kit.getU32Codec();
+var u64Codec = kit.getU64Codec();
+var u128Codec = kit.getU128Codec();
+var u256Codec = kit.transformCodec(
+  kit.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 = kit.transformCodec(
+  kit.fixCodecSize(kit.getBytesCodec(), 7),
+  (value) => value,
+  (value) => new Uint8Array(value)
+);
+var observationCodec = kit.getStructCodec([
+  ["timestamp", u32Codec],
+  ["price0Cumulative", u256Codec],
+  ["price1Cumulative", u256Codec]
+]);
+var ammConfigDataCodec = kit.getStructCodec([
+  ["admin", addressCodec],
+  ["paused", boolCodec],
+  ["hookAllowlistLen", u8Codec],
+  ["hookAllowlist", kit.getArrayCodec(addressCodec, { size: chunkY6TJIH33_cjs.MAX_HOOK_ALLOWLIST })],
+  ["maxSwapFeeBps", u16Codec],
+  ["maxFeeSplitBps", u16Codec],
+  ["protocolFeeEnabled", boolCodec],
+  ["protocolFeeBps", u16Codec],
+  ["version", u8Codec],
+  ["reserved", reservedBytesCodec]
+]);
+var poolDataCodec = kit.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],
+  ["hookProgram", addressCodec],
+  ["hookFlags", u32Codec],
+  ["liquidityMeasureTokenIndex", u8Codec],
+  ["kLast", u128Codec],
+  ["protocolFeePosition", addressCodec],
+  ["locked", u8Codec],
+  ["version", u8Codec],
+  ["reserved", reservedBytesCodec]
+]);
+var positionDataCodec = kit.getStructCodec([
+  ["pool", addressCodec],
+  ["owner", addressCodec],
+  ["positionId", u64Codec],
+  ["shares", u128Codec],
+  ["feeGrowthLast0Q64", u128Codec],
+  ["feeGrowthLast1Q64", u128Codec],
+  ["feeOwed0", u64Codec],
+  ["feeOwed1", u64Codec],
+  ["version", u8Codec],
+  ["reserved", reservedBytesCodec]
+]);
+var oracleStateDataCodec = kit.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",
+    kit.getArrayCodec(observationCodec, { size: chunkY6TJIH33_cjs.MAX_ORACLE_OBSERVATIONS })
+  ],
+  ["version", u8Codec],
+  ["reserved", reservedBytesCodec]
+]);
+var ammConfigDecoder = kit.getHiddenPrefixDecoder(ammConfigDataCodec, [
+  kit.getConstantDecoder(chunkY6TJIH33_cjs.ACCOUNT_DISCRIMINATORS.AmmConfig)
+]);
+var poolDecoder = kit.getHiddenPrefixDecoder(poolDataCodec, [
+  kit.getConstantDecoder(chunkY6TJIH33_cjs.ACCOUNT_DISCRIMINATORS.Pool)
+]);
+var positionDecoder = kit.getHiddenPrefixDecoder(positionDataCodec, [
+  kit.getConstantDecoder(chunkY6TJIH33_cjs.ACCOUNT_DISCRIMINATORS.Position)
+]);
+var oracleStateDecoder = kit.getHiddenPrefixDecoder(oracleStateDataCodec, [
+  kit.getConstantDecoder(chunkY6TJIH33_cjs.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 kit.mergeBytes([discriminator, encodedArgs]);
+}
+var swapExactInArgsCodec = kit.getStructCodec([
+  ["amountIn", u64Codec],
+  ["minAmountOut", u64Codec],
+  ["tradeDirection", u8Codec],
+  ["updateOracle", boolCodec]
+]);
+var addLiquidityArgsWithOracleCodec = kit.getStructCodec([
+  ["amount0Max", u64Codec],
+  ["amount1Max", u64Codec],
+  ["minSharesOut", u128Codec],
+  ["updateOracle", boolCodec]
+]);
+var addLiquidityArgsCodec = kit.transformCodec(
+  addLiquidityArgsWithOracleCodec,
+  (value) => ({
+    ...value,
+    updateOracle: value.updateOracle ?? false
+  }),
+  (value) => value
+);
+var removeLiquidityArgsCodec = kit.getStructCodec([
+  ["sharesIn", u128Codec],
+  ["minAmount0Out", u64Codec],
+  ["minAmount1Out", u64Codec],
+  ["updateOracle", boolCodec]
+]);
+var collectFeesArgsCodec = kit.getStructCodec([
+  ["max0", u64Codec],
+  ["max1", u64Codec]
+]);
+var collectProtocolFeesArgsCodec = kit.getStructCodec([
+  ["max0", u64Codec],
+  ["max1", u64Codec]
+]);
+var createPositionArgsCodec = kit.getStructCodec([["positionId", u64Codec]]);
+var initializeConfigArgsCodec = kit.getStructCodec([
+  ["admin", addressCodec],
+  ["maxSwapFeeBps", u16Codec],
+  ["maxFeeSplitBps", u16Codec],
+  ["protocolFeeEnabled", boolCodec],
+  ["protocolFeeBps", u16Codec],
+  ["hookAllowlist", kit.getArrayCodec(addressCodec, { size: u32Codec })]
+]);
+var initializePoolArgsCodec = kit.getStructCodec([
+  ["mintA", addressCodec],
+  ["mintB", addressCodec],
+  ["initialSwapFeeBps", u16Codec],
+  ["initialFeeSplitBps", u16Codec],
+  ["liquidityMeasureTokenIndex", u8Codec],
+  ["hookProgram", addressCodec],
+  ["hookFlags", u32Codec]
+]);
+var initializeOracleArgsCodec = kit.getStructCodec([
+  ["maxPriceChangeRatioQ64", u128Codec],
+  ["observationIntervalSec", u32Codec],
+  ["numObservations", u16Codec]
+]);
+var setHookArgsCodec = kit.getStructCodec([
+  ["hookProgram", addressCodec],
+  ["hookFlags", u32Codec]
+]);
+var setFeesArgsCodec = kit.getStructCodec([
+  ["swapFeeBps", u16Codec],
+  ["feeSplitBps", u16Codec]
+]);
+var transferAdminArgsCodec = kit.getStructCodec([
+  ["newAdmin", addressCodec]
+]);
+var oracleConsultArgsCodec = kit.getStructCodec([
+  ["windowSeconds", u32Codec]
+]);
+function encodeSwapExactInArgs(args) {
+  return new Uint8Array(swapExactInArgsCodec.encode(args));
+}
+function encodeAddLiquidityArgs(args) {
+  return new Uint8Array(addLiquidityArgsCodec.encode(args));
+}
+function encodeRemoveLiquidityArgs(args) {
+  return new Uint8Array(removeLiquidityArgsCodec.encode(args));
+}
+function encodeCollectFeesArgs(args) {
+  return new Uint8Array(collectFeesArgsCodec.encode(args));
+}
+function encodeCollectProtocolFeesArgs(args) {
+  return new Uint8Array(collectProtocolFeesArgsCodec.encode(args));
+}
+function encodeCreatePositionArgs(args) {
+  return new Uint8Array(createPositionArgsCodec.encode(args));
+}
+function encodeInitializeConfigArgs(args) {
+  return new Uint8Array(initializeConfigArgsCodec.encode(args));
+}
+function encodeInitializePoolArgs(args) {
+  return new Uint8Array(initializePoolArgsCodec.encode(args));
+}
+function encodeInitializeOracleArgs(args) {
+  return new Uint8Array(initializeOracleArgsCodec.encode(args));
+}
+function encodeSetHookArgs(args) {
+  return new Uint8Array(setHookArgsCodec.encode(args));
+}
+function encodeSetFeesArgs(args) {
+  return new Uint8Array(setFeesArgsCodec.encode(args));
+}
+function encodeTransferAdminArgs(args) {
+  return new Uint8Array(transferAdminArgsCodec.encode(args));
+}
+function encodeOracleConsultArgs(args) {
+  return new Uint8Array(oracleConsultArgsCodec.encode(args));
+}
+
+// src/solana/core/math.ts
+function q64ToNumber(q64) {
+  const intPart = q64 >> 64n;
+  const fracPart = q64 & (1n << 64n) - 1n;
+  return Number(intPart) + Number(fracPart) / Number(chunkY6TJIH33_cjs.Q64_ONE);
+}
+function numberToQ64(n) {
+  const intPart = Math.floor(n);
+  const fracPart = n - intPart;
+  return (BigInt(intPart) << 64n) + BigInt(Math.round(fracPart * Number(chunkY6TJIH33_cjs.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, tradeDirection) {
+  if (amountIn === 0n) {
+    return {
+      amountOut: 0n,
+      feeTotal: 0n,
+      feeDist: 0n,
+      feeComp: 0n,
+      priceImpact: 0,
+      executionPrice: 0
+    };
+  }
+  const [reserveIn, reserveOut] = tradeDirection === 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) / chunkY6TJIH33_cjs.BPS_DENOM;
+  const feeDist = feeTotal * BigInt(pool.feeSplitBps) / chunkY6TJIH33_cjs.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, tradeDirection) {
+  const [reserveIn, reserveOut] = tradeDirection === 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 * chunkY6TJIH33_cjs.BPS_DENOM,
+    chunkY6TJIH33_cjs.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);
+}
+var CLOSE_POSITION_DISCRIMINATOR = new Uint8Array([
+  123,
+  134,
+  81,
+  0,
+  49,
+  68,
+  98,
+  98
+]);
+function getClosePositionDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    CLOSE_POSITION_DISCRIMINATOR
+  );
+}
+function getClosePositionInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)]]),
+    (value) => ({ ...value, discriminator: CLOSE_POSITION_DISCRIMINATOR })
+  );
+}
+function getClosePositionInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)]
+  ]);
+}
+function getClosePositionInstructionDataCodec() {
+  return kit.combineCodec(
+    getClosePositionInstructionDataEncoder(),
+    getClosePositionInstructionDataDecoder()
+  );
+}
+function getClosePositionInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    pool: { value: input.pool ?? null, isWritable: false },
+    position: { value: input.position ?? null, isWritable: true },
+    owner: { value: input.owner ?? null, isWritable: false },
+    rentRecipient: { value: input.rentRecipient ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("position", accounts.position),
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("rentRecipient", accounts.rentRecipient)
+    ],
+    data: getClosePositionInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseClosePositionInstruction(instruction) {
+  if (instruction.accounts.length < 4) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 4
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      pool: getNextAccount(),
+      position: getNextAccount(),
+      owner: getNextAccount(),
+      rentRecipient: getNextAccount()
+    },
+    data: getClosePositionInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var COLLECT_FEES_DISCRIMINATOR = new Uint8Array([
+  164,
+  152,
+  207,
+  99,
+  30,
+  186,
+  19,
+  182
+]);
+function getCollectFeesDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    COLLECT_FEES_DISCRIMINATOR
+  );
+}
+function getCollectFeesInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["max0", kit.getU64Encoder()],
+      ["max1", kit.getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: COLLECT_FEES_DISCRIMINATOR })
+  );
+}
+function getCollectFeesInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["max0", kit.getU64Decoder()],
+    ["max1", kit.getU64Decoder()]
+  ]);
+}
+function getCollectFeesInstructionDataCodec() {
+  return kit.combineCodec(
+    getCollectFeesInstructionDataEncoder(),
+    getCollectFeesInstructionDataDecoder()
+  );
+}
+async function getCollectFeesInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    pool: { value: input.pool ?? null, isWritable: true },
+    position: { value: input.position ?? null, isWritable: true },
+    owner: { value: input.owner ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    user0: { value: input.user0 ?? null, isWritable: true },
+    user1: { value: input.user1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.authority.value) {
+    accounts.authority.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([97, 117, 116, 104, 111, 114, 105, 116, 121])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("position", accounts.position),
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("user0", accounts.user0),
+      getAccountMeta("user1", accounts.user1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program)
+    ],
+    data: getCollectFeesInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getCollectFeesInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    pool: { value: input.pool ?? null, isWritable: true },
+    position: { value: input.position ?? null, isWritable: true },
+    owner: { value: input.owner ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    user0: { value: input.user0 ?? null, isWritable: true },
+    user1: { value: input.user1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("position", accounts.position),
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("user0", accounts.user0),
+      getAccountMeta("user1", accounts.user1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program)
+    ],
+    data: getCollectFeesInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseCollectFeesInstruction(instruction) {
+  if (instruction.accounts.length < 12) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 12
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      pool: getNextAccount(),
+      position: getNextAccount(),
+      owner: getNextAccount(),
+      authority: getNextAccount(),
+      vault0: getNextAccount(),
+      vault1: getNextAccount(),
+      token0Mint: getNextAccount(),
+      token1Mint: getNextAccount(),
+      user0: getNextAccount(),
+      user1: getNextAccount(),
+      token0Program: getNextAccount(),
+      token1Program: getNextAccount()
+    },
+    data: getCollectFeesInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var COLLECT_PROTOCOL_FEES_DISCRIMINATOR = new Uint8Array([
+  22,
+  67,
+  23,
+  98,
+  150,
+  178,
+  70,
+  220
+]);
+function getCollectProtocolFeesDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    COLLECT_PROTOCOL_FEES_DISCRIMINATOR
+  );
+}
+function getCollectProtocolFeesInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["max0", kit.getU64Encoder()],
+      ["max1", kit.getU64Encoder()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: COLLECT_PROTOCOL_FEES_DISCRIMINATOR
+    })
+  );
+}
+function getCollectProtocolFeesInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["max0", kit.getU64Decoder()],
+    ["max1", kit.getU64Decoder()]
+  ]);
+}
+function getCollectProtocolFeesInstructionDataCodec() {
+  return kit.combineCodec(
+    getCollectProtocolFeesInstructionDataEncoder(),
+    getCollectProtocolFeesInstructionDataDecoder()
+  );
+}
+async function getCollectProtocolFeesInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    protocolFeePosition: {
+      value: input.protocolFeePosition ?? null,
+      isWritable: true
+    },
+    admin: { value: input.admin ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    recipient0: { value: input.recipient0 ?? null, isWritable: true },
+    recipient1: { value: input.recipient1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.authority.value) {
+    accounts.authority.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([97, 117, 116, 104, 111, 114, 105, 116, 121])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("protocolFeePosition", accounts.protocolFeePosition),
+      getAccountMeta("admin", accounts.admin),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("recipient0", accounts.recipient0),
+      getAccountMeta("recipient1", accounts.recipient1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program)
+    ],
+    data: getCollectProtocolFeesInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getCollectProtocolFeesInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    protocolFeePosition: {
+      value: input.protocolFeePosition ?? null,
+      isWritable: true
+    },
+    admin: { value: input.admin ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    recipient0: { value: input.recipient0 ?? null, isWritable: true },
+    recipient1: { value: input.recipient1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("protocolFeePosition", accounts.protocolFeePosition),
+      getAccountMeta("admin", accounts.admin),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("recipient0", accounts.recipient0),
+      getAccountMeta("recipient1", accounts.recipient1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program)
+    ],
+    data: getCollectProtocolFeesInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseCollectProtocolFeesInstruction(instruction) {
+  if (instruction.accounts.length < 13) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 13
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      pool: getNextAccount(),
+      protocolFeePosition: getNextAccount(),
+      admin: getNextAccount(),
+      authority: getNextAccount(),
+      vault0: getNextAccount(),
+      vault1: getNextAccount(),
+      token0Mint: getNextAccount(),
+      token1Mint: getNextAccount(),
+      recipient0: getNextAccount(),
+      recipient1: getNextAccount(),
+      token0Program: getNextAccount(),
+      token1Program: getNextAccount()
+    },
+    data: getCollectProtocolFeesInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+var CREATE_POSITION_DISCRIMINATOR = new Uint8Array([
+  48,
+  215,
+  197,
+  153,
+  96,
+  203,
+  180,
+  133
+]);
+function getCreatePositionDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    CREATE_POSITION_DISCRIMINATOR
+  );
+}
+function getCreatePositionInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["positionId", kit.getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: CREATE_POSITION_DISCRIMINATOR })
+  );
+}
+function getCreatePositionInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["positionId", kit.getU64Decoder()]
+  ]);
+}
+function getCreatePositionInstructionDataCodec() {
+  return kit.combineCodec(
+    getCreatePositionInstructionDataEncoder(),
+    getCreatePositionInstructionDataDecoder()
+  );
+}
+async function getCreatePositionInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    pool: { value: input.pool ?? null, isWritable: false },
+    position: { value: input.position ?? null, isWritable: true },
+    owner: { value: input.owner ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.position.value) {
+    accounts.position.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([112, 111, 115, 105, 116, 105, 111, 110])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "owner",
+            accounts.owner.value
+          )
+        ),
+        kit.getU64Encoder().encode(
+          programClientCore.getNonNullResolvedInstructionInput("positionId", args.positionId)
+        )
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("position", accounts.position),
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getCreatePositionInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getCreatePositionInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    pool: { value: input.pool ?? null, isWritable: false },
+    position: { value: input.position ?? null, isWritable: true },
+    owner: { value: input.owner ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("position", accounts.position),
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getCreatePositionInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseCreatePositionInstruction(instruction) {
+  if (instruction.accounts.length < 5) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 5
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      pool: getNextAccount(),
+      position: getNextAccount(),
+      owner: getNextAccount(),
+      payer: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getCreatePositionInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var INITIALIZE_CONFIG_DISCRIMINATOR = new Uint8Array([
+  208,
+  127,
+  21,
+  1,
+  194,
+  190,
+  196,
+  70
+]);
+function getInitializeConfigDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    INITIALIZE_CONFIG_DISCRIMINATOR
+  );
+}
+function getInitializeConfigInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["admin", kit.getAddressEncoder()],
+      ["maxSwapFeeBps", kit.getU16Encoder()],
+      ["maxFeeSplitBps", kit.getU16Encoder()],
+      ["protocolFeeEnabled", kit.getBooleanEncoder()],
+      ["protocolFeeBps", kit.getU16Encoder()],
+      ["hookAllowlist", kit.getArrayEncoder(kit.getAddressEncoder())]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_CONFIG_DISCRIMINATOR })
+  );
+}
+function getInitializeConfigInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["admin", kit.getAddressDecoder()],
+    ["maxSwapFeeBps", kit.getU16Decoder()],
+    ["maxFeeSplitBps", kit.getU16Decoder()],
+    ["protocolFeeEnabled", kit.getBooleanDecoder()],
+    ["protocolFeeBps", kit.getU16Decoder()],
+    ["hookAllowlist", kit.getArrayDecoder(kit.getAddressDecoder())]
+  ]);
+}
+function getInitializeConfigInstructionDataCodec() {
+  return kit.combineCodec(
+    getInitializeConfigInstructionDataEncoder(),
+    getInitializeConfigInstructionDataDecoder()
+  );
+}
+async function getInitializeConfigInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: true },
+    programData: { value: input.programData ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.config.value) {
+    accounts.config.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([99, 111, 110, 102, 105, 103]))
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("programData", accounts.programData),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getInitializeConfigInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getInitializeConfigInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: true },
+    programData: { value: input.programData ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("programData", accounts.programData),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getInitializeConfigInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseInitializeConfigInstruction(instruction) {
+  if (instruction.accounts.length < 4) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 4
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      programData: getNextAccount(),
+      payer: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getInitializeConfigInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var INITIALIZE_ORACLE_DISCRIMINATOR = new Uint8Array([
+  144,
+  223,
+  131,
+  120,
+  196,
+  253,
+  181,
+  99
+]);
+function getInitializeOracleDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    INITIALIZE_ORACLE_DISCRIMINATOR
+  );
+}
+function getInitializeOracleInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["maxPriceChangeRatioQ64", kit.getU128Encoder()],
+      ["observationIntervalSec", kit.getU32Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_ORACLE_DISCRIMINATOR })
+  );
+}
+function getInitializeOracleInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["maxPriceChangeRatioQ64", kit.getU128Decoder()],
+    ["observationIntervalSec", kit.getU32Decoder()]
+  ]);
+}
+function getInitializeOracleInstructionDataCodec() {
+  return kit.combineCodec(
+    getInitializeOracleInstructionDataEncoder(),
+    getInitializeOracleInstructionDataDecoder()
+  );
+}
+async function getInitializeOracleInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: true },
+    admin: { value: input.admin ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.oracle.value) {
+    accounts.oracle.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([111, 114, 97, 99, 108, 101])),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("oracle", accounts.oracle),
+      getAccountMeta("admin", accounts.admin),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getInitializeOracleInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getInitializeOracleInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: true },
+    admin: { value: input.admin ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("oracle", accounts.oracle),
+      getAccountMeta("admin", accounts.admin),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getInitializeOracleInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseInitializeOracleInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 6
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      pool: getNextAccount(),
+      oracle: getNextAccount(),
+      admin: getNextAccount(),
+      payer: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getInitializeOracleInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var INITIALIZE_POOL_DISCRIMINATOR = new Uint8Array([
+  95,
+  180,
+  10,
+  172,
+  84,
+  174,
+  232,
+  40
+]);
+function getInitializePoolDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    INITIALIZE_POOL_DISCRIMINATOR
+  );
+}
+function getInitializePoolInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["mintA", kit.getAddressEncoder()],
+      ["mintB", kit.getAddressEncoder()],
+      ["initialSwapFeeBps", kit.getU16Encoder()],
+      ["initialFeeSplitBps", kit.getU16Encoder()],
+      ["liquidityMeasureTokenIndex", kit.getU8Encoder()],
+      ["hookProgram", kit.getAddressEncoder()],
+      ["hookFlags", kit.getU32Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_POOL_DISCRIMINATOR })
+  );
+}
+function getInitializePoolInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["mintA", kit.getAddressDecoder()],
+    ["mintB", kit.getAddressDecoder()],
+    ["initialSwapFeeBps", kit.getU16Decoder()],
+    ["initialFeeSplitBps", kit.getU16Decoder()],
+    ["liquidityMeasureTokenIndex", kit.getU8Decoder()],
+    ["hookProgram", kit.getAddressDecoder()],
+    ["hookFlags", kit.getU32Decoder()]
+  ]);
+}
+function getInitializePoolInstructionDataCodec() {
+  return kit.combineCodec(
+    getInitializePoolInstructionDataEncoder(),
+    getInitializePoolInstructionDataDecoder()
+  );
+}
+async function getInitializePoolInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    protocolFeePosition: {
+      value: input.protocolFeePosition ?? null,
+      isWritable: true
+    },
+    protocolFeeOwner: {
+      value: input.protocolFeeOwner ?? null,
+      isWritable: false
+    },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    rent: { value: input.rent ?? null, isWritable: false },
+    migrationAuthority: {
+      value: input.migrationAuthority ?? null,
+      isWritable: false
+    }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.pool.value) {
+    accounts.pool.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([112, 111, 111, 108])),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "token0Mint",
+            accounts.token0Mint.value
+          )
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "token1Mint",
+            accounts.token1Mint.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.protocolFeeOwner.value) {
+    accounts.protocolFeeOwner.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([
+            112,
+            114,
+            111,
+            116,
+            111,
+            99,
+            111,
+            108,
+            95,
+            102,
+            101,
+            101,
+            95,
+            111,
+            119,
+            110,
+            101,
+            114
+          ])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  if (!accounts.protocolFeePosition.value) {
+    accounts.protocolFeePosition.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([112, 111, 115, 105, 116, 105, 111, 110])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "protocolFeeOwner",
+            accounts.protocolFeeOwner.value
+          )
+        ),
+        kit.getBytesEncoder().encode(new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]))
+      ]
+    });
+  }
+  if (!accounts.authority.value) {
+    accounts.authority.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([97, 117, 116, 104, 111, 114, 105, 116, 121])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  if (!accounts.vault0.value) {
+    accounts.vault0.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([118, 97, 117, 108, 116, 48])),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  if (!accounts.vault1.value) {
+    accounts.vault1.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([118, 97, 117, 108, 116, 49])),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.rent.value) {
+    accounts.rent.value = "SysvarRent111111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("protocolFeePosition", accounts.protocolFeePosition),
+      getAccountMeta("protocolFeeOwner", accounts.protocolFeeOwner),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("rent", accounts.rent),
+      getAccountMeta("migrationAuthority", accounts.migrationAuthority)
+    ],
+    data: getInitializePoolInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getInitializePoolInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    protocolFeePosition: {
+      value: input.protocolFeePosition ?? null,
+      isWritable: true
+    },
+    protocolFeeOwner: {
+      value: input.protocolFeeOwner ?? null,
+      isWritable: false
+    },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    rent: { value: input.rent ?? null, isWritable: false },
+    migrationAuthority: {
+      value: input.migrationAuthority ?? null,
+      isWritable: false
+    }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.rent.value) {
+    accounts.rent.value = "SysvarRent111111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("protocolFeePosition", accounts.protocolFeePosition),
+      getAccountMeta("protocolFeeOwner", accounts.protocolFeeOwner),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("rent", accounts.rent),
+      getAccountMeta("migrationAuthority", accounts.migrationAuthority)
+    ],
+    data: getInitializePoolInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseInitializePoolInstruction(instruction) {
+  if (instruction.accounts.length < 15) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 15
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      pool: getNextAccount(),
+      protocolFeePosition: getNextAccount(),
+      protocolFeeOwner: getNextAccount(),
+      authority: getNextAccount(),
+      vault0: getNextAccount(),
+      vault1: getNextAccount(),
+      token0Mint: getNextAccount(),
+      token1Mint: getNextAccount(),
+      payer: getNextAccount(),
+      token0Program: getNextAccount(),
+      token1Program: getNextAccount(),
+      systemProgram: getNextAccount(),
+      rent: getNextAccount(),
+      migrationAuthority: getNextAccount()
+    },
+    data: getInitializePoolInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var ORACLE_CONSULT_DISCRIMINATOR = new Uint8Array([
+  239,
+  237,
+  255,
+  177,
+  142,
+  72,
+  96,
+  175
+]);
+function getOracleConsultDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    ORACLE_CONSULT_DISCRIMINATOR
+  );
+}
+function getOracleConsultInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["windowSeconds", kit.getU32Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: ORACLE_CONSULT_DISCRIMINATOR })
+  );
+}
+function getOracleConsultInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["windowSeconds", kit.getU32Decoder()]
+  ]);
+}
+function getOracleConsultInstructionDataCodec() {
+  return kit.combineCodec(
+    getOracleConsultInstructionDataEncoder(),
+    getOracleConsultInstructionDataDecoder()
+  );
+}
+async function getOracleConsultInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    pool: { value: input.pool ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.oracle.value) {
+    accounts.oracle.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([111, 114, 97, 99, 108, 101])),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("oracle", accounts.oracle)
+    ],
+    data: getOracleConsultInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getOracleConsultInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    pool: { value: input.pool ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("oracle", accounts.oracle)
+    ],
+    data: getOracleConsultInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseOracleConsultInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { pool: getNextAccount(), oracle: getNextAccount() },
+    data: getOracleConsultInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var ORACLE_UPDATE_DISCRIMINATOR = new Uint8Array([
+  85,
+  209,
+  248,
+  142,
+  186,
+  249,
+  120,
+  239
+]);
+function getOracleUpdateDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    ORACLE_UPDATE_DISCRIMINATOR
+  );
+}
+function getOracleUpdateInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)]]),
+    (value) => ({ ...value, discriminator: ORACLE_UPDATE_DISCRIMINATOR })
+  );
+}
+function getOracleUpdateInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)]
+  ]);
+}
+function getOracleUpdateInstructionDataCodec() {
+  return kit.combineCodec(
+    getOracleUpdateInstructionDataEncoder(),
+    getOracleUpdateInstructionDataDecoder()
+  );
+}
+async function getOracleUpdateInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    pool: { value: input.pool ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.oracle.value) {
+    accounts.oracle.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([111, 114, 97, 99, 108, 101])),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("oracle", accounts.oracle)
+    ],
+    data: getOracleUpdateInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function getOracleUpdateInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    pool: { value: input.pool ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("oracle", accounts.oracle)
+    ],
+    data: getOracleUpdateInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseOracleUpdateInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { pool: getNextAccount(), oracle: getNextAccount() },
+    data: getOracleUpdateInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var PAUSE_DISCRIMINATOR = new Uint8Array([
+  211,
+  22,
+  221,
+  251,
+  74,
+  121,
+  193,
+  47
+]);
+function getPauseDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(PAUSE_DISCRIMINATOR);
+}
+function getPauseInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)]]),
+    (value) => ({ ...value, discriminator: PAUSE_DISCRIMINATOR })
+  );
+}
+function getPauseInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)]
+  ]);
+}
+function getPauseInstructionDataCodec() {
+  return kit.combineCodec(
+    getPauseInstructionDataEncoder(),
+    getPauseInstructionDataDecoder()
+  );
+}
+function getPauseInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: true },
+    admin: { value: input.admin ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("admin", accounts.admin)
+    ],
+    data: getPauseInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parsePauseInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { config: getNextAccount(), admin: getNextAccount() },
+    data: getPauseInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var PREVIEW_SWAP_EXACT_IN_DISCRIMINATOR = new Uint8Array([
+  50,
+  130,
+  31,
+  69,
+  147,
+  58,
+  222,
+  178
+]);
+function getPreviewSwapExactInDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    PREVIEW_SWAP_EXACT_IN_DISCRIMINATOR
+  );
+}
+function getPreviewSwapExactInInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["amountIn", kit.getU64Encoder()],
+      ["tradeDirection", kit.getU8Encoder()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: PREVIEW_SWAP_EXACT_IN_DISCRIMINATOR
+    })
+  );
+}
+function getPreviewSwapExactInInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["amountIn", kit.getU64Decoder()],
+    ["tradeDirection", kit.getU8Decoder()]
+  ]);
+}
+function getPreviewSwapExactInInstructionDataCodec() {
+  return kit.combineCodec(
+    getPreviewSwapExactInInstructionDataEncoder(),
+    getPreviewSwapExactInInstructionDataDecoder()
+  );
+}
+function getPreviewSwapExactInInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool)
+    ],
+    data: getPreviewSwapExactInInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parsePreviewSwapExactInInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { config: getNextAccount(), pool: getNextAccount() },
+    data: getPreviewSwapExactInInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+var REDEEM_PROTOCOL_SHARES_DISCRIMINATOR = new Uint8Array([
+  143,
+  253,
+  251,
+  77,
+  213,
+  178,
+  0,
+  225
+]);
+function getRedeemProtocolSharesDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    REDEEM_PROTOCOL_SHARES_DISCRIMINATOR
+  );
+}
+function getRedeemProtocolSharesInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["sharesIn", kit.getU128Encoder()],
+      ["minAmount0Out", kit.getU64Encoder()],
+      ["minAmount1Out", kit.getU64Encoder()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: REDEEM_PROTOCOL_SHARES_DISCRIMINATOR
+    })
+  );
+}
+function getRedeemProtocolSharesInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["sharesIn", kit.getU128Decoder()],
+    ["minAmount0Out", kit.getU64Decoder()],
+    ["minAmount1Out", kit.getU64Decoder()]
+  ]);
+}
+function getRedeemProtocolSharesInstructionDataCodec() {
+  return kit.combineCodec(
+    getRedeemProtocolSharesInstructionDataEncoder(),
+    getRedeemProtocolSharesInstructionDataDecoder()
+  );
+}
+async function getRedeemProtocolSharesInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    protocolFeePosition: {
+      value: input.protocolFeePosition ?? null,
+      isWritable: true
+    },
+    admin: { value: input.admin ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    recipient0: { value: input.recipient0 ?? null, isWritable: true },
+    recipient1: { value: input.recipient1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.authority.value) {
+    accounts.authority.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([97, 117, 116, 104, 111, 114, 105, 116, 121])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("protocolFeePosition", accounts.protocolFeePosition),
+      getAccountMeta("admin", accounts.admin),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("recipient0", accounts.recipient0),
+      getAccountMeta("recipient1", accounts.recipient1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program)
+    ],
+    data: getRedeemProtocolSharesInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getRedeemProtocolSharesInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    protocolFeePosition: {
+      value: input.protocolFeePosition ?? null,
+      isWritable: true
+    },
+    admin: { value: input.admin ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    recipient0: { value: input.recipient0 ?? null, isWritable: true },
+    recipient1: { value: input.recipient1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("protocolFeePosition", accounts.protocolFeePosition),
+      getAccountMeta("admin", accounts.admin),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("recipient0", accounts.recipient0),
+      getAccountMeta("recipient1", accounts.recipient1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program)
+    ],
+    data: getRedeemProtocolSharesInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseRedeemProtocolSharesInstruction(instruction) {
+  if (instruction.accounts.length < 13) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 13
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      pool: getNextAccount(),
+      protocolFeePosition: getNextAccount(),
+      admin: getNextAccount(),
+      authority: getNextAccount(),
+      vault0: getNextAccount(),
+      vault1: getNextAccount(),
+      token0Mint: getNextAccount(),
+      token1Mint: getNextAccount(),
+      recipient0: getNextAccount(),
+      recipient1: getNextAccount(),
+      token0Program: getNextAccount(),
+      token1Program: getNextAccount()
+    },
+    data: getRedeemProtocolSharesInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+var REMOVE_LIQUIDITY_DISCRIMINATOR = new Uint8Array([
+  80,
+  85,
+  209,
+  72,
+  24,
+  206,
+  177,
+  108
+]);
+function getRemoveLiquidityDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    REMOVE_LIQUIDITY_DISCRIMINATOR
+  );
+}
+function getRemoveLiquidityInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["sharesIn", kit.getU128Encoder()],
+      ["minAmount0Out", kit.getU64Encoder()],
+      ["minAmount1Out", kit.getU64Encoder()],
+      ["updateOracle", kit.getBooleanEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: REMOVE_LIQUIDITY_DISCRIMINATOR })
+  );
+}
+function getRemoveLiquidityInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["sharesIn", kit.getU128Decoder()],
+    ["minAmount0Out", kit.getU64Decoder()],
+    ["minAmount1Out", kit.getU64Decoder()],
+    ["updateOracle", kit.getBooleanDecoder()]
+  ]);
+}
+function getRemoveLiquidityInstructionDataCodec() {
+  return kit.combineCodec(
+    getRemoveLiquidityInstructionDataEncoder(),
+    getRemoveLiquidityInstructionDataDecoder()
+  );
+}
+async function getRemoveLiquidityInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    position: { value: input.position ?? null, isWritable: true },
+    protocolFeePosition: {
+      value: input.protocolFeePosition ?? null,
+      isWritable: true
+    },
+    owner: { value: input.owner ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    user0: { value: input.user0 ?? null, isWritable: true },
+    user1: { value: input.user1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.authority.value) {
+    accounts.authority.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([97, 117, 116, 104, 111, 114, 105, 116, 121])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("position", accounts.position),
+      getAccountMeta("protocolFeePosition", accounts.protocolFeePosition),
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("user0", accounts.user0),
+      getAccountMeta("user1", accounts.user1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program),
+      getAccountMeta("oracle", accounts.oracle)
+    ],
+    data: getRemoveLiquidityInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getRemoveLiquidityInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    position: { value: input.position ?? null, isWritable: true },
+    protocolFeePosition: {
+      value: input.protocolFeePosition ?? null,
+      isWritable: true
+    },
+    owner: { value: input.owner ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    user0: { value: input.user0 ?? null, isWritable: true },
+    user1: { value: input.user1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("position", accounts.position),
+      getAccountMeta("protocolFeePosition", accounts.protocolFeePosition),
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("user0", accounts.user0),
+      getAccountMeta("user1", accounts.user1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program),
+      getAccountMeta("oracle", accounts.oracle)
+    ],
+    data: getRemoveLiquidityInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseRemoveLiquidityInstruction(instruction) {
+  if (instruction.accounts.length < 15) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 15
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  const getNextOptionalAccount = () => {
+    const accountMeta = getNextAccount();
+    return accountMeta.address === CPMM_PROGRAM_ADDRESS ? void 0 : accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      pool: getNextAccount(),
+      position: getNextAccount(),
+      protocolFeePosition: getNextAccount(),
+      owner: getNextAccount(),
+      authority: getNextAccount(),
+      vault0: getNextAccount(),
+      vault1: getNextAccount(),
+      token0Mint: getNextAccount(),
+      token1Mint: getNextAccount(),
+      user0: getNextAccount(),
+      user1: getNextAccount(),
+      token0Program: getNextAccount(),
+      token1Program: getNextAccount(),
+      oracle: getNextOptionalAccount()
+    },
+    data: getRemoveLiquidityInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var SET_FEES_DISCRIMINATOR = new Uint8Array([
+  137,
+  178,
+  49,
+  58,
+  0,
+  245,
+  242,
+  190
+]);
+function getSetFeesDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(SET_FEES_DISCRIMINATOR);
+}
+function getSetFeesInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["swapFeeBps", kit.getU16Encoder()],
+      ["feeSplitBps", kit.getU16Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: SET_FEES_DISCRIMINATOR })
+  );
+}
+function getSetFeesInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["swapFeeBps", kit.getU16Decoder()],
+    ["feeSplitBps", kit.getU16Decoder()]
+  ]);
+}
+function getSetFeesInstructionDataCodec() {
+  return kit.combineCodec(
+    getSetFeesInstructionDataEncoder(),
+    getSetFeesInstructionDataDecoder()
+  );
+}
+function getSetFeesInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    admin: { value: input.admin ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("admin", accounts.admin)
+    ],
+    data: getSetFeesInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseSetFeesInstruction(instruction) {
+  if (instruction.accounts.length < 3) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 3
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      pool: getNextAccount(),
+      admin: getNextAccount()
+    },
+    data: getSetFeesInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var SET_HOOK_DISCRIMINATOR = new Uint8Array([
+  175,
+  16,
+  187,
+  252,
+  19,
+  54,
+  111,
+  221
+]);
+function getSetHookDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(SET_HOOK_DISCRIMINATOR);
+}
+function getSetHookInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["hookProgram", kit.getAddressEncoder()],
+      ["hookFlags", kit.getU32Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: SET_HOOK_DISCRIMINATOR })
+  );
+}
+function getSetHookInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["hookProgram", kit.getAddressDecoder()],
+    ["hookFlags", kit.getU32Decoder()]
+  ]);
+}
+function getSetHookInstructionDataCodec() {
+  return kit.combineCodec(
+    getSetHookInstructionDataEncoder(),
+    getSetHookInstructionDataDecoder()
+  );
+}
+function getSetHookInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    admin: { value: input.admin ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("admin", accounts.admin)
+    ],
+    data: getSetHookInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseSetHookInstruction(instruction) {
+  if (instruction.accounts.length < 3) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 3
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      pool: getNextAccount(),
+      admin: getNextAccount()
+    },
+    data: getSetHookInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var SWAP_EXACT_IN_DISCRIMINATOR = new Uint8Array([
+  104,
+  104,
+  131,
+  86,
+  161,
+  189,
+  180,
+  216
+]);
+function getSwapExactInDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    SWAP_EXACT_IN_DISCRIMINATOR
+  );
+}
+function getSwapExactInInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["amountIn", kit.getU64Encoder()],
+      ["minAmountOut", kit.getU64Encoder()],
+      ["tradeDirection", kit.getU8Encoder()],
+      ["updateOracle", kit.getBooleanEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: SWAP_EXACT_IN_DISCRIMINATOR })
+  );
+}
+function getSwapExactInInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["amountIn", kit.getU64Decoder()],
+    ["minAmountOut", kit.getU64Decoder()],
+    ["tradeDirection", kit.getU8Decoder()],
+    ["updateOracle", kit.getBooleanDecoder()]
+  ]);
+}
+function getSwapExactInInstructionDataCodec() {
+  return kit.combineCodec(
+    getSwapExactInInstructionDataEncoder(),
+    getSwapExactInInstructionDataDecoder()
+  );
+}
+async function getSwapExactInInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vaultIn: { value: input.vaultIn ?? null, isWritable: true },
+    vaultOut: { value: input.vaultOut ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    userIn: { value: input.userIn ?? null, isWritable: true },
+    userOut: { value: input.userOut ?? null, isWritable: true },
+    trader: { value: input.trader ?? null, isWritable: false },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.authority.value) {
+    accounts.authority.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([97, 117, 116, 104, 111, 114, 105, 116, 121])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vaultIn", accounts.vaultIn),
+      getAccountMeta("vaultOut", accounts.vaultOut),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("userIn", accounts.userIn),
+      getAccountMeta("userOut", accounts.userOut),
+      getAccountMeta("trader", accounts.trader),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program),
+      getAccountMeta("oracle", accounts.oracle)
+    ],
+    data: getSwapExactInInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getSwapExactInInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vaultIn: { value: input.vaultIn ?? null, isWritable: true },
+    vaultOut: { value: input.vaultOut ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    userIn: { value: input.userIn ?? null, isWritable: true },
+    userOut: { value: input.userOut ?? null, isWritable: true },
+    trader: { value: input.trader ?? null, isWritable: false },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vaultIn", accounts.vaultIn),
+      getAccountMeta("vaultOut", accounts.vaultOut),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("userIn", accounts.userIn),
+      getAccountMeta("userOut", accounts.userOut),
+      getAccountMeta("trader", accounts.trader),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program),
+      getAccountMeta("oracle", accounts.oracle)
+    ],
+    data: getSwapExactInInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseSwapExactInInstruction(instruction) {
+  if (instruction.accounts.length < 13) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 13
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  const getNextOptionalAccount = () => {
+    const accountMeta = getNextAccount();
+    return accountMeta.address === CPMM_PROGRAM_ADDRESS ? void 0 : accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      pool: getNextAccount(),
+      authority: getNextAccount(),
+      vaultIn: getNextAccount(),
+      vaultOut: getNextAccount(),
+      token0Mint: getNextAccount(),
+      token1Mint: getNextAccount(),
+      userIn: getNextAccount(),
+      userOut: getNextAccount(),
+      trader: getNextAccount(),
+      token0Program: getNextAccount(),
+      token1Program: getNextAccount(),
+      oracle: getNextOptionalAccount()
+    },
+    data: getSwapExactInInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var TRANSFER_ADMIN_DISCRIMINATOR = new Uint8Array([
+  42,
+  242,
+  66,
+  106,
+  228,
+  10,
+  111,
+  156
+]);
+function getTransferAdminDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    TRANSFER_ADMIN_DISCRIMINATOR
+  );
+}
+function getTransferAdminInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["newAdmin", kit.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: TRANSFER_ADMIN_DISCRIMINATOR })
+  );
+}
+function getTransferAdminInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["newAdmin", kit.getAddressDecoder()]
+  ]);
+}
+function getTransferAdminInstructionDataCodec() {
+  return kit.combineCodec(
+    getTransferAdminInstructionDataEncoder(),
+    getTransferAdminInstructionDataDecoder()
+  );
+}
+function getTransferAdminInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: true },
+    admin: { value: input.admin ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("admin", accounts.admin)
+    ],
+    data: getTransferAdminInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseTransferAdminInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { config: getNextAccount(), admin: getNextAccount() },
+    data: getTransferAdminInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var UNPAUSE_DISCRIMINATOR = new Uint8Array([
+  169,
+  144,
+  4,
+  38,
+  10,
+  141,
+  188,
+  255
+]);
+function getUnpauseDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(UNPAUSE_DISCRIMINATOR);
+}
+function getUnpauseInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)]]),
+    (value) => ({ ...value, discriminator: UNPAUSE_DISCRIMINATOR })
+  );
+}
+function getUnpauseInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)]
+  ]);
+}
+function getUnpauseInstructionDataCodec() {
+  return kit.combineCodec(
+    getUnpauseInstructionDataEncoder(),
+    getUnpauseInstructionDataDecoder()
+  );
+}
+function getUnpauseInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: true },
+    admin: { value: input.admin ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("admin", accounts.admin)
+    ],
+    data: getUnpauseInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseUnpauseInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { config: getNextAccount(), admin: getNextAccount() },
+    data: getUnpauseInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var UPDATE_CONFIG_DISCRIMINATOR = new Uint8Array([
+  29,
+  158,
+  252,
+  191,
+  10,
+  83,
+  219,
+  99
+]);
+function getUpdateConfigDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    UPDATE_CONFIG_DISCRIMINATOR
+  );
+}
+function getUpdateConfigInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["maxSwapFeeBps", kit.getU16Encoder()],
+      ["maxFeeSplitBps", kit.getU16Encoder()],
+      ["protocolFeeEnabled", kit.getBooleanEncoder()],
+      ["protocolFeeBps", kit.getU16Encoder()],
+      ["hookAllowlist", kit.getArrayEncoder(kit.getAddressEncoder())]
+    ]),
+    (value) => ({ ...value, discriminator: UPDATE_CONFIG_DISCRIMINATOR })
+  );
+}
+function getUpdateConfigInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["maxSwapFeeBps", kit.getU16Decoder()],
+    ["maxFeeSplitBps", kit.getU16Decoder()],
+    ["protocolFeeEnabled", kit.getBooleanDecoder()],
+    ["protocolFeeBps", kit.getU16Decoder()],
+    ["hookAllowlist", kit.getArrayDecoder(kit.getAddressDecoder())]
+  ]);
+}
+function getUpdateConfigInstructionDataCodec() {
+  return kit.combineCodec(
+    getUpdateConfigInstructionDataEncoder(),
+    getUpdateConfigInstructionDataDecoder()
+  );
+}
+function getUpdateConfigInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: true },
+    admin: { value: input.admin ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("admin", accounts.admin)
+    ],
+    data: getUpdateConfigInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseUpdateConfigInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { config: getNextAccount(), admin: getNextAccount() },
+    data: getUpdateConfigInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var WITHDRAW_VAULT_EXCESS_DISCRIMINATOR = new Uint8Array([
+  235,
+  197,
+  247,
+  177,
+  137,
+  72,
+  135,
+  113
+]);
+function getWithdrawVaultExcessDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    WITHDRAW_VAULT_EXCESS_DISCRIMINATOR
+  );
+}
+function getWithdrawVaultExcessInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)]]),
+    (value) => ({
+      ...value,
+      discriminator: WITHDRAW_VAULT_EXCESS_DISCRIMINATOR
+    })
+  );
+}
+function getWithdrawVaultExcessInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)]
+  ]);
+}
+function getWithdrawVaultExcessInstructionDataCodec() {
+  return kit.combineCodec(
+    getWithdrawVaultExcessInstructionDataEncoder(),
+    getWithdrawVaultExcessInstructionDataDecoder()
+  );
+}
+async function getWithdrawVaultExcessInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: false },
+    admin: { value: input.admin ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    adminAta0: { value: input.adminAta0 ?? null, isWritable: true },
+    adminAta1: { value: input.adminAta1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.authority.value) {
+    accounts.authority.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([97, 117, 116, 104, 111, 114, 105, 116, 121])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  if (!accounts.adminAta0.value) {
+    accounts.adminAta0.value = await kit.getProgramDerivedAddress({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "admin",
+            accounts.admin.value
+          )
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "token0Program",
+            accounts.token0Program.value
+          )
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "token0Mint",
+            accounts.token0Mint.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.adminAta1.value) {
+    accounts.adminAta1.value = await kit.getProgramDerivedAddress({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "admin",
+            accounts.admin.value
+          )
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "token1Program",
+            accounts.token1Program.value
+          )
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "token1Mint",
+            accounts.token1Mint.value
+          )
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("admin", accounts.admin),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("adminAta0", accounts.adminAta0),
+      getAccountMeta("adminAta1", accounts.adminAta1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program)
+    ],
+    data: getWithdrawVaultExcessInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function getWithdrawVaultExcessInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: false },
+    admin: { value: input.admin ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    adminAta0: { value: input.adminAta0 ?? null, isWritable: true },
+    adminAta1: { value: input.adminAta1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("admin", accounts.admin),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("adminAta0", accounts.adminAta0),
+      getAccountMeta("adminAta1", accounts.adminAta1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program)
+    ],
+    data: getWithdrawVaultExcessInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseWithdrawVaultExcessInstruction(instruction) {
+  if (instruction.accounts.length < 12) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 12
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      pool: getNextAccount(),
+      admin: getNextAccount(),
+      authority: getNextAccount(),
+      vault0: getNextAccount(),
+      vault1: getNextAccount(),
+      token0Mint: getNextAccount(),
+      token1Mint: getNextAccount(),
+      adminAta0: getNextAccount(),
+      adminAta1: getNextAccount(),
+      token0Program: getNextAccount(),
+      token1Program: getNextAccount()
+    },
+    data: getWithdrawVaultExcessInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+
+// src/solana/generated/cpmm/programs/cpmm.ts
+var CPMM_PROGRAM_ADDRESS = "9PSxVPoPfnbZ8Q1uQhgS6ZxvBjFboZtebNsu34umxkgQ";
+
+// src/solana/generated/cpmm/instructions/addLiquidity.ts
+var ADD_LIQUIDITY_DISCRIMINATOR = new Uint8Array([
+  181,
+  157,
+  89,
+  67,
+  143,
+  182,
+  52,
+  72
+]);
+function getAddLiquidityDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    ADD_LIQUIDITY_DISCRIMINATOR
+  );
+}
+function getAddLiquidityInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["amount0Max", kit.getU64Encoder()],
+      ["amount1Max", kit.getU64Encoder()],
+      ["minSharesOut", kit.getU128Encoder()],
+      ["updateOracle", kit.getBooleanEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: ADD_LIQUIDITY_DISCRIMINATOR })
+  );
+}
+function getAddLiquidityInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["amount0Max", kit.getU64Decoder()],
+    ["amount1Max", kit.getU64Decoder()],
+    ["minSharesOut", kit.getU128Decoder()],
+    ["updateOracle", kit.getBooleanDecoder()]
+  ]);
+}
+function getAddLiquidityInstructionDataCodec() {
+  return kit.combineCodec(
+    getAddLiquidityInstructionDataEncoder(),
+    getAddLiquidityInstructionDataDecoder()
+  );
+}
+async function getAddLiquidityInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    position: { value: input.position ?? null, isWritable: true },
+    protocolFeePosition: {
+      value: input.protocolFeePosition ?? null,
+      isWritable: true
+    },
+    owner: { value: input.owner ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    user0: { value: input.user0 ?? null, isWritable: true },
+    user1: { value: input.user1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.authority.value) {
+    accounts.authority.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([97, 117, 116, 104, 111, 114, 105, 116, 121])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("position", accounts.position),
+      getAccountMeta("protocolFeePosition", accounts.protocolFeePosition),
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("user0", accounts.user0),
+      getAccountMeta("user1", accounts.user1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program),
+      getAccountMeta("oracle", accounts.oracle)
+    ],
+    data: getAddLiquidityInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getAddLiquidityInstruction(input, config) {
+  const programAddress = config?.programAddress ?? CPMM_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    pool: { value: input.pool ?? null, isWritable: true },
+    position: { value: input.position ?? null, isWritable: true },
+    protocolFeePosition: {
+      value: input.protocolFeePosition ?? null,
+      isWritable: true
+    },
+    owner: { value: input.owner ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    vault0: { value: input.vault0 ?? null, isWritable: true },
+    vault1: { value: input.vault1 ?? null, isWritable: true },
+    token0Mint: { value: input.token0Mint ?? null, isWritable: false },
+    token1Mint: { value: input.token1Mint ?? null, isWritable: false },
+    user0: { value: input.user0 ?? null, isWritable: true },
+    user1: { value: input.user1 ?? null, isWritable: true },
+    token0Program: { value: input.token0Program ?? null, isWritable: false },
+    token1Program: { value: input.token1Program ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("config", accounts.config),
+      getAccountMeta("pool", accounts.pool),
+      getAccountMeta("position", accounts.position),
+      getAccountMeta("protocolFeePosition", accounts.protocolFeePosition),
+      getAccountMeta("owner", accounts.owner),
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("vault0", accounts.vault0),
+      getAccountMeta("vault1", accounts.vault1),
+      getAccountMeta("token0Mint", accounts.token0Mint),
+      getAccountMeta("token1Mint", accounts.token1Mint),
+      getAccountMeta("user0", accounts.user0),
+      getAccountMeta("user1", accounts.user1),
+      getAccountMeta("token0Program", accounts.token0Program),
+      getAccountMeta("token1Program", accounts.token1Program),
+      getAccountMeta("oracle", accounts.oracle)
+    ],
+    data: getAddLiquidityInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseAddLiquidityInstruction(instruction) {
+  if (instruction.accounts.length < 15) {
+    throw new kit.SolanaError(
+      kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 15
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  const getNextOptionalAccount = () => {
+    const accountMeta = getNextAccount();
+    return accountMeta.address === CPMM_PROGRAM_ADDRESS ? void 0 : accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      pool: getNextAccount(),
+      position: getNextAccount(),
+      protocolFeePosition: getNextAccount(),
+      owner: getNextAccount(),
+      authority: getNextAccount(),
+      vault0: getNextAccount(),
+      vault1: getNextAccount(),
+      token0Mint: getNextAccount(),
+      token1Mint: getNextAccount(),
+      user0: getNextAccount(),
+      user1: getNextAccount(),
+      token0Program: getNextAccount(),
+      token1Program: getNextAccount(),
+      oracle: getNextOptionalAccount()
+    },
+    data: getAddLiquidityInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// 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 ?? chunkY6TJIH33_cjs.CPMM_PROGRAM_ID;
+  const discriminatorFilter = {
+    memcmp: {
+      offset: 0n,
+      bytes: bytesToBase64(chunkY6TJIH33_cjs.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 ?? chunkY6TJIH33_cjs.CPMM_PROGRAM_ID;
+  const [poolAddress] = await chunkY6TJIH33_cjs.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 = chunkY6TJIH33_cjs.CPMM_PROGRAM_ID) {
+  const [token0, token1] = chunkY6TJIH33_cjs.sortMints(mint0, mint1);
+  const [poolAddress] = await chunkY6TJIH33_cjs.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 ?? chunkY6TJIH33_cjs.CPMM_PROGRAM_ID;
+  const filters = [
+    // Discriminator filter (first 8 bytes)
+    {
+      memcmp: {
+        offset: 0n,
+        bytes: bytesToBase642(
+          chunkY6TJIH33_cjs.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 ?? chunkY6TJIH33_cjs.CPMM_PROGRAM_ID;
+  const filters = [
+    // Discriminator filter
+    {
+      memcmp: {
+        offset: 0n,
+        bytes: bytesToBase642(
+          chunkY6TJIH33_cjs.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 ?? chunkY6TJIH33_cjs.CPMM_PROGRAM_ID;
+  const [address] = await chunkY6TJIH33_cjs.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 = chunkY6TJIH33_cjs.CPMM_PROGRAM_ID) {
+  const [address] = await chunkY6TJIH33_cjs.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 ?? chunkY6TJIH33_cjs.CPMM_PROGRAM_ID;
+  const [oracleAddress] = await chunkY6TJIH33_cjs.getOracleAddress(pool, programId);
+  const oracle = await fetchOracle(rpc, oracleAddress, config);
+  if (!oracle) {
+    return null;
+  }
+  return {
+    address: oracleAddress,
+    account: oracle
+  };
+}
+async function getOracleAddressFromPool(pool, programId = chunkY6TJIH33_cjs.CPMM_PROGRAM_ID) {
+  const [address] = await chunkY6TJIH33_cjs.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 ?? chunkY6TJIH33_cjs.CPMM_PROGRAM_ID;
+  const oracles = /* @__PURE__ */ new Map();
+  const oracleAddresses = await Promise.all(
+    pools.map((pool) => chunkY6TJIH33_cjs.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
+  };
+}
+
+exports.ADD_LIQUIDITY_DISCRIMINATOR = ADD_LIQUIDITY_DISCRIMINATOR;
+exports.CLOSE_POSITION_DISCRIMINATOR = CLOSE_POSITION_DISCRIMINATOR;
+exports.COLLECT_FEES_DISCRIMINATOR = COLLECT_FEES_DISCRIMINATOR;
+exports.COLLECT_PROTOCOL_FEES_DISCRIMINATOR = COLLECT_PROTOCOL_FEES_DISCRIMINATOR;
+exports.CPMM_PROGRAM_ADDRESS = CPMM_PROGRAM_ADDRESS;
+exports.CREATE_POSITION_DISCRIMINATOR = CREATE_POSITION_DISCRIMINATOR;
+exports.INITIALIZE_CONFIG_DISCRIMINATOR = INITIALIZE_CONFIG_DISCRIMINATOR;
+exports.INITIALIZE_ORACLE_DISCRIMINATOR = INITIALIZE_ORACLE_DISCRIMINATOR;
+exports.INITIALIZE_POOL_DISCRIMINATOR = INITIALIZE_POOL_DISCRIMINATOR;
+exports.ORACLE_CONSULT_DISCRIMINATOR = ORACLE_CONSULT_DISCRIMINATOR;
+exports.ORACLE_UPDATE_DISCRIMINATOR = ORACLE_UPDATE_DISCRIMINATOR;
+exports.PAUSE_DISCRIMINATOR = PAUSE_DISCRIMINATOR;
+exports.PREVIEW_SWAP_EXACT_IN_DISCRIMINATOR = PREVIEW_SWAP_EXACT_IN_DISCRIMINATOR;
+exports.REDEEM_PROTOCOL_SHARES_DISCRIMINATOR = REDEEM_PROTOCOL_SHARES_DISCRIMINATOR;
+exports.REMOVE_LIQUIDITY_DISCRIMINATOR = REMOVE_LIQUIDITY_DISCRIMINATOR;
+exports.SET_FEES_DISCRIMINATOR = SET_FEES_DISCRIMINATOR;
+exports.SET_HOOK_DISCRIMINATOR = SET_HOOK_DISCRIMINATOR;
+exports.SWAP_EXACT_IN_DISCRIMINATOR = SWAP_EXACT_IN_DISCRIMINATOR;
+exports.TRANSFER_ADMIN_DISCRIMINATOR = TRANSFER_ADMIN_DISCRIMINATOR;
+exports.UNPAUSE_DISCRIMINATOR = UNPAUSE_DISCRIMINATOR;
+exports.UPDATE_CONFIG_DISCRIMINATOR = UPDATE_CONFIG_DISCRIMINATOR;
+exports.WITHDRAW_VAULT_EXCESS_DISCRIMINATOR = WITHDRAW_VAULT_EXCESS_DISCRIMINATOR;
+exports.addLiquidityArgsCodec = addLiquidityArgsCodec;
+exports.ammConfigDataCodec = ammConfigDataCodec;
+exports.calculateAccruedFees = calculateAccruedFees;
+exports.calculateTwap = calculateTwap;
+exports.calculateTwapNumber = calculateTwapNumber;
+exports.ceilDiv = ceilDiv;
+exports.collectFeesArgsCodec = collectFeesArgsCodec;
+exports.collectProtocolFeesArgsCodec = collectProtocolFeesArgsCodec;
+exports.comparePoolAndOraclePrices = comparePoolAndOraclePrices;
+exports.computePrice0Q64 = computePrice0Q64;
+exports.computePrice1Q64 = computePrice1Q64;
+exports.consultTwap = consultTwap;
+exports.createPositionArgsCodec = createPositionArgsCodec;
+exports.decodeAmmConfig = decodeAmmConfig;
+exports.decodeOracleState = decodeOracleState;
+exports.decodePool = decodePool;
+exports.decodePosition = decodePosition;
+exports.encodeAddLiquidityArgs = encodeAddLiquidityArgs;
+exports.encodeCollectFeesArgs = encodeCollectFeesArgs;
+exports.encodeCollectProtocolFeesArgs = encodeCollectProtocolFeesArgs;
+exports.encodeCreatePositionArgs = encodeCreatePositionArgs;
+exports.encodeInitializeConfigArgs = encodeInitializeConfigArgs;
+exports.encodeInitializeOracleArgs = encodeInitializeOracleArgs;
+exports.encodeInitializePoolArgs = encodeInitializePoolArgs;
+exports.encodeInstructionData = encodeInstructionData;
+exports.encodeOracleConsultArgs = encodeOracleConsultArgs;
+exports.encodeRemoveLiquidityArgs = encodeRemoveLiquidityArgs;
+exports.encodeSetFeesArgs = encodeSetFeesArgs;
+exports.encodeSetHookArgs = encodeSetHookArgs;
+exports.encodeSwapExactInArgs = encodeSwapExactInArgs;
+exports.encodeTransferAdminArgs = encodeTransferAdminArgs;
+exports.fetchAllPools = fetchAllPools;
+exports.fetchOracle = fetchOracle;
+exports.fetchOraclesBatch = fetchOraclesBatch;
+exports.fetchPool = fetchPool;
+exports.fetchPoolPositions = fetchPoolPositions;
+exports.fetchPoolsBatch = fetchPoolsBatch;
+exports.fetchPosition = fetchPosition;
+exports.fetchPositionByParams = fetchPositionByParams;
+exports.fetchPositionsBatch = fetchPositionsBatch;
+exports.fetchUserPositions = fetchUserPositions;
+exports.filterActivePositions = filterActivePositions;
+exports.filterPoolsByMint = filterPoolsByMint;
+exports.getAddLiquidityDiscriminatorBytes = getAddLiquidityDiscriminatorBytes;
+exports.getAddLiquidityInstruction = getAddLiquidityInstruction;
+exports.getAddLiquidityInstructionAsync = getAddLiquidityInstructionAsync;
+exports.getAddLiquidityInstructionDataCodec = getAddLiquidityInstructionDataCodec;
+exports.getAddLiquidityInstructionDataDecoder = getAddLiquidityInstructionDataDecoder;
+exports.getAddLiquidityInstructionDataEncoder = getAddLiquidityInstructionDataEncoder;
+exports.getAddLiquidityQuote = getAddLiquidityQuote;
+exports.getClosePositionDiscriminatorBytes = getClosePositionDiscriminatorBytes;
+exports.getClosePositionInstruction = getClosePositionInstruction;
+exports.getClosePositionInstructionDataCodec = getClosePositionInstructionDataCodec;
+exports.getClosePositionInstructionDataDecoder = getClosePositionInstructionDataDecoder;
+exports.getClosePositionInstructionDataEncoder = getClosePositionInstructionDataEncoder;
+exports.getCollectFeesDiscriminatorBytes = getCollectFeesDiscriminatorBytes;
+exports.getCollectFeesInstruction = getCollectFeesInstruction;
+exports.getCollectFeesInstructionAsync = getCollectFeesInstructionAsync;
+exports.getCollectFeesInstructionDataCodec = getCollectFeesInstructionDataCodec;
+exports.getCollectFeesInstructionDataDecoder = getCollectFeesInstructionDataDecoder;
+exports.getCollectFeesInstructionDataEncoder = getCollectFeesInstructionDataEncoder;
+exports.getCollectProtocolFeesDiscriminatorBytes = getCollectProtocolFeesDiscriminatorBytes;
+exports.getCollectProtocolFeesInstruction = getCollectProtocolFeesInstruction;
+exports.getCollectProtocolFeesInstructionAsync = getCollectProtocolFeesInstructionAsync;
+exports.getCollectProtocolFeesInstructionDataCodec = getCollectProtocolFeesInstructionDataCodec;
+exports.getCollectProtocolFeesInstructionDataDecoder = getCollectProtocolFeesInstructionDataDecoder;
+exports.getCollectProtocolFeesInstructionDataEncoder = getCollectProtocolFeesInstructionDataEncoder;
+exports.getCreatePositionDiscriminatorBytes = getCreatePositionDiscriminatorBytes;
+exports.getCreatePositionInstruction = getCreatePositionInstruction;
+exports.getCreatePositionInstructionAsync = getCreatePositionInstructionAsync;
+exports.getCreatePositionInstructionDataCodec = getCreatePositionInstructionDataCodec;
+exports.getCreatePositionInstructionDataDecoder = getCreatePositionInstructionDataDecoder;
+exports.getCreatePositionInstructionDataEncoder = getCreatePositionInstructionDataEncoder;
+exports.getInitializeConfigDiscriminatorBytes = getInitializeConfigDiscriminatorBytes;
+exports.getInitializeConfigInstruction = getInitializeConfigInstruction;
+exports.getInitializeConfigInstructionAsync = getInitializeConfigInstructionAsync;
+exports.getInitializeConfigInstructionDataCodec = getInitializeConfigInstructionDataCodec;
+exports.getInitializeConfigInstructionDataDecoder = getInitializeConfigInstructionDataDecoder;
+exports.getInitializeConfigInstructionDataEncoder = getInitializeConfigInstructionDataEncoder;
+exports.getInitializeOracleDiscriminatorBytes = getInitializeOracleDiscriminatorBytes;
+exports.getInitializeOracleInstruction = getInitializeOracleInstruction;
+exports.getInitializeOracleInstructionAsync = getInitializeOracleInstructionAsync;
+exports.getInitializeOracleInstructionDataCodec = getInitializeOracleInstructionDataCodec;
+exports.getInitializeOracleInstructionDataDecoder = getInitializeOracleInstructionDataDecoder;
+exports.getInitializeOracleInstructionDataEncoder = getInitializeOracleInstructionDataEncoder;
+exports.getInitializePoolDiscriminatorBytes = getInitializePoolDiscriminatorBytes;
+exports.getInitializePoolInstruction = getInitializePoolInstruction;
+exports.getInitializePoolInstructionAsync = getInitializePoolInstructionAsync;
+exports.getInitializePoolInstructionDataCodec = getInitializePoolInstructionDataCodec;
+exports.getInitializePoolInstructionDataDecoder = getInitializePoolInstructionDataDecoder;
+exports.getInitializePoolInstructionDataEncoder = getInitializePoolInstructionDataEncoder;
+exports.getK = getK;
+exports.getOracleAddressFromPool = getOracleAddressFromPool;
+exports.getOracleAge = getOracleAge;
+exports.getOracleBufferStats = getOracleBufferStats;
+exports.getOracleConsultDiscriminatorBytes = getOracleConsultDiscriminatorBytes;
+exports.getOracleConsultInstruction = getOracleConsultInstruction;
+exports.getOracleConsultInstructionAsync = getOracleConsultInstructionAsync;
+exports.getOracleConsultInstructionDataCodec = getOracleConsultInstructionDataCodec;
+exports.getOracleConsultInstructionDataDecoder = getOracleConsultInstructionDataDecoder;
+exports.getOracleConsultInstructionDataEncoder = getOracleConsultInstructionDataEncoder;
+exports.getOracleDeviation = getOracleDeviation;
+exports.getOracleForPool = getOracleForPool;
+exports.getOracleSpotPrices = getOracleSpotPrices;
+exports.getOracleUpdateDiscriminatorBytes = getOracleUpdateDiscriminatorBytes;
+exports.getOracleUpdateInstruction = getOracleUpdateInstruction;
+exports.getOracleUpdateInstructionAsync = getOracleUpdateInstructionAsync;
+exports.getOracleUpdateInstructionDataCodec = getOracleUpdateInstructionDataCodec;
+exports.getOracleUpdateInstructionDataDecoder = getOracleUpdateInstructionDataDecoder;
+exports.getOracleUpdateInstructionDataEncoder = getOracleUpdateInstructionDataEncoder;
+exports.getPauseDiscriminatorBytes = getPauseDiscriminatorBytes;
+exports.getPauseInstruction = getPauseInstruction;
+exports.getPauseInstructionDataCodec = getPauseInstructionDataCodec;
+exports.getPauseInstructionDataDecoder = getPauseInstructionDataDecoder;
+exports.getPauseInstructionDataEncoder = getPauseInstructionDataEncoder;
+exports.getPendingFees = getPendingFees;
+exports.getPoolAddressFromMints = getPoolAddressFromMints;
+exports.getPoolByMints = getPoolByMints;
+exports.getPositionAddressFromParams = getPositionAddressFromParams;
+exports.getPositionValue = getPositionValue;
+exports.getPreviewSwapExactInDiscriminatorBytes = getPreviewSwapExactInDiscriminatorBytes;
+exports.getPreviewSwapExactInInstruction = getPreviewSwapExactInInstruction;
+exports.getPreviewSwapExactInInstructionDataCodec = getPreviewSwapExactInInstructionDataCodec;
+exports.getPreviewSwapExactInInstructionDataDecoder = getPreviewSwapExactInInstructionDataDecoder;
+exports.getPreviewSwapExactInInstructionDataEncoder = getPreviewSwapExactInInstructionDataEncoder;
+exports.getRedeemProtocolSharesDiscriminatorBytes = getRedeemProtocolSharesDiscriminatorBytes;
+exports.getRedeemProtocolSharesInstruction = getRedeemProtocolSharesInstruction;
+exports.getRedeemProtocolSharesInstructionAsync = getRedeemProtocolSharesInstructionAsync;
+exports.getRedeemProtocolSharesInstructionDataCodec = getRedeemProtocolSharesInstructionDataCodec;
+exports.getRedeemProtocolSharesInstructionDataDecoder = getRedeemProtocolSharesInstructionDataDecoder;
+exports.getRedeemProtocolSharesInstructionDataEncoder = getRedeemProtocolSharesInstructionDataEncoder;
+exports.getRemoveLiquidityDiscriminatorBytes = getRemoveLiquidityDiscriminatorBytes;
+exports.getRemoveLiquidityInstruction = getRemoveLiquidityInstruction;
+exports.getRemoveLiquidityInstructionAsync = getRemoveLiquidityInstructionAsync;
+exports.getRemoveLiquidityInstructionDataCodec = getRemoveLiquidityInstructionDataCodec;
+exports.getRemoveLiquidityInstructionDataDecoder = getRemoveLiquidityInstructionDataDecoder;
+exports.getRemoveLiquidityInstructionDataEncoder = getRemoveLiquidityInstructionDataEncoder;
+exports.getRemoveLiquidityQuote = getRemoveLiquidityQuote;
+exports.getSetFeesDiscriminatorBytes = getSetFeesDiscriminatorBytes;
+exports.getSetFeesInstruction = getSetFeesInstruction;
+exports.getSetFeesInstructionDataCodec = getSetFeesInstructionDataCodec;
+exports.getSetFeesInstructionDataDecoder = getSetFeesInstructionDataDecoder;
+exports.getSetFeesInstructionDataEncoder = getSetFeesInstructionDataEncoder;
+exports.getSetHookDiscriminatorBytes = getSetHookDiscriminatorBytes;
+exports.getSetHookInstruction = getSetHookInstruction;
+exports.getSetHookInstructionDataCodec = getSetHookInstructionDataCodec;
+exports.getSetHookInstructionDataDecoder = getSetHookInstructionDataDecoder;
+exports.getSetHookInstructionDataEncoder = getSetHookInstructionDataEncoder;
+exports.getSpotPrice0 = getSpotPrice0;
+exports.getSpotPrice1 = getSpotPrice1;
+exports.getSwapExactInDiscriminatorBytes = getSwapExactInDiscriminatorBytes;
+exports.getSwapExactInInstruction = getSwapExactInInstruction;
+exports.getSwapExactInInstructionAsync = getSwapExactInInstructionAsync;
+exports.getSwapExactInInstructionDataCodec = getSwapExactInInstructionDataCodec;
+exports.getSwapExactInInstructionDataDecoder = getSwapExactInInstructionDataDecoder;
+exports.getSwapExactInInstructionDataEncoder = getSwapExactInInstructionDataEncoder;
+exports.getSwapQuote = getSwapQuote;
+exports.getSwapQuoteExactOut = getSwapQuoteExactOut;
+exports.getTransferAdminDiscriminatorBytes = getTransferAdminDiscriminatorBytes;
+exports.getTransferAdminInstruction = getTransferAdminInstruction;
+exports.getTransferAdminInstructionDataCodec = getTransferAdminInstructionDataCodec;
+exports.getTransferAdminInstructionDataDecoder = getTransferAdminInstructionDataDecoder;
+exports.getTransferAdminInstructionDataEncoder = getTransferAdminInstructionDataEncoder;
+exports.getTvl = getTvl;
+exports.getUnpauseDiscriminatorBytes = getUnpauseDiscriminatorBytes;
+exports.getUnpauseInstruction = getUnpauseInstruction;
+exports.getUnpauseInstructionDataCodec = getUnpauseInstructionDataCodec;
+exports.getUnpauseInstructionDataDecoder = getUnpauseInstructionDataDecoder;
+exports.getUnpauseInstructionDataEncoder = getUnpauseInstructionDataEncoder;
+exports.getUpdateConfigDiscriminatorBytes = getUpdateConfigDiscriminatorBytes;
+exports.getUpdateConfigInstruction = getUpdateConfigInstruction;
+exports.getUpdateConfigInstructionDataCodec = getUpdateConfigInstructionDataCodec;
+exports.getUpdateConfigInstructionDataDecoder = getUpdateConfigInstructionDataDecoder;
+exports.getUpdateConfigInstructionDataEncoder = getUpdateConfigInstructionDataEncoder;
+exports.getWithdrawVaultExcessDiscriminatorBytes = getWithdrawVaultExcessDiscriminatorBytes;
+exports.getWithdrawVaultExcessInstruction = getWithdrawVaultExcessInstruction;
+exports.getWithdrawVaultExcessInstructionAsync = getWithdrawVaultExcessInstructionAsync;
+exports.getWithdrawVaultExcessInstructionDataCodec = getWithdrawVaultExcessInstructionDataCodec;
+exports.getWithdrawVaultExcessInstructionDataDecoder = getWithdrawVaultExcessInstructionDataDecoder;
+exports.getWithdrawVaultExcessInstructionDataEncoder = getWithdrawVaultExcessInstructionDataEncoder;
+exports.initializeConfigArgsCodec = initializeConfigArgsCodec;
+exports.initializeOracleArgsCodec = initializeOracleArgsCodec;
+exports.initializePoolArgsCodec = initializePoolArgsCodec;
+exports.isOracleStale = isOracleStale;
+exports.isqrt = isqrt;
+exports.maxBigInt = maxBigInt;
+exports.minBigInt = minBigInt;
+exports.numberToQ64 = numberToQ64;
+exports.observationCodec = observationCodec;
+exports.oracleConsultArgsCodec = oracleConsultArgsCodec;
+exports.oracleStateDataCodec = oracleStateDataCodec;
+exports.parseAddLiquidityInstruction = parseAddLiquidityInstruction;
+exports.parseClosePositionInstruction = parseClosePositionInstruction;
+exports.parseCollectFeesInstruction = parseCollectFeesInstruction;
+exports.parseCollectProtocolFeesInstruction = parseCollectProtocolFeesInstruction;
+exports.parseCreatePositionInstruction = parseCreatePositionInstruction;
+exports.parseInitializeConfigInstruction = parseInitializeConfigInstruction;
+exports.parseInitializeOracleInstruction = parseInitializeOracleInstruction;
+exports.parseInitializePoolInstruction = parseInitializePoolInstruction;
+exports.parseOracleConsultInstruction = parseOracleConsultInstruction;
+exports.parseOracleUpdateInstruction = parseOracleUpdateInstruction;
+exports.parsePauseInstruction = parsePauseInstruction;
+exports.parsePreviewSwapExactInInstruction = parsePreviewSwapExactInInstruction;
+exports.parseRedeemProtocolSharesInstruction = parseRedeemProtocolSharesInstruction;
+exports.parseRemoveLiquidityInstruction = parseRemoveLiquidityInstruction;
+exports.parseSetFeesInstruction = parseSetFeesInstruction;
+exports.parseSetHookInstruction = parseSetHookInstruction;
+exports.parseSwapExactInInstruction = parseSwapExactInInstruction;
+exports.parseTransferAdminInstruction = parseTransferAdminInstruction;
+exports.parseUnpauseInstruction = parseUnpauseInstruction;
+exports.parseUpdateConfigInstruction = parseUpdateConfigInstruction;
+exports.parseWithdrawVaultExcessInstruction = parseWithdrawVaultExcessInstruction;
+exports.poolDataCodec = poolDataCodec;
+exports.poolExists = poolExists;
+exports.positionDataCodec = positionDataCodec;
+exports.q64Div = q64Div;
+exports.q64Mul = q64Mul;
+exports.q64ToNumber = q64ToNumber;
+exports.ratioToNumber = ratioToNumber;
+exports.removeLiquidityArgsCodec = removeLiquidityArgsCodec;
+exports.setFeesArgsCodec = setFeesArgsCodec;
+exports.setHookArgsCodec = setHookArgsCodec;
+exports.sortPoolsByReserves = sortPoolsByReserves;
+exports.sortPositionsByShares = sortPositionsByShares;
+exports.swapExactInArgsCodec = swapExactInArgsCodec;
+exports.transferAdminArgsCodec = transferAdminArgsCodec;
+//# sourceMappingURL=chunk-KJ6W44WF.cjs.map
+//# sourceMappingURL=chunk-KJ6W44WF.cjs.map