@magmaprotocol/magma-clmm-sdk 0.3.1 → 0.4.0

package/dist/index.js

@@ -68,6 +68,7 @@ __export(src_exports, {
   GAS_SYMBOL: () => GAS_SYMBOL,
   GAS_TYPE_ARG: () => GAS_TYPE_ARG,
   GAS_TYPE_ARG_LONG: () => GAS_TYPE_ARG_LONG,
+  LockModule: () => LockModule,
   MAX_SQRT_PRICE: () => MAX_SQRT_PRICE,
   MAX_TICK_INDEX: () => MAX_TICK_INDEX,
   MIN_SQRT_PRICE: () => MIN_SQRT_PRICE,
@@ -81,6 +82,7 @@ __export(src_exports, {
   PositionModule: () => PositionModule,
   PositionStatus: () => PositionStatus,
   PositionUtil: () => PositionUtil,
+  RewardDistributor: () => RewardDistributor,
   RouterModule: () => RouterModule,
   RouterModuleV2: () => RouterModuleV2,
   RpcModule: () => RpcModule,
@@ -100,6 +102,8 @@ __export(src_exports, {
   U128: () => U128,
   U128_MAX: () => U128_MAX,
   U64_MAX: () => U64_MAX,
+  Voter: () => Voter,
+  VotingEscrow: () => VotingEscrow,
   ZERO: () => ZERO,
   addHexPrefix: () => addHexPrefix,
   adjustForCoinSlippage: () => adjustForCoinSlippage,
@@ -497,6 +501,9 @@ var ClmmIntegrateRouterWithPartnerModule = "router_with_partner";
 var ClmmFetcherModule = "fetcher_script";
 var ClmmExpectSwapModule = "expect_swap";
 var ClmmIntegrateUtilsModule = "utils";
+var VotingEscrow = "voting_escrow";
+var Voter = "voter";
+var RewardDistributor = "reward_distributor";
 var CoinInfoAddress = "0x1::coin::CoinInfo";
 var CoinStoreAddress = "0x1::coin::CoinStore";
 var DeepbookCustodianV2Moudle = "custodian_v2";
@@ -2953,6 +2960,246 @@ var _TransactionUtil = class {
     tx = _TransactionUtil.buildSwapTransactionArgs(tx, params, sdk.sdkOptions, primaryCoinInputA, primaryCoinInputB);
     return tx;
   }
+  static buildCreateLockTransaction(sdk, params, allCoinAsset) {
+    let tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    const { magma_token } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const lockCoinInput = _TransactionUtil.buildCoinForAmount(tx, allCoinAsset, BigInt(params.amount), magma_token, false, true);
+    tx = _TransactionUtil.buildCreateTransactionArgs(tx, params, sdk.sdkOptions, lockCoinInput);
+    return tx;
+  }
+  static buildCreateTransactionArgs(tx, params, sdkOptions, lockCoinInput) {
+    const { integrate } = sdkOptions;
+    const { voting_escrow_id, magma_token } = getPackagerConfigs(sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const functionName = "create_lock";
+    const coins = tx.makeMoveVec({ elements: [lockCoinInput.targetCoin] });
+    const args = [
+      tx.object(voting_escrow_id),
+      coins,
+      tx.pure.u64(params.lockDurationDays),
+      tx.pure.bool(params.permanent),
+      tx.object(CLOCK_ADDRESS)
+    ];
+    tx.moveCall({
+      target: `${integrate.published_at}::${VotingEscrow}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  static buildIncreaseLockAmountTransaction(sdk, params, allCoinAsset) {
+    const { magma_token } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    let tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    const lockCoinInput = _TransactionUtil.buildCoinForAmount(tx, allCoinAsset, BigInt(params.amount), magma_token, false, true);
+    tx = _TransactionUtil.buildIncreaseLockAmountTransactionArgs(tx, params, sdk.sdkOptions, lockCoinInput);
+    return tx;
+  }
+  static buildIncreaseLockAmountTransactionArgs(tx, params, sdkOptions, increaseCoinInput) {
+    const { integrate } = sdkOptions;
+    const { voting_escrow_id, magma_token } = getPackagerConfigs(sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const functionName = "increase_amount_single_coin";
+    const args = [tx.object(voting_escrow_id), tx.object(params.lockId), increaseCoinInput.targetCoin, tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${VotingEscrow}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  // public fun merge<T>(self: &mut VotingEscrow<T>, from_lock: Lock, to_lock: &mut Lock, clock: &Clock, ctx: &mut TxContext) {
+  static buildMergeLockTransaction(sdk, params) {
+    const tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    const { integrate } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const functionName = "merge_locks";
+    const args = [tx.object(voting_escrow_id), tx.object(params.fromLockId), tx.object(params.toLockId), tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${VotingEscrow}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  // public fun transfer<T>(lock: Lock, ve: &mut VotingEscrow<T>, to: address, clock: &Clock, ctx: &mut TxContext) {
+  static buildTransferLockTransaction(sdk, params) {
+    const tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    const { integrate } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const functionName = "transfer";
+    const args = [tx.object(voting_escrow_id), tx.object(params.lockId), tx.object(params.to), tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${VotingEscrow}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  // public fun increase_unlock_time<T>(self: &mut VotingEscrow<T>, lock: &mut Lock, lock_duration: u64, clock: &Clock, ctx: &mut TxContext) {
+  static buildIncreaseUnlockTimeTransaction(sdk, params) {
+    const tx = new import_transactions.Transaction();
+    tx.setGasBudget(1e8);
+    tx.setSender(sdk.senderAddress);
+    const oneDay = 24 * 60 * 60;
+    const newLockDuration = Math.ceil((params.newLockEndAt - Date.now()) / oneDay);
+    const { integrate } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const functionName = "increase_unlock_time";
+    const args = [tx.object(voting_escrow_id), tx.object(params.lockId), tx.pure.u64(newLockDuration), tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${VotingEscrow}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  // public fun lock_permanent<T>(self: &mut VotingEscrow<T>, lock: &mut Lock, clock: &Clock, ctx: &mut TxContext) {
+  static buildLockPermanentTransaction(sdk, params) {
+    const tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    const { integrate } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const functionName = "lock_permanent";
+    const args = [tx.object(voting_escrow_id), tx.object(params.lockId), tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${VotingEscrow}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  static buildUnlockPermanentTransaction(sdk, params) {
+    const tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    const { integrate } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const functionName = "unlock_permanent";
+    const args = [tx.object(voting_escrow_id), tx.object(params.lockId), tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${VotingEscrow}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  static buildVoteTransaction(sdk, params) {
+    const tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    tx.setGasBudget(1e8);
+    const { integrate } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token, voter_id } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const functionName = "vote";
+    const pools = tx.pure.vector("id", params.pools);
+    const weights = tx.makeMoveVec({
+      elements: params.weights.map((weight) => tx.pure.u64(weight)),
+      type: "u64"
+    });
+    const args = [tx.object(voter_id), tx.object(voting_escrow_id), tx.object(params.lockId), pools, weights, tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${Voter}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  static buildClaimVotingRewardsTransaction(sdk, params) {
+    const tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    const { integrate } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token, voter_id } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token, params.coinAType, params.coinBType];
+    const functionName = "claim_voting_fee_rewards_single";
+    const args = [tx.object(voter_id), tx.object(voting_escrow_id), tx.object(params.locks), tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${Voter}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  static buildClaimVotingRewardsPoolsTransaction(sdk, params) {
+    const tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    const { integrate, distribution } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token, voter_id } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token, params.coinAType, params.coinBType];
+    const functionName = "claim_voting_fee_rewards";
+    const locks = tx.makeMoveVec({
+      elements: params.locks.map((lock) => tx.object(lock)),
+      type: `${distribution.package_id}::voting_escrow::Lock`
+    });
+    const args = [tx.object(voter_id), tx.object(voting_escrow_id), locks, tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${Voter}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  static buildClaimAndLockRebases(sdk, params) {
+    const tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    tx.setGasBudget(5e8);
+    const { integrate } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token, reward_distributor_id } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const functionName = "claim_and_lock";
+    const args = [tx.object(reward_distributor_id), tx.object(voting_escrow_id), tx.object(params.lockId), tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${RewardDistributor}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  static buildPoke(sdk, params) {
+    const tx = new import_transactions.Transaction();
+    tx.setSender(sdk.senderAddress);
+    const { integrate } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token, voter_id } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const functionName = "poke";
+    const args = [tx.object(voter_id), tx.object(voting_escrow_id), tx.object(params.lockId), tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${Voter}::${functionName}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  static buildClaimVotingBribe(sdk, locks, incentive_tokens) {
+    const tx = new import_transactions.Transaction();
+    tx.setGasBudget(5e8);
+    tx.setSender(sdk.senderAddress);
+    const { integrate, distribution } = sdk.sdkOptions;
+    const { voting_escrow_id, magma_token, voter_id } = getPackagerConfigs(sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token, ...incentive_tokens];
+    let targetFunc = `${integrate.published_at}::${Voter}::claim_voting_bribes_${incentive_tokens.length}`;
+    if (incentive_tokens.length === 1) {
+      targetFunc = `${integrate.published_at}::${Voter}::claim_voting_bribes`;
+    }
+    const locksParams = tx.makeMoveVec({
+      elements: locks.map((lock) => tx.object(lock)),
+      type: `${distribution.package_id}::voting_escrow::Lock`
+    });
+    const args = [tx.object(voter_id), tx.object(voting_escrow_id), locksParams, tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: targetFunc,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
   /**
    * build swap transaction
    * @param params
@@ -6743,9 +6990,16 @@ var SwapModule = class {
    */
   async preswap(params) {
     const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const { global_config_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
     const tx = new import_transactions8.Transaction();
     const typeArguments = [params.coinTypeA, params.coinTypeB];
-    const args = [tx.object(params.pool.poolAddress), tx.pure.bool(params.a2b), tx.pure.bool(params.byAmountIn), tx.pure.u64(params.amount)];
+    const args = [
+      tx.object(global_config_id),
+      tx.object(params.pool.poolAddress),
+      tx.pure.bool(params.a2b),
+      tx.pure.bool(params.byAmountIn),
+      tx.pure.u64(params.amount)
+    ];
     tx.moveCall({
       target: `${integrate.published_at}::${ClmmFetcherModule}::calculate_swap_result`,
       arguments: args,
@@ -6903,10 +7157,434 @@ var SwapModule = class {
   }
 };
 
+// src/modules/lockModule.ts
+var import_transactions9 = require("@mysten/sui/transactions");
+var LockModule = class {
+  _sdk;
+  constructor(sdk) {
+    this._sdk = sdk;
+  }
+  get sdk() {
+    return this._sdk;
+  }
+  async createLockTransactionPayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    const allCoinAsset = await this._sdk.getOwnerCoinAssets(this._sdk.senderAddress);
+    return TransactionUtil.buildCreateLockTransaction(this.sdk, params, allCoinAsset);
+  }
+  async increaseLockAmountTransactionPayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    const allCoinAsset = await this._sdk.getOwnerCoinAssets(this._sdk.senderAddress);
+    return TransactionUtil.buildIncreaseLockAmountTransaction(this.sdk, params, allCoinAsset);
+  }
+  async mergeLockTransactionPayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildMergeLockTransaction(this.sdk, params);
+  }
+  // public fun transfer<T>(lock: Lock, ve: &mut VotingEscrow<T>, to: address, clock: &Clock, ctx: &mut TxContext) {
+  async transferLockTransactionPayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildTransferLockTransaction(this.sdk, params);
+  }
+  async increaseUnlockTimePayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildIncreaseUnlockTimeTransaction(this.sdk, params);
+  }
+  // public fun lock_permanent<T>(self: &mut VotingEscrow<T>, lock: &mut Lock, clock: &Clock, ctx: &mut TxContext) {
+  async lockPermanentPayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildLockPermanentTransaction(this.sdk, params);
+  }
+  async unlockPermanentPayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildUnlockPermanentTransaction(this.sdk, params);
+  }
+  async votePayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildVoteTransaction(this.sdk, params);
+  }
+  // public fun claim_fees<T, B>(self: &mut Voter<T>, ve: &mut VotingEscrow<T>, mut locks: vector<Lock>, clock: &Clock, ctx: &mut TxContext) {
+  async claimVotingRewardsPayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildClaimVotingRewardsTransaction(this.sdk, params);
+  }
+  // public fun claim_fees<T, B>(self: &mut Voter<T>, ve: &mut VotingEscrow<T>, mut locks: vector<Lock>, clock: &Clock, ctx: &mut TxContext) {
+  async claimVotingRewardsPoolsPayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildClaimVotingRewardsPoolsTransaction(this.sdk, params);
+  }
+  async claimAndLockRebasesPayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildClaimAndLockRebases(this.sdk, params);
+  }
+  async pokePayload(params) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildPoke(this.sdk, params);
+  }
+  async claimVotingBribe(locks, incentive_tokens) {
+    if (this._sdk.senderAddress.length === 0) {
+      throw Error("this config sdk senderAddress is empty");
+    }
+    return TransactionUtil.buildClaimVotingBribe(this.sdk, locks, incentive_tokens);
+  }
+  async locksOfUser(user) {
+    const locksInfo = { owner: user, lockInfo: [] };
+    const { distribution } = this._sdk.sdkOptions;
+    const { magma_token } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    const ownerRes = await this._sdk.fullClient.getOwnedObjectsByPage(user, {
+      options: { showType: true, showContent: true, showDisplay: true, showOwner: true },
+      filter: {
+        MatchAll: [{ Package: distribution.package_id }, { StructType: `${distribution.package_id}::voting_escrow::Lock` }]
+      }
+    });
+    for (const item of ownerRes.data) {
+      const { fields } = item.data.content;
+      const aLockSummary = await this.aLockSummary(fields.id.id);
+      const poolIncentiveTokens = await this.getVotingBribeRewardTokens(fields.id.id);
+      const incentiveTokens = [];
+      poolIncentiveTokens.forEach((value, key) => {
+        incentiveTokens.push(...value);
+      });
+      const poolIncentiveRewards = await this.getPoolIncentiveRewrads(incentiveTokens, fields.id.id);
+      const votingRewards = /* @__PURE__ */ new Map();
+      poolIncentiveRewards.forEach((value, coin) => {
+        value.forEach((amount, pool) => {
+          if (!votingRewards.has(pool)) {
+            votingRewards.set(pool, []);
+          }
+          votingRewards.get(pool)?.push({
+            kind: "incentiveCoin" /* Incentive */,
+            token_addr: coin,
+            amount: amount.toString()
+          });
+        });
+      });
+      const lockInfo = {
+        lock_id: fields.id.id,
+        amount: fields.amount,
+        start: fields.start,
+        end: fields.end,
+        permanent: fields.permanent,
+        rebase_amount: {
+          kind: "rebaseCoin" /* RebaseCoin */,
+          token_addr: magma_token,
+          amount: aLockSummary.reward_distributor_claimable
+        },
+        voting_power: aLockSummary.voting_power,
+        // pool => incentive => amount
+        voting_rewards: votingRewards
+      };
+      locksInfo.lockInfo.push(lockInfo);
+    }
+    return locksInfo;
+  }
+  async aLockSummary(lock_id) {
+    const tx = new import_transactions9.Transaction();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const { voting_escrow_id, magma_token, voter_id, reward_distributor_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const args = [
+      tx.object(voter_id),
+      tx.object(voting_escrow_id),
+      tx.object(reward_distributor_id),
+      tx.object(lock_id),
+      tx.object(CLOCK_ADDRESS)
+    ];
+    tx.moveCall({
+      target: `${integrate.published_at}::${VotingEscrow}::lock_summary`,
+      arguments: args,
+      typeArguments
+    });
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`lock_summary error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    let res = {
+      //  reward_distributor_claimable + incentive magma
+      fee_incentive_total: "",
+      // How much Magma can be claimed
+      reward_distributor_claimable: "",
+      voting_power: ""
+    };
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `LockSummary`) {
+        res = {
+          fee_incentive_total: item.parsedJson.fee_incentive_total,
+          reward_distributor_claimable: item.parsedJson.reward_distributor_claimable,
+          voting_power: item.parsedJson.voting_power
+        };
+      }
+    });
+    return res;
+  }
+  async allLockSummary() {
+    const tx = new import_transactions9.Transaction();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const { voting_escrow_id, magma_token, voter_id, minter_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const args = [tx.object(minter_id), tx.object(voter_id), tx.object(voting_escrow_id), tx.object(CLOCK_ADDRESS)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${VotingEscrow}::summary`,
+      arguments: args,
+      typeArguments
+    });
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`all_lock_summary error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    let summary = {
+      current_epoch_end: 0,
+      current_epoch_vote_end: 0,
+      rebase_apr: 0,
+      team_emission_rate: 0,
+      total_locked: 0,
+      total_voted_power: 0,
+      total_voting_power: 0
+    };
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `Summary`) {
+        summary = {
+          current_epoch_end: Number(item.parsedJson.current_epoch_end),
+          current_epoch_vote_end: Number(item.parsedJson.current_epoch_vote_end),
+          rebase_apr: Number(item.parsedJson.rebase_apr),
+          team_emission_rate: Number(item.parsedJson.team_emission_rate),
+          total_locked: Number(item.parsedJson.total_locked),
+          total_voted_power: Number(item.parsedJson.total_voted_power),
+          total_voting_power: Number(item.parsedJson.total_voting_power)
+        };
+      }
+    });
+    return summary;
+  }
+  async poolWeights(pools) {
+    const tx = new import_transactions9.Transaction();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const { magma_token, voter_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const poolsParams = tx.pure.vector("id", pools);
+    const args = [tx.object(voter_id), poolsParams];
+    tx.moveCall({
+      target: `${integrate.published_at}::${Voter}::pools_tally`,
+      arguments: args,
+      typeArguments
+    });
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`all_lock_summary error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    const poolWeights = [];
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `PoolsTally`) {
+        item.parsedJson.list.forEach((item2) => {
+          poolWeights.push({
+            poolId: item2.id,
+            weight: item2.weight
+          });
+        });
+      }
+    });
+    return poolWeights;
+  }
+  async getVotingFeeRewardTokens(lock_id) {
+    const tx = new import_transactions9.Transaction();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const { magma_token, voter_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const args = [tx.object(voter_id), tx.object(lock_id)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${Voter}::get_voting_fee_reward_tokens`,
+      arguments: args,
+      typeArguments
+    });
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`all_lock_summary error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    const poolRewardTokens = /* @__PURE__ */ new Map();
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `EventRewardTokens`) {
+        item.parsedJson.list.contents.forEach((poolTokens) => {
+          if (!poolRewardTokens.has(poolTokens.key)) {
+            poolRewardTokens.set(poolTokens.key, []);
+          }
+          poolTokens.value.forEach((token) => {
+            poolRewardTokens.get(poolTokens.key)?.push(token.name);
+          });
+        });
+      }
+    });
+    return poolRewardTokens;
+  }
+  async getVotingBribeRewardTokens(lock_id) {
+    const tx = new import_transactions9.Transaction();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const { magma_token, voter_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const args = [tx.object(voter_id), tx.object(lock_id)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${Voter}::get_voting_bribe_reward_tokens`,
+      arguments: args,
+      typeArguments
+    });
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`all_lock_summary error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    const poolBirbeRewardTokens = /* @__PURE__ */ new Map();
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `EventRewardTokens`) {
+        item.parsedJson.list.contents.forEach((poolTokens) => {
+          if (!poolBirbeRewardTokens.has(poolTokens.key)) {
+            poolBirbeRewardTokens.set(poolTokens.key, []);
+          }
+          poolTokens.value.forEach((token) => {
+            poolBirbeRewardTokens.get(poolTokens.key)?.push(token.name);
+          });
+        });
+      }
+    });
+    return poolBirbeRewardTokens;
+  }
+  // tokenId => pool => incentive_tokens
+  async getPoolIncentiveRewrads(incentive_tokens, locksId) {
+    const poolBirbeRewardTokens = /* @__PURE__ */ new Map();
+    if (incentive_tokens.length === 0) {
+      return poolBirbeRewardTokens;
+    }
+    const tx = new import_transactions9.Transaction();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const { magma_token, voter_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token, ...incentive_tokens];
+    const args = [tx.object(voter_id), tx.object(locksId), tx.object(CLOCK_ADDRESS)];
+    let targetFunc = `${integrate.published_at}::${Voter}::claimable_voting_bribes_${incentive_tokens.length}`;
+    if (incentive_tokens.length === 1) {
+      targetFunc = `${integrate.published_at}::${Voter}::claimable_voting_bribes`;
+    }
+    tx.moveCall({
+      target: targetFunc,
+      arguments: args,
+      typeArguments
+    });
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`all_lock_summary error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `ClaimableVotingBribes`) {
+        item.parsedJson.data.contents.forEach((rewardTokens) => {
+          if (!poolBirbeRewardTokens.has(rewardTokens.key.name)) {
+            poolBirbeRewardTokens.set(rewardTokens.key.name, /* @__PURE__ */ new Map());
+          }
+          rewardTokens.value.contents.forEach((token) => {
+            poolBirbeRewardTokens.get(rewardTokens.key.name)?.set(token.key, token.value);
+          });
+        });
+      }
+    });
+    return poolBirbeRewardTokens;
+  }
+  async getPoolBribeRewardTokens(pool_id) {
+    const tx = new import_transactions9.Transaction();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const { magma_token, voter_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
+    const args = [tx.object(voter_id), tx.object(pool_id)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${Voter}::get_voting_bribe_reward_tokens_by_pool`,
+      arguments: args,
+      typeArguments
+    });
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`all_lock_summary error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    const poolBirbeRewardTokens = /* @__PURE__ */ new Map();
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `EventRewardTokens`) {
+        item.parsedJson.list.contents.forEach((poolTokens) => {
+          if (!poolBirbeRewardTokens.has(poolTokens.key)) {
+            poolBirbeRewardTokens.set(poolTokens.key, []);
+          }
+          poolTokens.value.forEach((token) => {
+            poolBirbeRewardTokens.get(poolTokens.key)?.push(token.name);
+          });
+        });
+      }
+    });
+    return poolBirbeRewardTokens;
+  }
+};
+
 // src/modules/tokenModule.ts
 var import_js_base64 = require("js-base64");
