@magmaprotocol/magma-clmm-sdk 0.5.33 → 0.5.35

package/dist/index.mjs

@@ -303,6 +303,7 @@ var Voter = "voter";
 var RewardDistributor = "reward_distributor";
 var Gauge = "gauge";
 var Minter = "minter";
+var DlmmScript = "dlmm_script";
 var CoinInfoAddress = "0x1::coin::CoinInfo";
 var CoinStoreAddress = "0x1::coin::CoinStore";
 var DeepbookCustodianV2Moudle = "custodian_v2";
@@ -7389,6 +7390,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;
@@ -7581,6 +7633,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;
@@ -7661,6 +7764,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;
@@ -7684,7 +7835,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, []);
@@ -7697,20 +7848,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
@@ -7720,7 +7921,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, []);
@@ -7733,6 +7934,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) {
@@ -7783,6 +8046,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) {
@@ -7809,14 +8144,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
@@ -9465,6 +9800,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;
@@ -9497,6 +9847,277 @@ var GaugeModule = class {
   }
 };
 
+// src/modules/dlmm.ts
+import { Transaction as Transaction12 } from "@mysten/sui/transactions";
+import Decimal7 from "decimal.js";
+import { get_real_id_from_price, get_storage_id_from_real_id } from "@magmaprotocol/calc_dlmm";
+var DlmmModule = class {
+  _sdk;
+  constructor(sdk) {
+    this._sdk = sdk;
+  }
+  get sdk() {
+    return this._sdk;
+  }
+  // eg: fetch pool active_index
+  async fetchPairParams(params) {
+    const tx = new Transaction12();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const typeArguments = [params.coinTypeA, params.coinTypeB];
+    const args = [tx.object(params.pair)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::fetch_pair_params`,
+      arguments: args,
+      typeArguments
+    });
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`fetchBins error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    let res = {
+      base_factor: 0,
+      filter_period: 0,
+      decay_period: 0,
+      reduction_factor: 0,
+      variable_fee_control: 0,
+      protocol_share: 0,
+      max_volatility_accumulator: 0,
+      volatility_accumulator: 0,
+      volatility_reference: 0,
+      index_reference: 0,
+      time_of_last_update: 0,
+      oracle_index: 0,
+      active_index: 0
+    };
+    simulateRes.events?.forEach((item) => {
+      console.log(extractStructTagFromType(item.type).name);
+      if (extractStructTagFromType(item.type).name === `EventPairParams`) {
+        res = item.parsedJson.params;
+      }
+    });
+    return res;
+  }
+  // params price: input (b/(10^b_decimal))/(a/(10^a_decimal))
+  price_to_storage_id(price, bin_step, tokenADecimal, tokenBDecimal) {
+    const priceDec = new Decimal7(price);
+    const tenDec = new Decimal7(10);
+    const twoDec = new Decimal7(2);
+    const price_x128 = priceDec.mul(tenDec.pow(tokenBDecimal)).div(tenDec.pow(tokenADecimal)).mul(twoDec.pow(128));
+    const active_id = get_real_id_from_price(price_x128.toFixed(0).toString(), bin_step);
+    return get_storage_id_from_real_id(active_id);
+  }
+  // NOTE: x, y should be sorted
+  async createPairPayload(params) {
+    const storage_id = this.price_to_storage_id(params.priceTokenBPerTokenA, params.bin_step, params.coinADecimal, params.coinBDecimal);
+    const tx = new Transaction12();
+    tx.setSender(this.sdk.senderAddress);
+    const { clmm_pool, dlmm_pool, integrate } = this.sdk.sdkOptions;
+    const { global_config_id } = getPackagerConfigs(clmm_pool);
+    const dlmmConfig = getPackagerConfigs(dlmm_pool);
+    const typeArguments = [params.coinTypeA, params.coinTypeB];
+    const args = [tx.object(dlmmConfig.factory), tx.object(global_config_id), tx.pure.u16(params.bin_step), tx.pure.u32(storage_id)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::create_pair`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  async createAddLiquidityPayload() {
+    const tx = new Transaction12();
+    return tx;
+  }
+  // Create a position by percent
+  async mintPercent(params) {
+    const tx = new Transaction12();
+    tx.setSender(this.sdk.senderAddress);
+    const { dlmm_pool, integrate } = this.sdk.sdkOptions;
+    const dlmmConfig = getPackagerConfigs(dlmm_pool);
+    const typeArguments = [params.coinTypeA, params.coinTypeB];
+    const allCoins = await this._sdk.getOwnerCoinAssets(this._sdk.senderAddress);
+    const primaryCoinAInputs = TransactionUtil.buildCoinForAmount(tx, allCoins, BigInt(params.amountATotal), params.coinTypeA, false, true);
+    const primaryCoinBInputs = TransactionUtil.buildCoinForAmount(tx, allCoins, BigInt(params.amountBTotal), params.coinTypeB, false, true);
+    const args = [
+      tx.object(params.pair),
+      tx.object(dlmmConfig.factory),
+      primaryCoinAInputs.targetCoin,
+      primaryCoinBInputs.targetCoin,
+      tx.pure.u64(params.amountATotal),
+      tx.pure.u64(params.amountBTotal),
+      tx.pure.vector("u32", params.storageIds),
+      tx.pure.vector("u64", params.binsAPercent),
+      tx.pure.vector("u64", params.binsBPercent),
+      tx.pure.address(params.to),
+      tx.object(CLOCK_ADDRESS)
+    ];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::mint_percent`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  // Create a position by amount
+  async createPositionByAmount(params) {
+    const tx = new Transaction12();
+    tx.setSender(this.sdk.senderAddress);
+    const { dlmm_pool, integrate } = this.sdk.sdkOptions;
+    const dlmmConfig = getPackagerConfigs(dlmm_pool);
+    const typeArguments = [params.coinTypeA, params.coinTypeB];
+    const allCoins = await this._sdk.getOwnerCoinAssets(this._sdk.senderAddress);
+    const primaryCoinAInputs = TransactionUtil.buildCoinForAmount(tx, allCoins, BigInt(params.amountATotal), params.coinTypeA, false, true);
+    const primaryCoinBInputs = TransactionUtil.buildCoinForAmount(tx, allCoins, BigInt(params.amountBTotal), params.coinTypeB, false, true);
+    const args = [
+      tx.object(params.pair),
+      tx.object(dlmmConfig.factory),
+      primaryCoinAInputs.targetCoin,
+      primaryCoinBInputs.targetCoin,
+      tx.pure.vector("u32", params.storageIds),
+      tx.pure.vector("u64", params.amountsA),
+      tx.pure.vector("u64", params.amountsB),
+      tx.pure.address(params.to),
+      tx.object(CLOCK_ADDRESS)
+    ];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::mint_amounts`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  async swap(params) {
+    const tx = new Transaction12();
+    tx.setSender(this.sdk.senderAddress);
+    const { clmm_pool, integrate } = this.sdk.sdkOptions;
+    const { global_config_id } = getPackagerConfigs(clmm_pool);
+    const typeArguments = [params.coinTypeA, params.coinTypeB];
+    const args = [
+      tx.object(params.pair),
+      tx.object(global_config_id),
+      tx.object(params.coinTypeA),
+      tx.object(params.coinTypeB),
+      tx.pure.u64(params.amountIn),
+      tx.pure.u64(params.minAmountOut),
+      tx.pure.bool(params.swapForY),
+      tx.pure.address(params.to),
+      tx.object(CLOCK_ADDRESS)
+    ];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::swap`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  async fetchBins(params) {
+    const tx = new Transaction12();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const typeArguments = [params.coinTypeA, params.coinTypeB];
+    const args = [tx.object(params.pair), tx.pure.u64(params.offset), tx.pure.u64(params.limit)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::fetch_bins`,
+      arguments: args,
+      typeArguments
+    });
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`fetchBins error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    const res = [];
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `EventFetchBins`) {
+      }
+    });
+    return res;
+  }
+  async getPositionLiquidity(params) {
+    const tx = new Transaction12();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const typeArguments = [params.coinTypeA, params.coinTypeB];
+    const args = [tx.object(params.pair), tx.object(params.positionId)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::position_liquidity`,
+      arguments: args,
+      typeArguments
+    });
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`fetchBins error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    const out = {
+      shares: 0,
+      liquidity: 0,
+      x_equivalent: 0,
+      y_equivalent: 0,
+      bin_ids: [],
+      bin_x_eq: [],
+      bin_y_eq: [],
+      bin_liquidity: []
+    };
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `EventPositionLiquidity`) {
+        out.shares = item.parsedJson.shares;
+        out.liquidity = item.parsedJson.liquidity;
+        out.x_equivalent = item.parsedJson.x_equivalent;
+        out.y_equivalent = item.parsedJson.y_equivalent;
+        out.bin_ids = item.parsedJson.bin_id;
+        out.bin_x_eq = item.parsedJson.bin_x_eq;
+        out.bin_y_eq = item.parsedJson.bin_y_eq;
+        out.bin_liquidity = item.parsedJson.bin_liquidity;
+      }
+    });
+    return out;
+  }
+  async getPairLiquidity(params) {
+    const tx = new Transaction12();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const typeArguments = [params.coinTypeA, params.coinTypeB];
+    const args = [tx.object(params.pair)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::pair_liquidity`,
+      arguments: args,
+      typeArguments
+    });
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    if (simulateRes.error != null) {
+      throw new Error(`fetchBins error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    const out = {
+      shares: 0,
+      liquidity: 0,
+      x: 0,
+      y: 0,
+      bin_ids: [],
+      bin_x: [],
+      bin_y: []
+    };
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `EventPositionLiquidity`) {
+        out.shares = item.parsedJson.shares;
+        out.liquidity = item.parsedJson.liquidity;
+        out.x = item.parsedJson.x;
+        out.y = item.parsedJson.y;
+        out.bin_ids = item.bin_ids;
+        out.bin_x = item.bin_x;
+        out.bin_y = item.bin_y;
+      }
+    });
+    return out;
+  }
+};
+
 // src/sdk.ts
 var MagmaClmmSDK = class {
   _cache = {};
@@ -9521,6 +10142,7 @@ var MagmaClmmSDK = class {
    */
   _lock;
   _gauge;
+  _dlmm;
   /**
    * Provide interact  with a position rewarder interface.
    */
@@ -9558,6 +10180,7 @@ var MagmaClmmSDK = class {
     this._swap = new SwapModule(this);
     this._lock = new LockModule(this);
     this._gauge = new GaugeModule(this);
+    this._dlmm = new DlmmModule(this);
     this._pool = new PoolModule(this);
     this._position = new PositionModule(this);
     this._rewarder = new RewarderModule(this);
@@ -9595,6 +10218,9 @@ var MagmaClmmSDK = class {
   get Gauge() {
     return this._gauge;
   }
+  get Dlmm() {
+    return this._dlmm;
+  }
   /**
    * Getter for the fullClient property.
    * @returns {RpcModule} The fullClient property value.
@@ -9768,6 +10394,7 @@ var main_default = MagmaClmmSDK;
 var SDKConfig = {
   clmmConfig: {
     pools_id: "0xfa145b9de10fe858be81edd1c6cdffcf27be9d016de02a1345eb1009a68ba8b2",
+    // clmm and dlmm both use this global_config
     global_config_id: "0x4c4e1402401f72c7d8533d0ed8d5f8949da363c7a3319ccef261ffe153d32f8a",
     global_vault_id: "0xa7e1102f222b6eb81ccc8a126e7feb2353342be9df6f6646a77c4519da29c071",
     admin_cap_id: "0x89c1a321291d15ddae5a086c9abc533dff697fde3d89e0ca836c41af73e36a75"
@@ -9787,7 +10414,11 @@ var SDKConfig = {
     distribution_cfg: "0xaff8d151ac29317201151f97d28c546b3c5923d8cfc5499f40dea61c4022c949",
     magma_token: "0x7161c6c6bb65f852797c8f7f5c4f8d57adaf796e1b840921f9e23fabeadfd54e::magma::MAGMA",
     minter_id: "0x4fa5766cd83b33b215b139fec27ac344040f3bbd84fcbee7b61fc671aadc51fa"
-  }
+  },
+  dlmmConfig: {
+    factory: ""
+  },
+  gaugeConfig: {}
 };
 var clmmMainnet = {
   fullRpcUrl: getFullnodeUrl("mainnet"),
@@ -9804,6 +10435,11 @@ var clmmMainnet = {
     published_at: "0x4a35d3dfef55ed3631b7158544c6322a23bc434fe4fca1234cb680ce0505f82d",
     config: SDKConfig.clmmConfig
   },
+  dlmm_pool: {
+    package_id: "",
+    published_at: "",
+    config: SDKConfig.dlmmConfig
+  },
   distribution: {
     package_id: "0xee4a1f231dc45a303389998fe26c4e39278cf68b404b32e4f0b9769129b8267b",
     published_at: "0xee4a1f231dc45a303389998fe26c4e39278cf68b404b32e4f0b9769129b8267b"
@@ -9857,6 +10493,9 @@ var SDKConfig2 = {
     distribution_cfg: "0x94e23846c975e2faf89a61bfc2b10ad64decab9069eb1f9fc39752b010868c74",
     magma_token: "0x45ac2371c33ca0df8dc784d62c8ce5126d42edd8c56820396524dff2ae0619b1::magma_token::MAGMA_TOKEN",
     minter_id: "0x89435d6b2a510ba50ca23303f10e91ec058f138a88f69a43fe03cd22edb214c5"
+  },
+  dlmmConfig: {
+    factory: ""
   }
 };
 var clmmTestnet = {
@@ -9871,6 +10510,11 @@ var clmmTestnet = {
     published_at: "0x23e0b5ab4aa63d0e6fd98fa5e247bcf9b36ad716b479d39e56b2ba9ff631e09d",
     config: SDKConfig2.clmmConfig
   },
+  dlmm_pool: {
+    package_id: "",
+    published_at: "",
+    config: SDKConfig2.dlmmConfig
+  },
   distribution: {
     package_id: "0x45ac2371c33ca0df8dc784d62c8ce5126d42edd8c56820396524dff2ae0619b1",
     published_at: "0x45ac2371c33ca0df8dc784d62c8ce5126d42edd8c56820396524dff2ae0619b1"
@@ -9945,6 +10589,7 @@ export {
   DeepbookCustodianV2Moudle,
   DeepbookEndpointsV2Moudle,
   DeepbookUtils,
+  DlmmScript,
   FEE_RATE_DENOMINATOR,
   GAS_SYMBOL,
   GAS_TYPE_ARG,