@stabbleorg/mclmm-sdk 0.3.2 → 0.4.0

package/lib/index.js

@@ -66,11 +66,13 @@ __export(index_exports, {
   PoolManager: () => PoolManager,
   PoolUtils: () => PoolUtils,
   PositionManager: () => PositionManager,
+  PositionUtils: () => PositionUtils,
   PriceApiClient: () => PriceApiClient,
   Q128: () => Q128,
   Q64: () => Q64,
   SLIPPAGE_CALC: () => SLIPPAGE_CALC,
   STABBLE_CLMM_PROGRAM_ID: () => STABBLE_CLMM_PROGRAM_ID,
+  STABBLE_CLMM_QAS_PROGRAM_ID: () => STABBLE_CLMM_QAS_PROGRAM_ID,
   SYSTEM_PROGRAM_ID: () => SYSTEM_PROGRAM_ID,
   SYSVAR_RENT_PROGRAM_ID: () => SYSVAR_RENT_PROGRAM_ID,
   SqrtPriceMath: () => SqrtPriceMath,
@@ -5183,6 +5185,7 @@ var import_decimal2 = __toESM(require("decimal.js"));
 // src/constants.ts
 var import_bn = __toESM(require("bn.js"));
 var STABBLE_CLMM_PROGRAM_ID = "6dMXqGZ3ga2dikrYS9ovDXgHGh5RUsb2RTUj6hrQXhk6";
+var STABBLE_CLMM_QAS_PROGRAM_ID = "8896VTm3Z3g8PuktiDdW9JLxZP1ww2r5c9Tz5AbaBjAJ";
 var METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
 var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
 var SYSVAR_RENT_PROGRAM_ID = "SysvarRent111111111111111111111111111111111";
@@ -5348,6 +5351,22 @@ var TickUtils = class _TickUtils {
       );
     }
   }
+  static getTickOffsetInArray(tickIndex, tickSpacing) {
+    if (tickIndex % tickSpacing != 0) {
+      throw new Error("tickIndex % tickSpacing not equal 0");
+    }
+    const startTickIndex = _TickUtils.getTickArrayStartIndexByTick(
+      tickIndex,
+      tickSpacing
+    );
+    const offsetInArray = Math.floor(
+      (tickIndex - startTickIndex) / tickSpacing
+    );
+    if (offsetInArray < 0 || offsetInArray >= TICK_ARRAY_SIZE) {
+      throw new Error("tick offset in array overflow");
+    }
+    return offsetInArray;
+  }
   /**
    * Get the start index of the tick array containing a specific tick
    * @param tick - Target tick
@@ -5629,11 +5648,12 @@ var PdaUtils = class {
    * @param ammConfig - AMM config address
    * @param tokenMintA - Token A mint address
    * @param tokenMintB - Token B mint address
+   * @param programId - Program address (defaults to production)
    * @returns Pool state PDA
    */