-var import_transactions9 = require("@mysten/sui/transactions");
-var import_utils21 = require("@mysten/sui/utils");
+var import_transactions10 = require("@mysten/sui/transactions");
+var import_utils22 = require("@mysten/sui/utils");
 var TokenModule = class {
   _sdk;
   _cache = {};
@@ -7041,7 +7719,7 @@ var TokenModule = class {
     }
     const tokenConfig = getPackagerConfigs(token);
     while (true) {
-      const tx = new import_transactions9.Transaction();
+      const tx = new import_transactions10.Transaction();
       tx.moveCall({
         target: `${token.published_at}::coin_list::${isOwnerRequest ? "fetch_full_list_with_limit" : "fetch_all_registered_coin_info_with_limit"}`,
         arguments: isOwnerRequest ? [tx.pure.address(tokenConfig.coin_registry_id), tx.pure.address(listOwnerAddr), tx.pure.u64(index), tx.pure.u64(limit)] : [tx.pure.address(tokenConfig.coin_registry_id), tx.pure.u64(index), tx.pure.u64(limit)]
@@ -7084,7 +7762,7 @@ var TokenModule = class {
     }
     const tokenConfig = getPackagerConfigs(token);
     while (true) {
-      const tx = new import_transactions9.Transaction();
+      const tx = new import_transactions10.Transaction();
       tx.moveCall({
         target: `${token.published_at}::lp_list::${isOwnerRequest ? "fetch_full_list_with_limit" : "fetch_all_registered_coin_info_with_limit"}`,
         arguments: isOwnerRequest ? [tx.pure.address(tokenConfig.pool_registry_id), tx.pure.address(listOwnerAddr), tx.pure.u64(index), tx.pure.u64(limit)] : [tx.pure.address(tokenConfig.pool_registry_id), tx.pure.u64(index), tx.pure.u64(limit)]
@@ -7218,7 +7896,7 @@ var TokenModule = class {
           }
         }
         if (key === "pyth_id") {
-          value = (0, import_utils21.normalizeSuiObjectId)(value);
+          value = (0, import_utils22.normalizeSuiObjectId)(value);
         }
         token[key] = value;
       }
@@ -7619,7 +8297,7 @@ var RouterModuleV2 = class {
 };
 
 // src/modules/configModule.ts
-var import_utils23 = require("@mysten/sui/utils");
+var import_utils24 = require("@mysten/sui/utils");
 var import_js_base642 = require("js-base64");
 var ConfigModule = class {
   _sdk;
@@ -7775,7 +8453,7 @@ var ConfigModule = class {
     coin.id = getObjectId(object);
     coin.address = extractStructTagFromType(fields.coin_type.fields.name).full_address;
     if (fields.pyth_id) {
-      coin.pyth_id = (0, import_utils23.normalizeSuiObjectId)(fields.pyth_id);
+      coin.pyth_id = (0, import_utils24.normalizeSuiObjectId)(fields.pyth_id);
     }
     this.transformExtensions(coin, fields.extension_fields.fields.contents, transformExtensions);
     delete coin.coin_type;
@@ -7836,7 +8514,7 @@ var ConfigModule = class {
     fields = fields.value.fields;
     const pool = { ...fields };
     pool.id = getObjectId(object);
-    pool.pool_address = (0, import_utils23.normalizeSuiObjectId)(fields.pool_address);
+    pool.pool_address = (0, import_utils24.normalizeSuiObjectId)(fields.pool_address);
     this.transformExtensions(pool, fields.extension_fields.fields.contents, transformExtensions);
     return pool;
   }
@@ -7895,7 +8573,7 @@ var ConfigModule = class {
     fields = fields.value.fields;
     const pool = { ...fields };
     pool.id = getObjectId(object);
-    pool.pool_address = (0, import_utils23.normalizeSuiObjectId)(fields.pool_address);
+    pool.pool_address = (0, import_utils24.normalizeSuiObjectId)(fields.pool_address);
     this.transformExtensions(pool, fields.extension_fields.fields.contents, transformExtensions);
     const social_medias = [];
     fields.social_media.fields.contents.forEach((item) => {
@@ -7970,7 +8648,12 @@ var ConfigModule = class {
       global_config_id: "",
       coin_list_handle: "",
       launchpad_pools_handle: "",
-      clmm_pools_handle: ""
+      clmm_pools_handle: "",
+      voter_id: "",
+      minter_id: "",
+      reward_distributor_id: "",
+      magma_token: "",
+      voting_escrow_id: ""
     };
     if (objects.data.length > 0) {
       for (const item of objects.data) {
@@ -8260,6 +8943,10 @@ var MagmaClmmSDK = class {
    * Provide interact with a pool swap router interface.
    */
   _swap;
+  /**
+   * Provide interact with a lock interface.
+   */
+  _lock;
   /**
    * Provide interact  with a position rewarder interface.
    */
@@ -8295,6 +8982,7 @@ var MagmaClmmSDK = class {
       url: options.fullRpcUrl
     });
     this._swap = new SwapModule(this);
+    this._lock = new LockModule(this);
     this._pool = new PoolModule(this);
     this._position = new PositionModule(this);
     this._rewarder = new RewarderModule(this);
@@ -8325,6 +9013,10 @@ var MagmaClmmSDK = class {
   get Swap() {
     return this._swap;
   }
+  /* */
+  get Lock() {
+    return this._lock;
+  }
   /**
    * Getter for the fullClient property.
    * @returns {RpcModule} The fullClient property value.
@@ -8498,7 +9190,7 @@ var main_default = MagmaClmmSDK;
 var SDKConfig = {
   clmmConfig: {
     pools_id: "0xf699e7f2276f5c9a75944b37a0c5b5d9ddfd2471bf6242483b03ab2887d198d0",
-    global_config_id: "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f",
+    global_config_id: "0x4f32c00706e7bdbce532acdcfc0afd91b14defd5ffc9e2723a0ce7ed84f5d380",
     global_vault_id: "0xce7bceef26d3ad1f6d9b6f13a953f053e6ed3ca77907516481ce99ae8e588f2b",
     admin_cap_id: "0x89c1a321291d15ddae5a086c9abc533dff697fde3d89e0ca836c41af73e36a75"
   },
@@ -8507,10 +9199,15 @@ var SDKConfig = {
     launchpad_pools_id: "0x1098fac992eab3a0ab7acf15bb654fc1cf29b5a6142c4ef1058e6c408dd15115",
     clmm_pools_id: "0x15b6a27dd9ae03eb455aba03b39e29aad74abd3757b8e18c0755651b2ae5b71e",
     admin_cap_id: "0x39d78781750e193ce35c45ff32c6c0c3f2941fa3ddaf8595c90c555589ddb113",
-    global_config_id: "0x0408fa4e4a4c03cc0de8f23d0c2bbfe8913d178713c9a271ed4080973fe42d8f",
     coin_list_handle: "0x49136005e90e28c4695419ed4194cc240603f1ea8eb84e62275eaff088a71063",
     launchpad_pools_handle: "0x5e194a8efcf653830daf85a85b52e3ae8f65dc39481d54b2382acda25068375c",
-    clmm_pools_handle: "0x37f60eb2d9d227949b95da8fea810db3c32d1e1fa8ed87434fc51664f87d83cb"
+    clmm_pools_handle: "0x37f60eb2d9d227949b95da8fea810db3c32d1e1fa8ed87434fc51664f87d83cb",
+    global_config_id: "0x4f32c00706e7bdbce532acdcfc0afd91b14defd5ffc9e2723a0ce7ed84f5d380",
+    voter_id: "0x2e2fae39d85e991e1adad756f6723bb1aebc33140b8b16897a41171640389f88",
+    voting_escrow_id: "0x8c300ccc0cb221feb76d0ed0820ff0873477ab1ada266129d594d539c5cd2f11",
+    reward_distributor_id: "0x289c10f62e998a2ee58a982262732af7e329b7b689f4c81b0e16de7c6589669c",
+    magma_token: "0x4201f44d506036666a1d9166f7a3450a80c73c551a582684cf39f2dbb3d56461::magma_token::MAGMA_TOKEN",
+    minter_id: "0xfaf1c9b59192a3f910f28d46325dbfb3ffcc92df43d11663f3820fec8faf540b"
   }
 };
 var clmmMainnet = {
@@ -8524,13 +9221,17 @@ var clmmMainnet = {
     config: SDKConfig.magmaConfig
   },
   clmm_pool: {
-    package_id: "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb",
-    published_at: "0xdc67d6de3f00051c505da10d8f6fbab3b3ec21ec65f0dc22a2f36c13fc102110",
+    package_id: "0x0a9b94307de472ebe7c1a24ea862eb013d954c9c003a0484e045861d05b31435",
+    published_at: "0x0a9b94307de472ebe7c1a24ea862eb013d954c9c003a0484e045861d05b31435",
     config: SDKConfig.clmmConfig
   },
+  distribution: {
+    package_id: "0x4201f44d506036666a1d9166f7a3450a80c73c551a582684cf39f2dbb3d56461",
+    published_at: "0x5c008a2e0aee9a034b19e32bbc119cf6e7b1a0ce1316b2199cde1704d9f64f3c"
+  },
   integrate: {
-    package_id: "0x996c4d9480708fb8b92aa7acf819fb0497b5ec8e65ba06601cae2fb6db3312c3",
-    published_at: "0x3a5aa90ffa33d09100d7b6941ea1c0ffe6ab66e77062ddd26320c1b073aabb10"
+    package_id: "0x01268a2afbaf91538f0b9041269fe2780273eb83b642abd4fcacad7b660a3711",
+    published_at: "0x01268a2afbaf91538f0b9041269fe2780273eb83b642abd4fcacad7b660a3711"
   },
   deepbook: {
     package_id: "0x000000000000000000000000000000000000000000000000000000000000dee9",
@@ -8567,34 +9268,43 @@ var SDKConfig2 = {
     launchpad_pools_id: "0xdc3a7bd66a6dcff73c77c866e87d73826e446e9171f34e1c1b656377314f94da",
     clmm_pools_id: "0x26c85500f5dd2983bf35123918a144de24e18936d0b234ef2b49fbb2d3d6307d",
     admin_cap_id: "0x1a496f6c67668eb2c27c99e07e1d61754715c1acf86dac45020c886ac601edb8",
-    global_config_id: "0xe1f3db327e75f7ec30585fa52241edf66f7e359ef550b533f89aa1528dd1be52",
     coin_list_handle: "0x3204350fc603609c91675e07b8f9ac0999b9607d83845086321fca7f469de235",
     launchpad_pools_handle: "0xae67ff87c34aceea4d28107f9c6c62e297a111e9f8e70b9abbc2f4c9f5ec20fd",
-    clmm_pools_handle: "0xd28736923703342b4752f5ed8c2f2a5c0cb2336c30e1fed42b387234ce8408ec"
+    clmm_pools_handle: "0xd28736923703342b4752f5ed8c2f2a5c0cb2336c30e1fed42b387234ce8408ec",
+    global_config_id: "0xbbe54f3c2bd06c5ab7f93950025bff6710c9a83836d7145636fea383b315774d",
+    voter_id: "0x59571991a5c7041c4376d980061af5c7a6d8345006d6b5167bd1f00fc17b8ddb",
+    voting_escrow_id: "0x9081c8044719135da4ff2d52907fcd40c19e2a40750cbba4c1d6a59610ae1446",
+    reward_distributor_id: "0xdf213d8e0ca49c8f4a508e7d3b3a6983c4aafd639f7c99479fc75fb4451d752e",
+    magma_token: "0x45ac2371c33ca0df8dc784d62c8ce5126d42edd8c56820396524dff2ae0619b1::magma_token::MAGMA_TOKEN",
+    minter_id: "0x89435d6b2a510ba50ca23303f10e91ec058f138a88f69a43fe03cd22edb214c5"
   }
 };
 var clmmTestnet = {
   fullRpcUrl: (0, import_client3.getFullnodeUrl)("testnet"),
-  simulationAccount: {
-    address: "0x0000000000000000000000000000000000000000000000000000000000000000"
-  },
-  faucet: {
-    package_id: "0x26b3bc67befc214058ca78ea9a2690298d731a2d4309485ec3d40198063c4abc",
-    published_at: "0x26b3bc67befc214058ca78ea9a2690298d731a2d4309485ec3d40198063c4abc"
-  },
   magma_config: {
     package_id: "0xf5ff7d5ba73b581bca6b4b9fa0049cd320360abd154b809f8700a8fd3cfaf7ca",
     published_at: "0xf5ff7d5ba73b581bca6b4b9fa0049cd320360abd154b809f8700a8fd3cfaf7ca",
     config: SDKConfig2.magmaConfig
   },
   clmm_pool: {
-    package_id: "0x0c7ae833c220aa73a3643a0d508afa4ac5d50d97312ea4584e35f9eb21b9df12",
-    published_at: "0x85e61285a10efc6602ab00df70a0c06357c384ef4c5633ecf73016df1500c704",
+    package_id: "0x23e0b5ab4aa63d0e6fd98fa5e247bcf9b36ad716b479d39e56b2ba9ff631e09d",
+    published_at: "0x23e0b5ab4aa63d0e6fd98fa5e247bcf9b36ad716b479d39e56b2ba9ff631e09d",
     config: SDKConfig2.clmmConfig
   },
+  distribution: {
+    package_id: "0x45ac2371c33ca0df8dc784d62c8ce5126d42edd8c56820396524dff2ae0619b1",
+    published_at: "0x45ac2371c33ca0df8dc784d62c8ce5126d42edd8c56820396524dff2ae0619b1"
+  },
   integrate: {
-    package_id: "0x2918cf39850de6d5d94d8196dc878c8c722cd79db659318e00bff57fbb4e2ede",
-    published_at: "0x19dd42e05fa6c9988a60d30686ee3feb776672b5547e328d6dab16563da65293"
+    package_id: "0x6d225cd7b90ca74b13e7de114c6eba2f844a1e5e1a4d7459048386bfff0d45df",
+    published_at: "0x6d225cd7b90ca74b13e7de114c6eba2f844a1e5e1a4d7459048386bfff0d45df"
+  },
+  simulationAccount: {
+    address: "0x0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  faucet: {
+    package_id: "0x26b3bc67befc214058ca78ea9a2690298d731a2d4309485ec3d40198063c4abc",
+    published_at: "0x26b3bc67befc214058ca78ea9a2690298d731a2d4309485ec3d40198063c4abc"
   },
   deepbook: {
     package_id: "0x000000000000000000000000000000000000000000000000000000000000dee9",
@@ -8660,6 +9370,7 @@ var src_default = MagmaClmmSDK;
   GAS_SYMBOL,
   GAS_TYPE_ARG,
   GAS_TYPE_ARG_LONG,
+  LockModule,
   MAX_SQRT_PRICE,
   MAX_TICK_INDEX,
   MIN_SQRT_PRICE,
@@ -8673,6 +9384,7 @@ var src_default = MagmaClmmSDK;
   PositionModule,
   PositionStatus,
   PositionUtil,
+  RewardDistributor,
   RouterModule,
   RouterModuleV2,
   RpcModule,
@@ -8692,6 +9404,8 @@ var src_default = MagmaClmmSDK;
   U128,
   U128_MAX,
   U64_MAX,
+  Voter,
+  VotingEscrow,
   ZERO,
   addHexPrefix,
   adjustForCoinSlippage,