@magmaprotocol/magma-clmm-sdk 0.5.32 → 0.5.34

package/dist/index.mjs

@@ -2973,7 +2973,6 @@ var _TransactionUtil = class {
   // 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 Transaction();
-    tx.setGasBudget(1e8);
     tx.setSender(sdk.senderAddress);
     const oneDay = 24 * 60 * 60;
     const newLockDuration = Math.ceil((params.newLockEndAt - Date.now() / 1e3) / oneDay);
@@ -3134,7 +3133,6 @@ var _TransactionUtil = class {
   static buildClaimAndLockRebases(sdk, params) {
     const tx = new 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];
@@ -3170,7 +3168,6 @@ var _TransactionUtil = class {
   }
   static buildClaimVotingBribe(sdk, locks, incentive_tokens) {
     const tx = new 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);
@@ -7392,6 +7389,57 @@ var LockModule = class {
     }
     return locksInfo;
   }
+  async locksOfUserV2(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` }]
+      }
+    });
+    const ids = ownerRes.data.map((item) => item.data.content.id.id);
+    const lockSummary = await this.getAllLockSummary(ids);
+    const lockIncentiveTokens = await this.getAllBribeRewardTokensOfLock(ids);
+    const lockFeeTokens = await this.getAllVotingFeeRewardTokens(ids);
+    const poolIncentiveRewards = await this.getAllIncentiveRewards(lockIncentiveTokens);
+    const poolFeeRewards = await this.getAllFeeRewards(lockFeeTokens);
+    for (const item of ownerRes.data) {
+      const { fields } = item.data.content;
+      const lock_id = fields.id.id;
+      const votingRewards = /* @__PURE__ */ new Map();
+      poolIncentiveRewards.get(lock_id)?.forEach((value, pool) => {
+        if (!votingRewards.has(pool)) {
+          votingRewards.set(pool, []);
+        }
+        votingRewards.get(pool)?.push(...value);
+      });
+      poolFeeRewards.get(lock_id)?.forEach((value, pool) => {
+        if (!votingRewards.has(pool)) {
+          votingRewards.set(pool, []);
+        }
+        votingRewards.get(pool)?.push(...value);
+      });
+      const lockInfo = {
+        lock_id,
+        amount: fields.amount,
+        start: fields.start,
+        end: fields.end,
+        permanent: fields.permanent,
+        rebase_amount: {
+          kind: "rebaseCoin" /* RebaseCoin */,
+          token_addr: magma_token,
+          amount: lockSummary.get(lock_id)?.reward_distributor_claimable || "0"
+        },
+        voting_power: lockSummary.get(lock_id)?.voting_power || "0",
+        // pool => incentive/fee => amount
+        voting_rewards: votingRewards
+      };
+      locksInfo.lockInfo.push(lockInfo);
+    }
+    return locksInfo;
+  }
   async locksOfUser(user) {
     const locksInfo = { owner: user, lockInfo: [] };
     const { distribution } = this._sdk.sdkOptions;
@@ -7584,6 +7632,57 @@ var LockModule = class {
     });
     return res;
   }
+  // Return: lock_id => ALockSummary
+  async getAllLockSummary(lock_ids) {
+    let tx = new Transaction9();
+    for (const lock_id of lock_ids) {
+      tx = await this._aLockSummary(lock_id, tx);
+    }
+    return this._parseLockSummary(tx);
+  }
+  async _aLockSummary(lock_id, tx) {
+    tx = tx || new Transaction9();
+    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];
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
+    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
+    });
+    return tx;
+  }
+  async _parseLockSummary(tx) {
+    const { simulationAccount } = this.sdk.sdkOptions;
+    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"}`);
+    }
+    const res = /* @__PURE__ */ new Map();
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `LockSummary`) {
+        res.set(item.parsedJson.lock_id, {
+          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 Transaction9();
     const { integrate, simulationAccount } = this.sdk.sdkOptions;
@@ -7664,6 +7763,54 @@ var LockModule = class {
     });
     return poolWeights;
   }
+  async getAllVotingFeeRewardTokens(lock_ids) {
+    let tx = new Transaction9();
+    for (const lock_id of lock_ids) {
+      tx = await this._getVotingFeeRewardTokens(lock_id, tx);
+    }
+    return this._parseVotingFeeRewardTokens(tx);
+  }
+  async _getVotingFeeRewardTokens(lock_id, tx) {
+    tx = tx || new Transaction9();
+    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)];
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
+    tx.moveCall({
+      target: `${integrate.published_at}::${Voter}::get_voting_fee_reward_tokens`,
+      arguments: args,
+      typeArguments
+    });
+    return tx;
+  }
+  async _parseVotingFeeRewardTokens(tx) {
+    const { simulationAccount } = this.sdk.sdkOptions;
+    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 poolFeeRewardTokens = /* @__PURE__ */ new Map();
+    simulateRes.events?.forEach((event) => {
+      if (extractStructTagFromType(event.type).name === `EventFeeRewardTokens`) {
+        const { lock_id } = event.parsedJson;
+        if (!poolFeeRewardTokens.has(lock_id)) {
+          poolFeeRewardTokens.set(lock_id, []);
+        }
+        event.parsedJson.list.contents.forEach((poolTokens) => {
+          poolTokens.value.forEach((token) => {
+            poolFeeRewardTokens.get(lock_id)?.push(token.name);
+          });
+        });
+      }
+    });
+    return poolFeeRewardTokens;
+  }
   async getVotingFeeRewardTokens(lock_id) {
     const tx = new Transaction9();
     const { integrate, simulationAccount } = this.sdk.sdkOptions;
@@ -7687,7 +7834,7 @@ var LockModule = class {
     }
     const poolRewardTokens = /* @__PURE__ */ new Map();
     simulateRes.events?.forEach((item) => {
-      if (extractStructTagFromType(item.type).name === `EventRewardTokens`) {
+      if (extractStructTagFromType(item.type).name === `EventFeeRewardTokens`) {
         item.parsedJson.list.contents.forEach((poolTokens) => {
           if (!poolRewardTokens.has(poolTokens.key)) {
             poolRewardTokens.set(poolTokens.key, []);
@@ -7700,20 +7847,70 @@ var LockModule = class {
     });
     return poolRewardTokens;
   }
-  async getVotingBribeRewardTokens(lock_id) {
-    const tx = new Transaction9();
+  // tokens
+  async getAllBribeRewardTokensOfLock(lock_ids) {
+    let tx = new Transaction9();
+    for (const lock_id of lock_ids) {
+      tx = await this._getVotingBribeRewardTokens(lock_id, tx);
+    }
+    return this._parseVotingBribeRewardTokens(tx);
+  }
+  async _getVotingBribeRewardTokens(lock_id, tx) {
+    tx = tx || new Transaction9();
     const { integrate, simulationAccount } = this.sdk.sdkOptions;
     const { magma_token, voter_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
     const typeArguments = [magma_token];
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
     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
     });
+    return tx;
+  }
+  async _parseVotingBribeRewardTokens(tx) {
+    const { simulationAccount } = this.sdk.sdkOptions;
+    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((event) => {
+      if (extractStructTagFromType(event.type).name === `EventBribeRewardTokens`) {
+        const { lock_id } = event.parsedJson;
+        if (!poolBirbeRewardTokens.has(lock_id)) {
+          poolBirbeRewardTokens.set(lock_id, []);
+        }
+        event.parsedJson.list.contents.forEach((poolTokens) => {
+          poolTokens.value.forEach((token) => {
+            poolBirbeRewardTokens.get(lock_id)?.push(token.name);
+          });
+        });
+      }
+    });
+    return poolBirbeRewardTokens;
+  }
+  // Return PoolId => tokens
+  async getVotingBribeRewardTokens(lock_id) {
+    const tx = new Transaction9();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const { magma_token, voter_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token];
     if (!checkInvalidSuiAddress(simulationAccount.address)) {
       throw Error("this config simulationAccount is not set right");
     }
+    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
+    });
     const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
       transactionBlock: tx,
       sender: simulationAccount.address
@@ -7723,7 +7920,7 @@ var LockModule = class {
     }
     const poolBirbeRewardTokens = /* @__PURE__ */ new Map();
     simulateRes.events?.forEach((item) => {
-      if (extractStructTagFromType(item.type).name === `EventRewardTokens`) {
+      if (extractStructTagFromType(item.type).name === `EventBribeRewardTokens`) {
         item.parsedJson.list.contents.forEach((poolTokens) => {
           if (!poolBirbeRewardTokens.has(poolTokens.key)) {
             poolBirbeRewardTokens.set(poolTokens.key, []);
@@ -7736,6 +7933,68 @@ var LockModule = class {
     });
     return poolBirbeRewardTokens;
   }
+  async getAllFeeRewards(fee_tokens) {
+    let tx = new Transaction9();
+    fee_tokens.forEach((tokens, lock_id) => {
+      tx = this._getFeeRewards(lock_id, tokens, tx);
+    });
+    return await this._parseFeeRewards(tx);
+  }
+  _getFeeRewards(lock_id, fee_tokens, tx) {
+    if (fee_tokens.length % 2 !== 0) {
+      fee_tokens.push(fee_tokens[0]);
+    }
+    for (let i = 0; i + 1 < fee_tokens.length; i += 2) {
+      tx = this._getFeeRewardsInner(lock_id, fee_tokens[i], fee_tokens[i + 1], tx);
+    }
+    return tx;
+  }
+  _getFeeRewardsInner(lock_id, token_a, token_b, tx) {
+    tx = tx || new Transaction9();
+    const { integrate } = this.sdk.sdkOptions;
+    const { magma_token, voter_id } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    const typeArguments = [magma_token, token_a, token_b];
+    const args = [tx.object(voter_id), tx.object(lock_id), tx.object(CLOCK_ADDRESS)];
+    const targetFunc = `${integrate.published_at}::${Voter}::claimable_voting_fee_rewards`;
+    tx.moveCall({
+      target: targetFunc,
+      arguments: args,
+      typeArguments
+    });
+    return tx;
+  }
+  async _parseFeeRewards(tx) {
+    const { simulationAccount } = this.sdk.sdkOptions;
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`getPoolIncentiveRewards error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    const poolFeeRewardTokens = /* @__PURE__ */ new Map();
+    simulateRes.events?.forEach((event) => {
+      if (extractStructTagFromType(event.type).name === `ClaimableVotingFee`) {
+        const { lock_id } = event.parsedJson;
+        if (!poolFeeRewardTokens.has(lock_id)) {
+          poolFeeRewardTokens.set(lock_id, /* @__PURE__ */ new Map());
+        }
+        event.parsedJson.list.contents.forEach((rewardTokens) => {
+          rewardTokens.value.contents.forEach((token) => {
+            if (!poolFeeRewardTokens.get(lock_id)?.has(rewardTokens.key.name)) {
+              poolFeeRewardTokens.get(lock_id)?.set(rewardTokens.key.name, []);
+            }
+            poolFeeRewardTokens.get(lock_id)?.get(rewardTokens.key.name)?.push({
+              kind: "incentiveCoin" /* Incentive */,
+              token_addr: token.key,
+              amount: token.value
+            });
+          });
+        });
+      }
+    });
+    return poolFeeRewardTokens;
+  }
   async getPoolFeeRewards(lock_id, tokens) {
     const poolFeeRewardTokens = /* @__PURE__ */ new Map();
     if (tokens.length === 0) {
@@ -7786,6 +8045,78 @@ var LockModule = class {
     });
     return poolFeeRewardTokens;
   }
+  // params: lock_id => incentive_tokens
+  // lock_id => Pool => rewardTokens
+  async getAllIncentiveRewards(lock_incentive_tokens) {
+    let tx = new Transaction9();
+    lock_incentive_tokens.forEach((tokens, lock_id) => {
+      tx = this._getIncentiveRewards(lock_id, tokens, tx);
+    });
+    return await this._parseIncentiveRewards(tx);
+  }
+  _getIncentiveRewards(lock_id, incentive_tokens, tx) {
+    let i = 0;
+    for (; i + 3 < incentive_tokens.length; i += 3) {
+      this._getIncentiveRewardsInner(lock_id, incentive_tokens.slice(i, i + 3), tx);
+    }
+    return this._getIncentiveRewardsInner(lock_id, incentive_tokens.slice(i), tx);
+  }
+  _getIncentiveRewardsInner(locksId, incentive_tokens, tx) {
+    tx = tx || new Transaction9();
+    if (incentive_tokens.length > 3) {
+      throw Error("Too many tokens");
+    }
+    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`;
+    }
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
+    tx.moveCall({
+      target: targetFunc,
+      arguments: args,
+      typeArguments
+    });
+    return tx;
+  }
+  async _parseIncentiveRewards(tx) {
+    const { simulationAccount } = this.sdk.sdkOptions;
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`getPoolIncentiveRewards error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    const poolBribeRewardTokens = /* @__PURE__ */ new Map();
+    simulateRes.events?.forEach((event) => {
+      if (extractStructTagFromType(event.type).name === `ClaimableVotingBribes`) {
+        const { lock_id } = event.parsedJson;
+        if (!poolBribeRewardTokens.has(lock_id)) {
+          poolBribeRewardTokens.set(lock_id, /* @__PURE__ */ new Map());
+        }
+        event.parsedJson.list.contents.forEach((rewardTokens) => {
+          rewardTokens.value.contents.forEach((token) => {
+            if (!poolBribeRewardTokens.get(lock_id)?.has(rewardTokens.key.name)) {
+              poolBribeRewardTokens.get(lock_id)?.set(rewardTokens.key.name, []);
+            }
+            poolBribeRewardTokens.get(lock_id)?.get(rewardTokens.key.name)?.push({
+              kind: "incentiveCoin" /* Incentive */,
+              token_addr: token.key,
+              amount: token.value
+            });
+          });
+        });
+      }
+    });
+    return poolBribeRewardTokens;
+  }
+  // coin => pool => amount
   async getPoolIncentiveRewards(lock_id, incentive_tokens) {
     const poolBribeRewardTokens = /* @__PURE__ */ new Map();
     if (incentive_tokens.length === 0) {
@@ -7812,14 +8143,14 @@ var LockModule = class {
     if (incentive_tokens.length === 1) {
       targetFunc = `${integrate.published_at}::${Voter}::claimable_voting_bribes`;
     }
+    if (!checkInvalidSuiAddress(simulationAccount.address)) {
+      throw Error("this config simulationAccount is not set right");
+    }
     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
@@ -9402,7 +9733,6 @@ var GaugeModule = class {
     const poolGauger = /* @__PURE__ */ new Map();
     simulateRes.events?.forEach((item) => {
       const { gauges } = item.parsedJson;
-      console.log("parsedJson", item.parsedJson);
       item.parsedJson.pools.map((pool, index) => {
         poolGauger.set(pool, gauges[index]);
       });
@@ -9469,6 +9799,21 @@ var GaugeModule = class {
     });
     return tx;
   }
+  async getAllRewardByPositions(paramsList) {
+    const tx = new Transaction11();
+    const { integrate } = this.sdk.sdkOptions;
+    const { magma_token } = getPackagerConfigs(this.sdk.sdkOptions.magma_config);
+    paramsList.forEach((params) => {
+      const typeArguments = [params.coinTypeA, params.coinTypeB, magma_token];
+      const args = [tx.object(params.gaugeId), tx.object(params.poolId), tx.object(params.positionId), tx.object(CLOCK_ADDRESS)];
+      tx.moveCall({
+        target: `${integrate.published_at}::${Gauge}::get_reward_by_position`,
+        arguments: args,
+        typeArguments
+      });
+    });
+    return tx;
+  }
   async getEpochRewardByPool(pool, incentive_tokens) {
     const tx = new Transaction11();
     const { integrate, simulationAccount } = this.sdk.sdkOptions;