-  static async getPoolStatePda(ammConfig, tokenMintA, tokenMintB) {
+  static async getPoolStatePda(ammConfig, tokenMintA, tokenMintB, programId = STABBLE_CLMM_PROGRAM_ID) {
     return await (0, import_kit50.getProgramDerivedAddress)({
-      programAddress: STABBLE_CLMM_PROGRAM_ID,
+      programAddress: programId,
       seeds: [
         PDA_SEEDS.POOL_STATE,
         addressEncoder.encode(ammConfig),
@@ -5645,22 +5665,24 @@ var PdaUtils = class {
   /**
    * Derive AMM config PDA
    * @param index - Config index
+   * @param programId - Program address (defaults to production)
    * @returns AMM config PDA
    */
-  static async getAmmConfigPda(index) {
+  static async getAmmConfigPda(index, programId = STABBLE_CLMM_PROGRAM_ID) {
     return await (0, import_kit50.getProgramDerivedAddress)({
-      programAddress: STABBLE_CLMM_PROGRAM_ID,
+      programAddress: programId,
       seeds: [PDA_SEEDS.AMM_CONFIG, (0, import_kit50.getU16Encoder)().encode(index)]
     });
   }
   /**
    * Derive position state PDA
    * @param nftMint - Position NFT mint address
+   * @param programId - Program address (defaults to production)
    * @returns Position state PDA
    */
-  static async getPositionStatePda(nftMint) {
+  static async getPositionStatePda(nftMint, programId = STABBLE_CLMM_PROGRAM_ID) {
     return await (0, import_kit50.getProgramDerivedAddress)({
-      programAddress: STABBLE_CLMM_PROGRAM_ID,
+      programAddress: programId,
       seeds: [PDA_SEEDS.POSITION_STATE, addressEncoder.encode(nftMint)]
     });
   }
@@ -5668,11 +5690,12 @@ var PdaUtils = class {
    * Derive tick array state PDA
    * @param poolState - Pool state address
    * @param startTickIndex - Starting tick index of the array
+   * @param programId - Program address (defaults to production)
    * @returns Tick array state PDA
    */
-  static async getTickArrayStatePda(poolState, startTickIndex) {
+  static async getTickArrayStatePda(poolState, startTickIndex, programId = STABBLE_CLMM_PROGRAM_ID) {
     return await (0, import_kit50.getProgramDerivedAddress)({
-      programAddress: STABBLE_CLMM_PROGRAM_ID,
+      programAddress: programId,
       seeds: [
         PDA_SEEDS.TICK_ARRAY_STATE,
         addressEncoder.encode(poolState),
@@ -5683,32 +5706,34 @@ var PdaUtils = class {
   /**
    * Derive observation state PDA
    * @param poolState - Pool state address
+   * @param programId - Program address (defaults to production)
    * @returns Observation state PDA
    */
-  static async getObservationStatePda(poolState) {
+  static async getObservationStatePda(poolState, programId = STABBLE_CLMM_PROGRAM_ID) {
     return await (0, import_kit50.getProgramDerivedAddress)({
-      programAddress: STABBLE_CLMM_PROGRAM_ID,
+      programAddress: programId,
       seeds: [PDA_SEEDS.OBSERVATION_STATE, addressEncoder.encode(poolState)]
     });
   }
-  static async getPoolVaultIdPda(poolAddress, vaultAddress) {
+  static async getPoolVaultIdPda(poolAddress, vaultAddress, programId = STABBLE_CLMM_PROGRAM_ID) {
     return await (0, import_kit50.getProgramDerivedAddress)({
       seeds: [
         PDA_SEEDS.POOL_VAULT,
         addressEncoder.encode(poolAddress),
         addressEncoder.encode(vaultAddress)
       ],
-      programAddress: STABBLE_CLMM_PROGRAM_ID
+      programAddress: programId
     });
   }
   /**
    * Derive tick array bitmap extension PDA
    * @param poolState - Pool state address
+   * @param programId - Program address (defaults to production)
    * @returns Tick array bitmap extension PDA
    */
-  static async getTickArrayBitmapExtensionPda(poolState) {
+  static async getTickArrayBitmapExtensionPda(poolState, programId = STABBLE_CLMM_PROGRAM_ID) {
     return await (0, import_kit50.getProgramDerivedAddress)({
-      programAddress: STABBLE_CLMM_PROGRAM_ID,
+      programAddress: programId,
       seeds: [PDA_SEEDS.BITMAP_EXTENSION, addressEncoder.encode(poolState)]
     });
   }
@@ -5731,9 +5756,10 @@ var PdaUtils = class {
    * @param tickUpper - Upper tick of range
    * @param tickSpacing - Tick spacing of the pool
    * @param tickCurrent - Current pool tick
+   * @param programId - Program address (defaults to production)
    * @returns Array of tick array PDAs
    */
-  static async getTickArrayPdasForRange(poolState, tickLower, tickUpper, tickSpacing, tickCurrent) {
+  static async getTickArrayPdasForRange(poolState, tickLower, tickUpper, tickSpacing, tickCurrent, programId = STABBLE_CLMM_PROGRAM_ID) {
     const startIndexLower = this.getTickArrayStartIndex(tickLower, tickSpacing);
     const startIndexUpper = this.getTickArrayStartIndex(tickUpper, tickSpacing);
     const startIndexCurrent = this.getTickArrayStartIndex(
@@ -5747,7 +5773,7 @@ var PdaUtils = class {
     ]);
     return await Promise.all(
       Array.from(indices).map(
-        (index) => this.getTickArrayStatePda(poolState, index)
+        (index) => this.getTickArrayStatePda(poolState, index, programId)
       )
     );
   }
@@ -5756,11 +5782,12 @@ var PdaUtils = class {
    * @param poolState - Pool state address
    * @param tickLowerIndex - Lower tick index
    * @param tickUpperIndex - Upper tick index
+   * @param programId - Program address (defaults to production)
    * @returns Protocol position state PDA
    */
-  static async getProtocolPositionStatePda(poolState, tickLowerIndex, tickUpperIndex) {
+  static async getProtocolPositionStatePda(poolState, tickLowerIndex, tickUpperIndex, programId = STABBLE_CLMM_PROGRAM_ID) {
     return await (0, import_kit50.getProgramDerivedAddress)({
-      programAddress: STABBLE_CLMM_PROGRAM_ID,
+      programAddress: programId,
       seeds: [
         PDA_SEEDS.POSITION_STATE,
         addressEncoder.encode(poolState),
@@ -5772,11 +5799,12 @@ var PdaUtils = class {
   /**
    * Derive operation state PDA
    * @param poolState - Pool state address
+   * @param programId - Program address (defaults to production)
    * @returns Operation state PDA
    */
-  static async getOperationStatePda(poolState) {
+  static async getOperationStatePda(poolState, programId = STABBLE_CLMM_PROGRAM_ID) {
     return await (0, import_kit50.getProgramDerivedAddress)({
-      programAddress: STABBLE_CLMM_PROGRAM_ID,
+      programAddress: programId,
       seeds: [PDA_SEEDS.OPERATION, addressEncoder.encode(poolState)]
     });
   }
@@ -5795,7 +5823,7 @@ async function getMetadataPda(mint) {
 // src/utils/tickQuery.ts
 var FETCH_TICKARRAY_COUNT = 15;
 var TickQuery = class _TickQuery {
-  static async getTickArrays(rpc, poolId, tickCurrent, tickSpacing, tickArrayBitmapArray, exTickArrayBitmap) {
+  static async getTickArrays(rpc, poolId, tickCurrent, tickSpacing, tickArrayBitmapArray, exTickArrayBitmap, programId = STABBLE_CLMM_PROGRAM_ID) {
     const tickArraysToFetch = [];
     const currentTickArrayStartIndex = TickUtils.getTickArrayStartIndexByTick(
       tickCurrent,
@@ -5811,7 +5839,8 @@ var TickQuery = class _TickQuery {
     for (let i = 0; i < startIndexArray.length; i++) {
       const [tickArrayAddress] = await PdaUtils.getTickArrayStatePda(
         poolId,
-        startIndexArray[i]
+        startIndexArray[i],
+        programId
       );
       tickArraysToFetch.push(tickArrayAddress);
     }
@@ -5866,7 +5895,7 @@ var TickQuery = class _TickQuery {
    * @param zeroForOne - Search direction
    * @returns First initialized tick, tick array address, and start index
    */
-  static async firstInitializedTickInOneArray(poolId, tickArray, zeroForOne) {
+  static async firstInitializedTickInOneArray(poolId, tickArray, zeroForOne, programId = STABBLE_CLMM_PROGRAM_ID) {
     let nextInitializedTick = void 0;
     if (zeroForOne) {
       for (let i = TICK_ARRAY_SIZE - 1; i >= 0; i--) {
@@ -5887,7 +5916,8 @@ var TickQuery = class _TickQuery {
     }
     const [tickArrayAddress] = await PdaUtils.getTickArrayStatePda(
       poolId,
-      tickArray.data.startTickIndex
+      tickArray.data.startTickIndex,
+      programId
     );
     return {
       nextTick: nextInitializedTick,
@@ -5905,7 +5935,7 @@ var TickQuery = class _TickQuery {
    * @param zeroForOne - Search direction
    * @returns Next initialized tick info
    */
-  static async nextInitializedTickInOneArray(poolId, tickArrayCache, tickIndex, tickSpacing, zeroForOne) {
+  static async nextInitializedTickInOneArray(poolId, tickArrayCache, tickIndex, tickSpacing, zeroForOne, programId = STABBLE_CLMM_PROGRAM_ID) {
     const startIndex = TickUtils.getTickArrayStartIndexByTick(
       tickIndex,
       tickSpacing
@@ -5944,7 +5974,8 @@ var TickQuery = class _TickQuery {
     }
     const [tickArrayAddress] = await PdaUtils.getTickArrayStatePda(
       poolId,
-      startIndex
+      startIndex,
+      programId
     );
     return {
       initializedTick: nextInitializedTick,
@@ -5962,7 +5993,7 @@ var TickQuery = class _TickQuery {
    * @param zeroForOne - Search direction
    * @returns Next initialized tick info
    */
-  static async nextInitializedTick(poolId, tickArrayCache, tickIndex, tickSpacing, zeroForOne) {
+  static async nextInitializedTick(poolId, tickArrayCache, tickIndex, tickSpacing, zeroForOne, programId = STABBLE_CLMM_PROGRAM_ID) {
     let {
       initializedTick: nextTick,
       tickArrayAddress,
@@ -5972,7 +6003,8 @@ var TickQuery = class _TickQuery {
       tickArrayCache,
       tickIndex,
       tickSpacing,
-      zeroForOne
+      zeroForOne,
+      programId
     );
     while (nextTick === void 0 || nextTick.liquidityGross <= 0n) {
       const nextArrayStartIndex = zeroForOne ? tickArrayStartTickIndex - this.tickCount(tickSpacing) : tickArrayStartTickIndex + this.tickCount(tickSpacing);
@@ -5989,7 +6021,8 @@ var TickQuery = class _TickQuery {
       const result = await this.firstInitializedTickInOneArray(
         poolId,
         cachedTickArray,
-        zeroForOne
+        zeroForOne,
+        programId
       );
       nextTick = result.nextTick;
       tickArrayAddress = result.tickArrayAddress;
@@ -7471,6 +7504,268 @@ var PoolUtils = class {
   }
 };
 
+// src/utils/position.ts
+var import_bn5 = __toESM(require("bn.js"));
+var PositionUtils = class _PositionUtils {
+  /**
+   * Calculate fee growth inside a position's tick range.
+   *
+   * formula:
+   * ```
+   * feeGrowthInside = feeGrowthGlobal - feeGrowthBelow - feeGrowthAbove
+   * ```
+   *
+   * Where feeGrowthBelow and feeGrowthAbove depend on the current tick
+   * relative to the position's tick boundaries.
+   *
+   * @param params - Parameters for fee growth calculation
+   * @returns Fee growth inside for both tokens (X64 fixed-point)
+   */
+  static getFeeGrowthInside(params) {
+    const {
+      tickCurrent,
+      tickLower,
+      tickUpper,
+      tickLowerState,
+      tickUpperState,
+      feeGrowthGlobal0X64,
+      feeGrowthGlobal1X64
+    } = params;
+    const feeGrowthGlobal0 = new import_bn5.default(feeGrowthGlobal0X64.toString());
+    const feeGrowthGlobal1 = new import_bn5.default(feeGrowthGlobal1X64.toString());
+    const tickLowerFeeGrowthOutside0 = new import_bn5.default(
+      tickLowerState.feeGrowthOutside0X64.toString()
+    );
+    const tickLowerFeeGrowthOutside1 = new import_bn5.default(
+      tickLowerState.feeGrowthOutside1X64.toString()
+    );
+    const tickUpperFeeGrowthOutside0 = new import_bn5.default(
+      tickUpperState.feeGrowthOutside0X64.toString()
+    );
+    const tickUpperFeeGrowthOutside1 = new import_bn5.default(
+      tickUpperState.feeGrowthOutside1X64.toString()
+    );
+    let feeGrowthBelow0X64;
+    let feeGrowthBelow1X64;
+    if (tickCurrent >= tickLower) {
+      feeGrowthBelow0X64 = tickLowerFeeGrowthOutside0;
+      feeGrowthBelow1X64 = tickLowerFeeGrowthOutside1;
+    } else {
+      feeGrowthBelow0X64 = MathUtils.wrappingSubU128(
+        feeGrowthGlobal0,
+        tickLowerFeeGrowthOutside0
+      );
+      feeGrowthBelow1X64 = MathUtils.wrappingSubU128(
+        feeGrowthGlobal1,
+        tickLowerFeeGrowthOutside1
+      );
+    }
+    let feeGrowthAbove0X64;
+    let feeGrowthAbove1X64;
+    if (tickCurrent < tickUpper) {
+      feeGrowthAbove0X64 = tickUpperFeeGrowthOutside0;
+      feeGrowthAbove1X64 = tickUpperFeeGrowthOutside1;
+    } else {
+      feeGrowthAbove0X64 = MathUtils.wrappingSubU128(
+        feeGrowthGlobal0,
+        tickUpperFeeGrowthOutside0
+      );
+      feeGrowthAbove1X64 = MathUtils.wrappingSubU128(
+        feeGrowthGlobal1,
+        tickUpperFeeGrowthOutside1
+      );
+    }
+    const feeGrowthInside0X64 = MathUtils.wrappingSubU128(
+      MathUtils.wrappingSubU128(feeGrowthGlobal0, feeGrowthBelow0X64),
+      feeGrowthAbove0X64
+    );
+    const feeGrowthInside1X64 = MathUtils.wrappingSubU128(
+      MathUtils.wrappingSubU128(feeGrowthGlobal1, feeGrowthBelow1X64),
+      feeGrowthAbove1X64
+    );
+    return {
+      feeGrowthInside0X64,
+      feeGrowthInside1X64
+    };
+  }
+  /**
+   * Calculate pending fees for a position.
+   *
+   * Formula:
+   * ```
+   * feeDelta = (feeGrowthInside - feeGrowthInsideLast) × liquidity / 2^64
+   * totalFees = tokenFeesOwed + feeDelta
+   * ```
+   *
+   * @param params - Parameters for fee calculation
+   * @returns Pending fees for both tokens in native units
+   */
+  static getPositionFees(params) {
+    const {
+      liquidity,
+      tickLower,
+      tickUpper,
+      feeGrowthInside0LastX64,
+      feeGrowthInside1LastX64,
+      tokenFeesOwed0,
+      tokenFeesOwed1,
+      tickCurrent,
+      feeGrowthGlobal0X64,
+      feeGrowthGlobal1X64,
+      tickLowerState,
+      tickUpperState
+    } = params;
+    const { feeGrowthInside0X64, feeGrowthInside1X64 } = _PositionUtils.getFeeGrowthInside({
+      tickCurrent,
+      tickLower,
+      tickUpper,
+      tickLowerState,
+      tickUpperState,
+      feeGrowthGlobal0X64,
+      feeGrowthGlobal1X64
+    });
+    const liquidityBN = new import_bn5.default(liquidity.toString());
+    const feeGrowthInside0Last = new import_bn5.default(feeGrowthInside0LastX64.toString());
+    const feeGrowthInside1Last = new import_bn5.default(feeGrowthInside1LastX64.toString());
+    const feesOwed0 = new import_bn5.default(tokenFeesOwed0.toString());
+    const feesOwed1 = new import_bn5.default(tokenFeesOwed1.toString());
+    const feeGrowthDelta0 = MathUtils.wrappingSubU128(
+      feeGrowthInside0X64,
+      feeGrowthInside0Last
+    );
+    const feeGrowthDelta1 = MathUtils.wrappingSubU128(
+      feeGrowthInside1X64,
+      feeGrowthInside1Last
+    );
+    const feeAmount0 = MathUtils.mulDivFloor(feeGrowthDelta0, liquidityBN, Q64);
+    const feeAmount1 = MathUtils.mulDivFloor(feeGrowthDelta1, liquidityBN, Q64);
+    return {
+      tokenFees0: feesOwed0.add(feeAmount0),
+      tokenFees1: feesOwed1.add(feeAmount1)
+    };
+  }
+  /**
+   * Calculate reward growth inside a position's tick range for all reward tokens.
+   *
+   * Formula:
+   * ```
+   * rewardGrowthInside = rewardGrowthGlobal - rewardGrowthBelow - rewardGrowthAbove
+   * ```
+   *
+   * Special cases:
+   * - If tickLower has no liquidity (liquidityGross = 0), rewardGrowthBelow = rewardGrowthGlobal
+   * - If tickUpper has no liquidity (liquidityGross = 0), rewardGrowthAbove = 0
+   *
+   * @param params - Parameters for reward growth calculation
+   * @returns Reward growth inside for each reward token (X64 fixed-point)
+   */
+  static getRewardGrowthInside(params) {
+    const {
+      tickCurrent,
+      tickLower,
+      tickUpper,
+      tickLowerState,
+      tickUpperState,
+      rewardInfos
+    } = params;
+    const rewardGrowthsInside = [];
+    for (let i = 0; i < rewardInfos.length; i++) {
+      const rewardGrowthGlobal = new import_bn5.default(
+        rewardInfos[i].rewardGrowthGlobalX64.toString()
+      );
+      let rewardGrowthBelow;
+      if (tickLowerState.liquidityGross === 0n) {
+        rewardGrowthBelow = rewardGrowthGlobal;
+      } else if (tickCurrent < tickLower) {
+        rewardGrowthBelow = rewardGrowthGlobal.sub(
+          new import_bn5.default(tickLowerState.rewardGrowthsOutsideX64[i].toString())
+        );
+      } else {
+        rewardGrowthBelow = new import_bn5.default(
+          tickLowerState.rewardGrowthsOutsideX64[i].toString()
+        );
+      }
+      let rewardGrowthAbove;
+      if (tickUpperState.liquidityGross === 0n) {
+        rewardGrowthAbove = new import_bn5.default(0);
+      } else if (tickCurrent < tickUpper) {
+        rewardGrowthAbove = new import_bn5.default(
+          tickUpperState.rewardGrowthsOutsideX64[i].toString()
+        );
+      } else {
+        rewardGrowthAbove = rewardGrowthGlobal.sub(
+          new import_bn5.default(tickUpperState.rewardGrowthsOutsideX64[i].toString())
+        );
+      }
+      const rewardGrowthInside = MathUtils.wrappingSubU128(
+        MathUtils.wrappingSubU128(rewardGrowthGlobal, rewardGrowthBelow),
+        rewardGrowthAbove
+      );
+      rewardGrowthsInside.push(rewardGrowthInside);
+    }
+    return rewardGrowthsInside;
+  }
+  /**
+   * Calculate pending rewards for a position.
+   *
+   * Formula:
+   * ```
+   * rewardDelta = (rewardGrowthInside - rewardGrowthInsideLast) × liquidity / 2^64
+   * totalReward = rewardAmountOwed + rewardDelta
+   * ```
+   *
+   * @param params - Parameters for reward calculation
+   * @returns Pending rewards for each reward token in native units
+   */
+  static getPositionRewards(params) {
+    const {
+      liquidity,
+      tickLower,
+      tickUpper,
+      positionRewardInfos,
+      tickCurrent,
+      rewardInfos,
+      tickLowerState,
+      tickUpperState
+    } = params;
+    const rewardGrowthsInside = _PositionUtils.getRewardGrowthInside({
+      tickCurrent,
+      tickLower,
+      tickUpper,
+      tickLowerState,
+      tickUpperState,
+      rewardInfos
+    });
+    const liquidityBN = new import_bn5.default(liquidity.toString());
+    const rewards = [];
+    for (let i = 0; i < rewardGrowthsInside.length; i++) {
+      const rewardGrowthInside = rewardGrowthsInside[i];
+      const positionRewardInfo = positionRewardInfos[i];
+      if (!positionRewardInfo) {
+        rewards.push(new import_bn5.default(0));
+        continue;
+      }
+      const growthInsideLast = new import_bn5.default(
+        positionRewardInfo.growthInsideLastX64.toString()
+      );
+      const rewardAmountOwed = new import_bn5.default(
+        positionRewardInfo.rewardAmountOwed.toString()
+      );
+      const rewardGrowthDelta = MathUtils.wrappingSubU128(
+        rewardGrowthInside,
+        growthInsideLast
+      );
+      const rewardAmountDelta = MathUtils.mulDivFloor(
+        rewardGrowthDelta,
+        liquidityBN,
+        Q64
+      );
+      rewards.push(rewardAmountOwed.add(rewardAmountDelta));
+    }
+    return { rewards };
+  }
+};
+
 // src/utils/index.ts
 var import_kit51 = require("@solana/kit");
 function validateAddress(address6, name = "address") {
@@ -7568,7 +7863,9 @@ function getApisFromEndpoint(rpc) {
 var Clmm = class {
   constructor(config) {
     this.config = config;
+    this.programId = config.programAddress ?? STABBLE_CLMM_PROGRAM_ID;
   }
+  programId;
   /**
    * Create a new AMM configuration
    * @param params - Configuration parameters
@@ -7583,7 +7880,7 @@ var Clmm = class {
       protocolFeeRate,
       fundFeeRate
     } = params;
-    const ammConfigPda = await PdaUtils.getAmmConfigPda(index);
+    const ammConfigPda = await PdaUtils.getAmmConfigPda(index, this.programId);
     const instruction = await getCreateAmmConfigInstructionAsync({
       owner,
       ammConfig: ammConfigPda[0],
@@ -7636,7 +7933,7 @@ var Clmm = class {
 // src/pool-manager.ts
 var import_kit52 = require("@solana/kit");
 var import_token2 = require("@solana-program/token");
-var import_bn5 = __toESM(require("bn.js"));
+var import_bn6 = __toESM(require("bn.js"));
 var import_decimal3 = __toESM(require("decimal.js"));
 
 // src/utils/token.ts
@@ -7657,7 +7954,9 @@ async function getToken(rpc, tokenAccount) {
 var PoolManager = class {
   constructor(config) {
     this.config = config;
+    this.programId = config.programAddress ?? STABBLE_CLMM_PROGRAM_ID;
   }
+  programId;
   /**
    * Make create pool instructions
    * @param params - Pool creation parameters
@@ -7675,8 +7974,8 @@ var PoolManager = class {
     } = params;
     const addressA = (0, import_kit52.address)(tokenMintA);
     const addressB = (0, import_kit52.address)(tokenMintB);
-    const isAFirst = new import_bn5.default(Buffer.from(addressB)).gt(
-      new import_bn5.default(Buffer.from(addressA))
+    const isAFirst = new import_bn6.default(Buffer.from(addressB)).gt(
+      new import_bn6.default(Buffer.from(addressA))
     );
     const [token0, token1, decimals0, decimals1, priceAdjusted] = isAFirst ? [tokenMintA, tokenMintB, mintADecimals, mintBDecimals, initialPrice] : [
       tokenMintB,
@@ -7693,12 +7992,13 @@ var PoolManager = class {
     const [poolPda] = await PdaUtils.getPoolStatePda(
       ammConfigId,
       token0,
-      token1
+      token1,
+      this.programId
     );
-    const [observationPda] = await PdaUtils.getObservationStatePda(poolPda);
-    const [tickArrayBitmapPda] = await PdaUtils.getTickArrayBitmapExtensionPda(poolPda);
-    const [tokenVault0] = await PdaUtils.getPoolVaultIdPda(poolPda, token0);
-    const [tokenVault1] = await PdaUtils.getPoolVaultIdPda(poolPda, token1);
+    const [observationPda] = await PdaUtils.getObservationStatePda(poolPda, this.programId);
+    const [tickArrayBitmapPda] = await PdaUtils.getTickArrayBitmapExtensionPda(poolPda, this.programId);
+    const [tokenVault0] = await PdaUtils.getPoolVaultIdPda(poolPda, token0, this.programId);
+    const [tokenVault1] = await PdaUtils.getPoolVaultIdPda(poolPda, token1, this.programId);
     const instruction = await getCreatePoolInstructionAsync({
       poolCreator: owner,
       ammConfig: ammConfigId,
@@ -7743,7 +8043,7 @@ var PoolManager = class {
       protocolFeeRate,
       fundFeeRate
     } = params;
-    const ammConfigPda = await PdaUtils.getAmmConfigPda(index);
+    const ammConfigPda = await PdaUtils.getAmmConfigPda(index, this.programId);
     const instruction = getCreateAmmConfigInstruction({
       owner,
       ammConfig: ammConfigPda[0],
@@ -7795,17 +8095,18 @@ var PoolManager = class {
    * @returns Pool information if found
    */
   async getPoolByTokenPairAndConfig(tokenA, tokenB, ammConfigIndex = 0) {
-    const ammConfigPda = await PdaUtils.getAmmConfigPda(ammConfigIndex);
+    const ammConfigPda = await PdaUtils.getAmmConfigPda(ammConfigIndex, this.programId);
     const poolPda = await PdaUtils.getPoolStatePda(
       ammConfigPda[0],
       tokenA,
-      tokenB
+      tokenB,
+      this.programId
     );
     return this.getPool(poolPda[0]);
   }
   async getAllPools(rpc) {
     try {
-      let accounts = await rpc.getProgramAccounts(STABBLE_CLMM_PROGRAM_ID, {
+      let accounts = await rpc.getProgramAccounts(this.programId, {
         commitment: "finalized",
         encoding: "base64",
         filters: [
@@ -7858,7 +8159,7 @@ var PoolManager = class {
       getToken(this.config.rpc, poolState.tokenVault1)
     ]);
     const currentPrice = this.calculatePoolPrice(
-      new import_bn5.default(poolState.sqrtPriceX64.toString()),
+      new import_bn6.default(poolState.sqrtPriceX64.toString()),
       tokenA.decimals,
       tokenB.decimals
     );
@@ -7903,7 +8204,7 @@ var PoolManager = class {
 var import_kit53 = require("@solana/kit");
 var import_token4 = require("@solana-program/token");
 var import_token_20222 = require("@solana-program/token-2022");
-var import_bn6 = __toESM(require("bn.js"));
+var import_bn7 = __toESM(require("bn.js"));
 
 // ../node_modules/@solana/spl-token/lib/esm/constants.js
 var import_web3 = require("@solana/web3.js");
@@ -7920,7 +8221,9 @@ var TOKEN_ACCOUNT_SIZE = 165n;
 var PositionManager = class {
   constructor(config) {
     this.config = config;
+    this.programId = config.programAddress ?? STABBLE_CLMM_PROGRAM_ID;
   }
+  programId;
   buildWrapSolInstructions(params) {
     const { payer, ata, owner, amount } = params;
     return [
@@ -8022,7 +8325,8 @@ var PositionManager = class {
       poolAccount.data.tickSpacing
     );
     const [positionStatePda] = await PdaUtils.getPositionStatePda(
-      nftMintAccount.address
+      nftMintAccount.address,
+      this.programId
     );
     const [metadataPda] = await getMetadataPda(nftMintAccount.address);
     const [positionNftAccountPda] = await (0, import_token4.findAssociatedTokenPda)({
@@ -8033,7 +8337,8 @@ var PositionManager = class {
     const [protocolPositionPda] = await PdaUtils.getProtocolPositionStatePda(
       poolAccount.address,
       tickLower,
-      tickUpper
+      tickUpper,
+      this.programId
     );
     const instruction = await getOpenPositionWithToken22NftInstructionAsync({
       payer: ownerInfo.feePayer,
@@ -8108,14 +8413,17 @@ var PositionManager = class {
     );
     const [tickArrayLower] = await PdaUtils.getTickArrayStatePda(
       poolAccount.address,
-      tickArrayLowerStartIndex
+      tickArrayLowerStartIndex,
+      this.programId
     );
     const [tickArrayUpper] = await PdaUtils.getTickArrayStatePda(
       poolAccount.address,
-      tickArrayUpperStartIndex
+      tickArrayUpperStartIndex,
+      this.programId
     );
     const [positionStatePda] = await PdaUtils.getPositionStatePda(
-      nftMintAccount.address
+      nftMintAccount.address,
+      this.programId
     );
     const [metadataPda] = await getMetadataPda(nftMintAccount.address);
     const [positionNftAccountPda] = await (0, import_token4.findAssociatedTokenPda)({
@@ -8126,7 +8434,8 @@ var PositionManager = class {
     const [protocolPositionPda] = await PdaUtils.getProtocolPositionStatePda(
       poolAccount.address,
       tickLower,
-      tickUpper
+      tickUpper,
+      this.programId
     );
     const amount0Max = base === "MintA" ? baseAmount : otherAmountMax;
     const amount1Max = base === "MintA" ? otherAmountMax : baseAmount;
@@ -8134,7 +8443,7 @@ var PositionManager = class {
       poolAccount.data.tickSpacing,
       [tickArrayLowerStartIndex, tickArrayUpperStartIndex]
     );
-    const extBitmapAccount = isOverflow ? await PdaUtils.getTickArrayBitmapExtensionPda(poolAccount.address) : void 0;
+    const extBitmapAccount = isOverflow ? await PdaUtils.getTickArrayBitmapExtensionPda(poolAccount.address, this.programId) : void 0;
     const remAccounts = extBitmapAccount ? [{ address: extBitmapAccount[0], role: import_kit53.AccountRole.WRITABLE }] : [];
     let wrapSolInstructions = [];
     if (poolAccount.data.tokenMint0.toString() === NATIVE_MINT.toString()) {
@@ -8210,7 +8519,8 @@ var PositionManager = class {
       amountMaxB
     } = params;
     const [personalPosition] = await PdaUtils.getPositionStatePda(
-      ownerPosition.nftMint
+      ownerPosition.nftMint,
+      this.programId
     );
     const [positionNftAccount] = await (0, import_token4.findAssociatedTokenPda)({
       mint: ownerPosition.nftMint,
@@ -8220,27 +8530,30 @@ var PositionManager = class {
     const [protocolPositionPda] = await PdaUtils.getProtocolPositionStatePda(
       poolState.address,
       ownerPosition.tickLowerIndex,
-      ownerPosition.tickUpperIndex
+      ownerPosition.tickUpperIndex,
+      this.programId
     );
     const [tickArrayLower] = await PdaUtils.getTickArrayStatePda(
       poolState.address,
       PdaUtils.getTickArrayStartIndex(
         ownerPosition.tickLowerIndex,
         poolState.data.tickSpacing
-      )
+      ),
+      this.programId
     );
     const [tickArrayUpper] = await PdaUtils.getTickArrayStatePda(
       poolState.address,
       PdaUtils.getTickArrayStartIndex(
         ownerPosition.tickUpperIndex,
         poolState.data.tickSpacing
-      )
+      ),
+      this.programId
     );
     const isOverflow = PoolUtils.isOverflowDefaultTickArrayBitmap(
       poolState.data.tickSpacing,
       [ownerPosition.tickLowerIndex, ownerPosition.tickUpperIndex]
     );
-    const extBitmapAccount = isOverflow ? await PdaUtils.getTickArrayBitmapExtensionPda(poolState.address) : void 0;
+    const extBitmapAccount = isOverflow ? await PdaUtils.getTickArrayBitmapExtensionPda(poolState.address, this.programId) : void 0;
     const remAccounts = extBitmapAccount ? [{ address: extBitmapAccount[0], role: import_kit53.AccountRole.WRITABLE }] : [];
     const instruction = getIncreaseLiquidityV2Instruction({
       nftOwner: ownerInfo.wallet,
@@ -8298,7 +8611,8 @@ var PositionManager = class {
     } = params;
     const signers = [];
     const [personalPosition] = await PdaUtils.getPositionStatePda(
-      ownerPosition.nftMint
+      ownerPosition.nftMint,
+      this.programId
     );
     const [positionNftAccount] = await (0, import_token4.findAssociatedTokenPda)({
       mint: ownerPosition.nftMint,
@@ -8308,27 +8622,30 @@ var PositionManager = class {
     const [protocolPositionPda] = await PdaUtils.getProtocolPositionStatePda(
       poolState.address,
       ownerPosition.tickLowerIndex,
-      ownerPosition.tickUpperIndex
+      ownerPosition.tickUpperIndex,
+      this.programId
     );
     const [tickArrayLower] = await PdaUtils.getTickArrayStatePda(
       poolState.address,
       PdaUtils.getTickArrayStartIndex(
         ownerPosition.tickLowerIndex,
         poolState.data.tickSpacing
-      )
+      ),
+      this.programId
     );
     const [tickArrayUpper] = await PdaUtils.getTickArrayStatePda(
       poolState.address,
       PdaUtils.getTickArrayStartIndex(
         ownerPosition.tickUpperIndex,
         poolState.data.tickSpacing
-      )
+      ),
+      this.programId
     );
     const isOverflow = PoolUtils.isOverflowDefaultTickArrayBitmap(
       poolState.data.tickSpacing,
       [ownerPosition.tickLowerIndex, ownerPosition.tickUpperIndex]
     );
-    const extBitmapAccount = isOverflow ? await PdaUtils.getTickArrayBitmapExtensionPda(poolState.address) : void 0;
+    const extBitmapAccount = isOverflow ? await PdaUtils.getTickArrayBitmapExtensionPda(poolState.address, this.programId) : void 0;
     const remAccounts = extBitmapAccount ? [{ address: extBitmapAccount[0], role: import_kit53.AccountRole.WRITABLE }] : [];
     const createRecipientAta0Ix = (0, import_token4.getCreateAssociatedTokenIdempotentInstruction)(
       {
@@ -8411,7 +8728,8 @@ var PositionManager = class {
   async makeClosePositionInstructions(params) {
     const { ownerPosition, ownerInfo } = params;
     const [personalPosition] = await PdaUtils.getPositionStatePda(
-      ownerPosition.nftMint
+      ownerPosition.nftMint,
+      this.programId
     );
     const [positionNftAccount] = await (0, import_token4.findAssociatedTokenPda)({
       mint: ownerPosition.nftMint,
@@ -8440,7 +8758,7 @@ var PositionManager = class {
    */
   async getPosition(positionMint) {
     try {
-      const positionStatePda = await PdaUtils.getPositionStatePda(positionMint);
+      const positionStatePda = await PdaUtils.getPositionStatePda(positionMint, this.programId);
       const positionState = await fetchMaybePersonalPositionState(
         this.config.rpc,
         positionStatePda[0],
@@ -8461,21 +8779,22 @@ var PositionManager = class {
    * Enrich position state with computed fields from pool data
    * @param position - Raw position state from blockchain
    * @param pool - Pool state from blockchain
+   * @param fees - Position fees
    * @returns Enriched position info with calculated amounts and prices
    */
-  enrichPositionInfo(position, pool) {
+  enrichPositionInfo(position, pool, fees, rewards) {
     const sqrtPriceLowerX64 = SqrtPriceMath.getSqrtPriceX64FromTick(
       position.tickLowerIndex
     );
     const sqrtPriceUpperX64 = SqrtPriceMath.getSqrtPriceX64FromTick(
       position.tickUpperIndex
     );
-    const sqrtPriceCurrentX64 = new import_bn6.default(pool.sqrtPriceX64.toString());
+    const sqrtPriceCurrentX64 = new import_bn7.default(pool.sqrtPriceX64.toString());
     const { amountA, amountB } = LiquidityMath.getAmountsFromLiquidity(
       sqrtPriceCurrentX64,
       sqrtPriceLowerX64,
       sqrtPriceUpperX64,
-      new import_bn6.default(position.liquidity.toString()),
+      new import_bn7.default(position.liquidity.toString()),
       true
     );
     const [_amountA, _amountB] = [
@@ -8496,9 +8815,13 @@ var PositionManager = class {
     });
     const inRange = pool.tickCurrent >= position.tickLowerIndex && pool.tickCurrent < position.tickUpperIndex;
     const unclaimedFees = {
-      token0: new import_bn6.default(position.tokenFeesOwed0.toString()),
-      token1: new import_bn6.default(position.tokenFeesOwed1.toString())
+      token0: fees?.tokenFees0 ? fees?.tokenFees0 : new import_bn7.default(0),
+      token1: fees?.tokenFees1 ? fees?.tokenFees1 : new import_bn7.default(0)
     };
+    const unclaimedRewards = rewards?.rewards ? rewards.rewards.map((amount, i) => ({
+      mint: pool.rewardInfos[i]?.tokenMint,
+      amount
+    })).filter((r) => r.mint !== void 0) : void 0;
     const ageSeconds = 0;
     return {
       ...position,
@@ -8511,18 +8834,16 @@ var PositionManager = class {
       inRange,
       ageSeconds,
       unclaimedFees,
-      // valueUsd is optional and requires external price feeds
-      valueUsd: void 0,
-      // unclaimedRewards is optional
-      unclaimedRewards: void 0
+      unclaimedRewards,
+      valueUsd: void 0
     };
   }
   /**
-   * Get all positions for a wallet
+   * Get raw positions for a wallet (without pool-state enrichment)
    * @param wallet - Wallet address
-   * @returns Array of positions owned by the wallet
+   * @returns Array of raw position states owned by the wallet
    */
-  async getPositionsForWallet(wallet) {
+  async getRawPositionsForWallet(wallet) {
     try {
       const response22 = await this.config.rpc.getTokenAccountsByOwner(
         wallet,
@@ -8539,29 +8860,7 @@ var PositionManager = class {
           (ta) => this.getPosition(ta.account.data.parsed.info.mint)
         )
       );
-      const validPositions = positions.filter(
-        (p) => !!p
-      );
-      const enrichedPositions = await Promise.all(
-        validPositions.map(async (position) => {
-          try {
-            const poolAccount = await fetchMaybePoolState(
-              this.config.rpc,
-              position.poolId,
-              { commitment: this.config.commitment }
-            );
-            if (!poolAccount.exists) {
-              console.warn(`Pool ${position.poolId} not found for position`);
-              return null;
-            }
-            return this.enrichPositionInfo(position, poolAccount.data);
-          } catch (error) {
-            console.error(`Failed to enrich position: ${error}`);
-            return null;
-          }
-        })
-      );
-      return enrichedPositions.filter((p) => !!p);
+      return positions.filter((p) => !!p);
     } catch (error) {
       throw new ClmmError(
         "POSITION_NOT_FOUND" /* POSITION_NOT_FOUND */,
@@ -8569,6 +8868,146 @@ var PositionManager = class {
       );
     }
   }
+  /**
+   * Get all positions for a wallet, enriched with pool data
+   * @param wallet - Wallet address
+   * @returns Structured result with enriched positions and any failures
+   */
+  async getPositionsForWallet(wallet) {
+    const rawPositions = await this.getRawPositionsForWallet(wallet);
+    const results = await Promise.allSettled(
+      rawPositions.map(async (position) => {
+        const poolAccount = await fetchMaybePoolState(
+          this.config.rpc,
+          position.poolId,
+          { commitment: this.config.commitment }
+        );
+        if (!poolAccount.exists) {
+          throw new Error(`Pool ${position.poolId} not found for position`);
+        }
+        const { fees, rewards } = await this.getPositionFeeAndRewards(
+          position,
+          poolAccount.data
+        );
+        return this.enrichPositionInfo(
+          position,
+          poolAccount.data,
+          fees,
+          rewards
+        );
+      })
+    );
+    const positions = [];
+    const failed = [];
+    results.forEach((result, index) => {
+      if (result.status === "fulfilled") {
+        positions.push(result.value);
+      } else {
+        failed.push({
+          position: rawPositions[index],
+          error: result.reason instanceof Error ? result.reason : new Error(String(result.reason))
+        });
+      }
+    });
+    return { positions, failed };
+  }
+  /**
+   * Calculate pending fees and rewards for a position.
+   *
+   * @param position - Personal position state
+   * @param pool - Pool state
+   * @returns Pending fees for both tokens and rewards for each reward token (up to 3)
+   */
+  async getPositionFeeAndRewards(position, pool) {
+    const [tickArrayLower] = await PdaUtils.getTickArrayStatePda(
+      position.poolId,
+      PdaUtils.getTickArrayStartIndex(
+        position.tickLowerIndex,
+        pool.tickSpacing
+      ),
+      this.programId
+    );
+    const [tickArrayUpper] = await PdaUtils.getTickArrayStatePda(
+      position.poolId,
+      PdaUtils.getTickArrayStartIndex(
+        position.tickUpperIndex,
+        pool.tickSpacing
+      ),
+      this.programId
+    );
+    const tickArrayLowerAccount = await fetchMaybeTickArrayState(
+      this.config.rpc,
+      tickArrayLower
+    );
+    const tickArrayUpperAccount = await fetchMaybeTickArrayState(
+      this.config.rpc,
+      tickArrayUpper
+    );
+    if (!tickArrayLowerAccount.exists || !tickArrayUpperAccount.exists) {
+      console.log(
+        "[getPositionFeeAndRewards] tick array state accounts do not exist."
+      );
+      return {
+        fees: { tokenFees0: new import_bn7.default(0), tokenFees1: new import_bn7.default(0) },
+        rewards: { rewards: [new import_bn7.default(0), new import_bn7.default(0), new import_bn7.default(0)] }
+      };
+    }
+    const tickSpacing = pool.tickSpacing;
+    const tickArrayLowerIndex = TickUtils.getTickOffsetInArray(
+      position.tickLowerIndex,
+      tickSpacing
+    );
+    const tickArrayUpperIndex = TickUtils.getTickOffsetInArray(
+      position.tickUpperIndex,
+      tickSpacing
+    );
+    if (tickArrayLowerIndex < 0 || tickArrayUpperIndex < 0) {
+      console.log("[getPositionFeeAndRewards] tick array indexes < 0.");
+      return {
+        fees: { tokenFees0: new import_bn7.default(0), tokenFees1: new import_bn7.default(0) },
+        rewards: { rewards: [new import_bn7.default(0), new import_bn7.default(0), new import_bn7.default(0)] }
+      };
+    }
+    const lowerTickState = tickArrayLowerAccount.data.ticks[tickArrayLowerIndex];
+    const upperTickState = tickArrayUpperAccount.data.ticks[tickArrayUpperIndex];
+    const fees = PositionUtils.getPositionFees({
+      liquidity: position.liquidity,
+      tickLower: position.tickLowerIndex,
+      tickUpper: position.tickUpperIndex,
+      feeGrowthInside0LastX64: position.feeGrowthInside0LastX64,
+      feeGrowthInside1LastX64: position.feeGrowthInside1LastX64,
+      tokenFeesOwed0: position.tokenFeesOwed0,
+      tokenFeesOwed1: position.tokenFeesOwed1,
+      tickCurrent: pool.tickCurrent,
+      feeGrowthGlobal0X64: pool.feeGrowthGlobal0X64,
+      feeGrowthGlobal1X64: pool.feeGrowthGlobal1X64,
+      tickLowerState: {
+        feeGrowthOutside0X64: lowerTickState.feeGrowthOutside0X64,
+        feeGrowthOutside1X64: lowerTickState.feeGrowthOutside1X64
+      },
+      tickUpperState: {
+        feeGrowthOutside0X64: upperTickState.feeGrowthOutside0X64,
+        feeGrowthOutside1X64: upperTickState.feeGrowthOutside1X64
+      }
+    });
+    const rewards = PositionUtils.getPositionRewards({
+      liquidity: position.liquidity,
+      tickLower: position.tickLowerIndex,
+      tickUpper: position.tickUpperIndex,
+      positionRewardInfos: position.rewardInfos,
+      tickCurrent: pool.tickCurrent,
+      rewardInfos: pool.rewardInfos,
+      tickLowerState: {
+        liquidityGross: lowerTickState.liquidityGross,
+        rewardGrowthsOutsideX64: lowerTickState.rewardGrowthsOutsideX64
+      },
+      tickUpperState: {
+        liquidityGross: upperTickState.liquidityGross,
+        rewardGrowthsOutsideX64: upperTickState.rewardGrowthsOutsideX64
+      }
+    });
+    return { fees, rewards };
+  }
 };
 
 // src/api/config.ts
@@ -9540,7 +9979,7 @@ var PriceApiClient = class _PriceApiClient {
 };
 
 // src/swap.ts
-var import_bn7 = __toESM(require("bn.js"));
+var import_bn8 = __toESM(require("bn.js"));
 var import_decimal6 = __toESM(require("decimal.js"));
 var DEFAULT_RETRY_CONFIG = {
   maxRetries: 3,
@@ -9600,7 +10039,7 @@ var SwapMathEngine = class {
       slippageTolerance,
       poolAddress
     } = params;
-    if (amountIn.lte(new import_bn7.default(0))) {
+    if (amountIn.lte(new import_bn8.default(0))) {
       throw new ClmmError(
         "SWAP_AMOUNT_CANNOT_BE_ZERO" /* SWAP_AMOUNT_CANNOT_BE_ZERO */,
         "Swap amount must be greater than zero"
@@ -9612,8 +10051,8 @@ var SwapMathEngine = class {
         `Slippage tolerance must be between 0 and 1, got ${slippageTolerance}`
       );
     }
-    const liquidity = new import_bn7.default(pool.liquidity.toString());
-    const sqrtPriceCurrentX64 = new import_bn7.default(pool.sqrtPriceX64.toString());
+    const liquidity = new import_bn8.default(pool.liquidity.toString());
+    const sqrtPriceCurrentX64 = new import_bn8.default(pool.sqrtPriceX64.toString());
     const feeRate = ammConfig.tradeFeeRate;
     const sqrtPriceTargetX64 = this.calculateSqrtPriceLimit(
       sqrtPriceCurrentX64,
@@ -9641,9 +10080,9 @@ var SwapMathEngine = class {
       pool.mintDecimals1
     );
     const priceImpact = priceAfter.minus(priceBefore).div(priceBefore).abs().toNumber();
-    const slippageBN = new import_bn7.default(Math.floor(slippageTolerance * 1e4));
+    const slippageBN = new import_bn8.default(Math.floor(slippageTolerance * 1e4));
     const minAmountOut = step.amountOut.sub(
-      step.amountOut.mul(slippageBN).div(new import_bn7.default(1e4))
+      step.amountOut.mul(slippageBN).div(new import_bn8.default(1e4))
     );
     return {
       amountIn,
@@ -9690,17 +10129,17 @@ var SwapMathEngine = class {
       tickArrayCache
     } = params;
     const sqrtPriceLimitX64 = this.calculateSqrtPriceLimit(
-      new import_bn7.default(pool.sqrtPriceX64.toString()),
+      new import_bn8.default(pool.sqrtPriceX64.toString()),
       zeroForOne,
       slippageTolerance
     );
     const result = await SwapMath.swapCompute({
       poolState: {
-        sqrtPriceX64: new import_bn7.default(pool.sqrtPriceX64.toString()),
+        sqrtPriceX64: new import_bn8.default(pool.sqrtPriceX64.toString()),
         tickCurrent: pool.tickCurrent,
-        liquidity: new import_bn7.default(pool.liquidity.toString()),
-        feeGrowthGlobal0X64: new import_bn7.default(pool.feeGrowthGlobal0X64.toString()),
-        feeGrowthGlobal1X64: new import_bn7.default(pool.feeGrowthGlobal1X64.toString())
+        liquidity: new import_bn8.default(pool.liquidity.toString()),
+        feeGrowthGlobal0X64: new import_bn8.default(pool.feeGrowthGlobal0X64.toString()),
+        feeGrowthGlobal1X64: new import_bn8.default(pool.feeGrowthGlobal1X64.toString())
       },
       tickArrayCache,
       tickSpacing: pool.tickSpacing,
@@ -9717,7 +10156,7 @@ var SwapMathEngine = class {
       poolId: poolAddress
     });
     const priceBefore = SqrtPriceMath.sqrtPriceX64ToPrice(
-      new import_bn7.default(pool.sqrtPriceX64.toString()),
+      new import_bn8.default(pool.sqrtPriceX64.toString()),
       pool.mintDecimals0,
       pool.mintDecimals1
     );
@@ -9727,9 +10166,9 @@ var SwapMathEngine = class {
       pool.mintDecimals1
     );
     const priceImpact = priceAfter.minus(priceBefore).div(priceBefore).abs().toNumber();
-    const slippageBN = new import_bn7.default(Math.floor(slippageTolerance * 1e4));
+    const slippageBN = new import_bn8.default(Math.floor(slippageTolerance * 1e4));
     const minAmountOut = result.amountOut.sub(
-      result.amountOut.mul(slippageBN).div(new import_bn7.default(1e4))
+      result.amountOut.mul(slippageBN).div(new import_bn8.default(1e4))
     );
     const feeImpact = ammConfig.tradeFeeRate / FEE_RATE_DENOMINATOR_NUMBER;
     return {
@@ -9773,10 +10212,10 @@ var SwapMathEngine = class {
    */
   calculateSqrtPriceLimit(sqrtPriceX64, zeroForOne, slippageTolerance) {
     const bps = Math.floor(slippageTolerance * 1e4);
-    const base = new import_bn7.default(1e4);
-    const scaled = zeroForOne ? sqrtPriceX64.mul(base.sub(new import_bn7.default(bps))).div(base) : sqrtPriceX64.mul(base.add(new import_bn7.default(bps))).div(base);
-    const min2 = new import_bn7.default(MIN_SQRT_PRICE_X64);
-    const max = new import_bn7.default(MAX_SQRT_PRICE_X64);
+    const base = new import_bn8.default(1e4);
+    const scaled = zeroForOne ? sqrtPriceX64.mul(base.sub(new import_bn8.default(bps))).div(base) : sqrtPriceX64.mul(base.add(new import_bn8.default(bps))).div(base);
+    const min2 = new import_bn8.default(MIN_SQRT_PRICE_X64);
+    const max = new import_bn8.default(MAX_SQRT_PRICE_X64);
     if (scaled.lt(min2)) return min2;
     if (scaled.gt(max)) return max;
     return scaled;
@@ -9869,6 +10308,7 @@ var SwapManager = class {
   constructor(config, managerConfig) {
     this.config = config;
     this.managerConfig = managerConfig;
+    this.programId = config.programAddress ?? STABBLE_CLMM_PROGRAM_ID;
     this.poolDataManager = new PoolDataManager(config, {
       cacheTTL: 2e3,
       immutability: "freeze",
@@ -9889,6 +10329,7 @@ var SwapManager = class {
       );
     }
   }
+  programId;
   poolDataManager;
   mathEngine;
   priceApiClient;
@@ -10200,7 +10641,7 @@ var SwapManager = class {
         `Invalid slippage tolerance: ${slippageTolerance}. Must be between 0 and 1.`
       );
     }
-    if (amountIn.lte(new import_bn7.default(0))) {
+    if (amountIn.lte(new import_bn8.default(0))) {
       throw new ClmmError(
         "SWAP_AMOUNT_CANNOT_BE_ZERO" /* SWAP_AMOUNT_CANNOT_BE_ZERO */,
         "Swap amount must be greater than zero."
@@ -10302,7 +10743,7 @@ var SwapManager = class {
         `Invalid slippage tolerance: ${slippageTolerance}. Must be between 0 and 1.`
       );
     }
-    if (amountIn.lte(new import_bn7.default(0))) {
+    if (amountIn.lte(new import_bn8.default(0))) {
       throw new ClmmError(
         "SWAP_AMOUNT_CANNOT_BE_ZERO" /* SWAP_AMOUNT_CANNOT_BE_ZERO */,
         "Swap amount must be greater than zero."
@@ -10356,7 +10797,7 @@ var SwapManager = class {
         poolAddress
       });
       const priceBefore = SqrtPriceMath.sqrtPriceX64ToPrice(
-        new import_bn7.default(pool.sqrtPriceX64.toString()),
+        new import_bn8.default(pool.sqrtPriceX64.toString()),
         pool.mintDecimals0,
         pool.mintDecimals1
       );
@@ -10466,21 +10907,21 @@ var SwapManager = class {
    * @returns Number of tick arrays to fetch (includes safety buffer)
    */
   estimateTickArrayCount(pool, amountIn) {
-    const liquidity = new import_bn7.default(pool.liquidity.toString());
-    if (liquidity.eq(new import_bn7.default(0)) || liquidity.lt(new import_bn7.default(1e3))) {
+    const liquidity = new import_bn8.default(pool.liquidity.toString());
+    if (liquidity.eq(new import_bn8.default(0)) || liquidity.lt(new import_bn8.default(1e3))) {
       return 10;
     }
-    const roughImpact = amountIn.mul(new import_bn7.default(1e3)).div(liquidity);
+    const roughImpact = amountIn.mul(new import_bn8.default(1e3)).div(liquidity);
     let baseArrays;
-    if (roughImpact.lte(new import_bn7.default(1))) {
+    if (roughImpact.lte(new import_bn8.default(1))) {
       baseArrays = 2;
-    } else if (roughImpact.lte(new import_bn7.default(10))) {
+    } else if (roughImpact.lte(new import_bn8.default(10))) {
       baseArrays = 4;
-    } else if (roughImpact.lte(new import_bn7.default(50))) {
+    } else if (roughImpact.lte(new import_bn8.default(50))) {
       baseArrays = 6;
-    } else if (roughImpact.lte(new import_bn7.default(100))) {
+    } else if (roughImpact.lte(new import_bn8.default(100))) {
       baseArrays = 8;
-    } else if (roughImpact.lte(new import_bn7.default(200))) {
+    } else if (roughImpact.lte(new import_bn8.default(200))) {
       baseArrays = 12;
     } else {
       baseArrays = 15;
@@ -10499,7 +10940,8 @@ var SwapManager = class {
       const startIndex = currentStartIndex + offset * TICKS_PER_ARRAY * tickSpacing;
       const [tickArrayPda] = await PdaUtils.getTickArrayStatePda(
         poolAddress,
-        startIndex
+        startIndex,
+        this.programId
       );
       tickArrayAddresses.push(tickArrayPda);
     }
@@ -10525,7 +10967,7 @@ var SwapManager = class {
     const decOut = zeroForOne ? pool.mintDecimals1 : pool.mintDecimals0;
     const promises = params.amounts.map(async (amountIn) => {
       try {
-        if (amountIn.lte(new import_bn7.default(0))) return;
+        if (amountIn.lte(new import_bn8.default(0))) return;
         const quote = await this.mathEngine.calculateSimpleSwap({
           pool,
           ammConfig,
@@ -10567,7 +11009,7 @@ var SwapManager = class {
       options
     );
     const priceBefore = SqrtPriceMath.sqrtPriceX64ToPrice(
-      new import_bn7.default(pool.sqrtPriceX64.toString()),
+      new import_bn8.default(pool.sqrtPriceX64.toString()),
       pool.mintDecimals0,
       pool.mintDecimals1
     );
@@ -10690,13 +11132,13 @@ var SwapManager = class {
           `Extremely high price impact: ${(quote.priceImpact * 100).toFixed(2)}%. Swap likely to fail or result in significant slippage.`
         );
       }
-      const oneUnit = new import_bn7.default(10).pow(new import_bn7.default(outputDecimals));
+      const oneUnit = new import_bn8.default(10).pow(new import_bn8.default(outputDecimals));
       if (quote.amountOut.lt(oneUnit)) {
         warnings.push(
           `Output amount is less than 1 unit of the output token. Consider increasing input amount or slippage tolerance.`
         );
       }
-      if (quote.amountOut.lte(new import_bn7.default(0))) {
+      if (quote.amountOut.lte(new import_bn8.default(0))) {
         errors.push(
           "Swap would result in zero output. Amount may be too small."
         );
@@ -10717,11 +11159,11 @@ var SwapManager = class {
       return {
         quote: {
           amountIn: params.amountIn,
-          amountOut: new import_bn7.default(0),
-          minAmountOut: new import_bn7.default(0),
+          amountOut: new import_bn8.default(0),
+          minAmountOut: new import_bn8.default(0),
           priceImpact: 0,
           route: [],
-          fee: new import_bn7.default(0)
+          fee: new import_bn8.default(0)
         },
         willSucceed: false,
         errors,
@@ -10809,7 +11251,7 @@ var SwapManager = class {
     }
     const pool = await this.poolDataManager.getPoolState(poolAddress, options);
     const zeroForOne = params.tokenIn === pool.tokenMint0;
-    const [observationState] = await PdaUtils.getObservationStatePda(poolAddress);
+    const [observationState] = await PdaUtils.getObservationStatePda(poolAddress, this.programId);
     const [inputTokenAccount] = await (0, import_token5.findAssociatedTokenPda)({
       mint: params.tokenIn,
       owner: payer.address,
@@ -10821,7 +11263,7 @@ var SwapManager = class {
       tokenProgram: import_token5.TOKEN_PROGRAM_ADDRESS
     });
     const sqrtPriceLimitX64 = params.sqrtPriceLimitX64 || this.mathEngine.calculateSqrtPriceLimit(
-      new import_bn7.default(pool.sqrtPriceX64.toString()),
+      new import_bn8.default(pool.sqrtPriceX64.toString()),
       zeroForOne,
       params.slippageTolerance || DEFAULT_SLIPPAGE_TOLERANCE
     );
@@ -10846,7 +11288,7 @@ var SwapManager = class {
   async getCurrentPrice(poolAddress, options) {
     const pool = await this.poolDataManager.getPoolState(poolAddress, options);
     return SqrtPriceMath.sqrtPriceX64ToPrice(
-      new import_bn7.default(pool.sqrtPriceX64.toString()),
+      new import_bn8.default(pool.sqrtPriceX64.toString()),
       pool.mintDecimals0,
       pool.mintDecimals1
     );
@@ -11059,11 +11501,13 @@ var DEFAULT_SDK_CONFIG = {
   PoolManager,
   PoolUtils,
   PositionManager,
+  PositionUtils,
   PriceApiClient,
   Q128,
   Q64,
   SLIPPAGE_CALC,
   STABBLE_CLMM_PROGRAM_ID,
+  STABBLE_CLMM_QAS_PROGRAM_ID,
   SYSTEM_PROGRAM_ID,
   SYSVAR_RENT_PROGRAM_ID,
   SqrtPriceMath,