@magmaprotocol/magma-clmm-sdk 0.5.40 → 0.5.42

package/dist/index.d.ts

@@ -3549,9 +3549,9 @@ type FetchBinsParams = {
 };
 type GetPositionLiquidityParams = {
     pair: string;
+    positionId: string;
     coinTypeA: string;
     coinTypeB: string;
-    positionId: string;
 };
 type GetPairLiquidityParams = {
     pair: string;
@@ -3616,6 +3616,72 @@ type DlmmPoolInfo = {
     base_fee: number;
     active_index: number;
 };
+type DlmmAddLiquidityParams = {
+    pool_id: string;
+    coin_a: string;
+    coin_b: string;
+    position_id: string;
+    amounts_a: number[];
+    amounts_b: number[];
+    receiver: string;
+    rewards_token: string[];
+};
+type DlmmBurnPositionParams = {
+    pool_id: string;
+    position_id: string;
+    coin_a: string;
+    coin_b: string;
+    rewards_token: string[];
+};
+type DlmmShrinkPosition = {
+    pool_id: string;
+    position_id: string;
+    coin_a: string;
+    coin_b: string;
+    delta_percentage: number;
+    rewards_token: string[];
+};
+type DlmmCollectRewardParams = {
+    pool_id: string;
+    coin_a: string;
+    coin_b: string;
+    position_id: string;
+    rewards_token: string[];
+};
+type DlmmCollectFeeParams = {
+    pool_id: string;
+    coin_a: string;
+    coin_b: string;
+    position_id: string;
+};
+type DlmmRewardsParams = {
+    pool_id: string;
+    position_id: string;
+    coin_a: string;
+    coin_b: string;
+    rewards_token: string[];
+};
+type DlmmEventEarnedFees = {
+    position_id: string;
+    x: string;
+    y: string;
+    fee_x: number;
+    fee_y: number;
+};
+type DlmmEventEarnedRewards = {
+    position_id: string;
+    reward: string[];
+    amount: number[];
+};
+type GetPairRewarderParams = {
+    pool_id: string;
+    coin_a: string;
+    coin_b: string;
+};
+type DlmmEventPairRewardTypes = {
+    pair_id: string;
+    tokens: string[];
+};
 
 declare class DlmmModule implements IModule {
     protected _sdk: MagmaClmmSDK;
@@ -3628,10 +3694,22 @@ declare class DlmmModule implements IModule {
     createAddLiquidityPayload(): Promise<Transaction>;
     mintPercent(params: MintPercentParams): Promise<Transaction>;
     createPositionByAmount(params: MintAmountParams): Promise<Transaction>;
+    addLiquidity(params: DlmmAddLiquidityParams): Promise<Transaction>;
+    private _raisePositionByAmounts;
+    private _raisePositionByAmountsReward;
+    burnPosition(params: DlmmBurnPositionParams): Promise<Transaction>;
+    shrinkPosition(params: DlmmShrinkPosition): Promise<Transaction>;
+    collectReward(params: DlmmCollectRewardParams): Promise<Transaction>;
+    collectFees(params: DlmmCollectFeeParams): Promise<Transaction>;
     swap(params: SwapParams): Promise<Transaction>;
     fetchBins(params: FetchBinsParams): Promise<EventBin[]>;
     getPositionLiquidity(params: GetPositionLiquidityParams): Promise<EventPositionLiquidity>;
     getPairLiquidity(params: GetPairLiquidityParams): Promise<EventPairLiquidity>;
+    getEarnedFees(params: DlmmCollectFeeParams): Promise<DlmmEventEarnedFees>;
+    getEarnedRewards(params: DlmmRewardsParams): Promise<DlmmEventEarnedRewards>;
+    getPairRewarders(params: GetPairRewarderParams[]): Promise<Map<string, DlmmEventPairRewardTypes[]>>;
+    private _getPairRewarders;
+    private _parsePairRewarders;
 }
 
 /**

package/dist/index.js

@@ -10865,6 +10865,153 @@ var DlmmModule = class {
     });
     return tx;
   }
+  async addLiquidity(params) {
+    if (params.rewards_token.length === 0) {
+      return this._raisePositionByAmounts(params);
+    }
+    return this._raisePositionByAmountsReward(params);
+  }
+  async _raisePositionByAmounts(params) {
+    const tx = new import_transactions12.Transaction();
+    tx.setSender(this.sdk.senderAddress);
+    const { dlmm_pool, integrate } = this.sdk.sdkOptions;
+    const dlmmConfig = getPackagerConfigs(dlmm_pool);
+    const typeArguments = [params.coin_a, params.coin_b];
+    const allCoins = await this._sdk.getOwnerCoinAssets(this._sdk.senderAddress);
+    const amountATotal = params.amounts_a.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+    const amountBTotal = params.amounts_b.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+    const primaryCoinAInputs = TransactionUtil.buildCoinForAmount(tx, allCoins, BigInt(amountATotal), params.coin_a, false, true);
+    const primaryCoinBInputs = TransactionUtil.buildCoinForAmount(tx, allCoins, BigInt(amountBTotal), params.coin_b, false, true);
+    const args = [
+      tx.object(params.pool_id),
+      tx.object(dlmmConfig.factory),
+      tx.object(params.position_id),
+      primaryCoinAInputs.targetCoin,
+      primaryCoinBInputs.targetCoin,
+      tx.pure.vector("u64", params.amounts_a),
+      tx.pure.vector("u64", params.amounts_b),
+      tx.pure.address(params.receiver),
+      tx.object(CLOCK_ADDRESS)
+    ];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::raise_position_by_amounts`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  async _raisePositionByAmountsReward(params) {
+    const tx = new import_transactions12.Transaction();
+    tx.setSender(this.sdk.senderAddress);
+    const { dlmm_pool, integrate, clmm_pool } = this.sdk.sdkOptions;
+    const dlmmConfig = getPackagerConfigs(dlmm_pool);
+    const clmmConfigs = getPackagerConfigs(clmm_pool);
+    const typeArguments = [params.coin_a, params.coin_b, ...params.rewards_token];
+    const allCoins = await this._sdk.getOwnerCoinAssets(this._sdk.senderAddress);
+    const amountATotal = params.amounts_a.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+    const amountBTotal = params.amounts_b.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+    const primaryCoinAInputs = TransactionUtil.buildCoinForAmount(tx, allCoins, BigInt(amountATotal), params.coin_a, false, true);
+    const primaryCoinBInputs = TransactionUtil.buildCoinForAmount(tx, allCoins, BigInt(amountBTotal), params.coin_b, false, true);
+    const args = [
+      tx.object(params.pool_id),
+      tx.object(dlmmConfig.factory),
+      tx.object(clmmConfigs.global_vault_id),
+      tx.object(params.position_id),
+      primaryCoinAInputs.targetCoin,
+      primaryCoinBInputs.targetCoin,
+      tx.pure.vector("u64", params.amounts_a),
+      tx.pure.vector("u64", params.amounts_b),
+      tx.pure.address(params.receiver),
+      tx.object(CLOCK_ADDRESS)
+    ];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::raise_position_by_amounts_reward${params.rewards_token.length}`,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  async burnPosition(params) {
+    const tx = new import_transactions12.Transaction();
+    tx.setSender(this.sdk.senderAddress);
+    const { integrate, clmm_pool } = this.sdk.sdkOptions;
+    const clmmConfigs = getPackagerConfigs(clmm_pool);
+    const typeArguments = [params.coin_a, params.coin_b, ...params.rewards_token];
+    let args = [tx.object(params.pool_id), tx.object(params.position_id), tx.object(CLOCK_ADDRESS)];
+    let target = `${integrate.published_at}::${DlmmScript}::burn_position`;
+    if (params.rewards_token.length > 0) {
+      args = [tx.object(params.pool_id), tx.object(clmmConfigs.global_vault_id), tx.object(params.position_id), tx.object(CLOCK_ADDRESS)];
+      target = `${integrate.published_at}::${DlmmScript}::burn_position_reward${params.rewards_token.length}`;
+    }
+    tx.moveCall({
+      target,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  async shrinkPosition(params) {
+    const tx = new import_transactions12.Transaction();
+    tx.setSender(this.sdk.senderAddress);
+    const { integrate, clmm_pool } = this.sdk.sdkOptions;
+    const clmmConfigs = getPackagerConfigs(clmm_pool);
+    const typeArguments = [params.coin_a, params.coin_b, ...params.rewards_token];
+    let args = [tx.object(params.pool_id), tx.object(params.position_id), tx.pure.u64(params.delta_percentage), tx.object(CLOCK_ADDRESS)];
+    let target = `${integrate.published_at}::${DlmmScript}::shrink_position`;
+    if (params.rewards_token.length > 0) {
+      args = [
+        tx.object(params.pool_id),
+        tx.object(clmmConfigs.global_vault_id),
+        tx.object(params.position_id),
+        tx.pure.u64(params.delta_percentage),
+        tx.object(CLOCK_ADDRESS)
+      ];
+      target = `${integrate.published_at}::${DlmmScript}::shrink_position_reward${params.rewards_token.length}`;
+    }
+    tx.moveCall({
+      target,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  async collectReward(params) {
+    const tx = new import_transactions12.Transaction();
+    tx.setSender(this.sdk.senderAddress);
+    const { integrate, clmm_pool } = this.sdk.sdkOptions;
+    const clmmConfigs = getPackagerConfigs(clmm_pool);
+    const typeArguments = [params.coin_a, params.coin_b, ...params.rewards_token];
+    const args = [
+      tx.object(params.pool_id),
+      tx.object(clmmConfigs.global_vault_id),
+      tx.object(params.position_id),
+      tx.object(CLOCK_ADDRESS)
+    ];
+    let target = `${integrate.published_at}::${DlmmScript}::collect_reward`;
+    if (params.rewards_token.length > 1) {
+      target = `${integrate.published_at}::${DlmmScript}::collect_reward${params.rewards_token.length}`;
+    }
+    tx.moveCall({
+      target,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
+  async collectFees(params) {
+    const tx = new import_transactions12.Transaction();
+    tx.setSender(this.sdk.senderAddress);
+    const { integrate } = this.sdk.sdkOptions;
+    const typeArguments = [params.coin_a, params.coin_b];
+    const args = [tx.object(params.pool_id), tx.object(params.position_id), tx.object(CLOCK_ADDRESS)];
+    const target = `${integrate.published_at}::${DlmmScript}::collect_fees`;
+    tx.moveCall({
+      target,
+      typeArguments,
+      arguments: args
+    });
+    return tx;
+  }
   async swap(params) {
     const tx = new import_transactions12.Transaction();
     tx.setSender(this.sdk.senderAddress);
@@ -10906,9 +11053,11 @@ var DlmmModule = class {
     if (simulateRes.error != null) {
       throw new Error(`fetchBins error code: ${simulateRes.error ?? "unknown error"}`);
     }
-    const res = [];
+    let res = [];
     simulateRes.events?.forEach((item) => {
       if (extractStructTagFromType(item.type).name === `EventFetchBins`) {
+        const { bins } = item.parsedJson;
+        res = bins;
       }
     });
     return res;
@@ -10946,7 +11095,7 @@ var DlmmModule = class {
         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_ids = item.parsedJson.bin_ids;
         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;
@@ -10993,6 +11142,127 @@ var DlmmModule = class {
     });
     return out;
   }
+  async getEarnedFees(params) {
+    const tx = new import_transactions12.Transaction();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const typeArguments = [params.coin_a, params.coin_b];
+    const args = [tx.object(params.pool_id), tx.object(params.position_id)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::earned_fees`,
+      arguments: args,
+      typeArguments
+    });
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    const out = {
+      position_id: "",
+      x: "",
+      y: "",
+      fee_x: 0,
+      fee_y: 0
+    };
+    if (simulateRes.error != null) {
+      throw new Error(`fetchBins error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `EventPositionLiquidity`) {
+        out.position_id = item.parsedJson.position_id;
+        out.x = item.parsedJson.x;
+        out.y = item.parsedJson.y;
+        out.fee_x = item.parsedJson.fee_x;
+        out.fee_y = item.parsedJson.fee_y;
+      }
+    });
+    return out;
+  }
+  async getEarnedRewards(params) {
+    const tx = new import_transactions12.Transaction();
+    const { integrate, simulationAccount } = this.sdk.sdkOptions;
+    const typeArguments = [params.coin_a, params.coin_b, ...params.rewards_token];
+    const args = [tx.object(params.pool_id), tx.object(params.position_id)];
+    let target = `${integrate.published_at}::${DlmmScript}::earned_rewards`;
+    if (params.rewards_token.length > 1) {
+      target = `${integrate.published_at}::${DlmmScript}::earned_rewards${params.rewards_token.length}`;
+    }
+    tx.moveCall({
+      target,
+      arguments: args,
+      typeArguments
+    });
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    const out = {
+      position_id: "",
+      reward: [],
+      amount: []
+    };
+    if (simulateRes.error != null) {
+      throw new Error(`fetchBins error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `DlmmEventEarnedRewards`) {
+        out.position_id = item.parsedJson.position_id;
+        out.reward = [item.parsedJson.reward];
+        out.amount = [item.parsedJson.amount];
+      } else if (extractStructTagFromType(item.type).name === `DlmmEventEarnedRewards2`) {
+        out.position_id = item.parsedJson.position_id;
+        out.reward = [item.parsedJson.reward1, item.parsedJson.reward2];
+        out.amount = [item.parsedJson.amount1, item.parsedJson.amount2];
+      } else if (extractStructTagFromType(item.type).name === `EventEarnedRewards3`) {
+        out.position_id = item.parsedJson.position_id;
+        out.reward = [item.parsedJson.reward1, item.parsedJson.reward2, item.parsedJson.reward3];
+        out.amount = [item.parsedJson.amount1, item.parsedJson.amount2, item.parsedJson.amount3];
+      }
+    });
+    return out;
+  }
+  async getPairRewarders(params) {
+    let tx = new import_transactions12.Transaction();
+    for (const param of params) {
+      tx = await this._getPairRewarders(param, tx);
+    }
+    return this._parsePairRewarders(tx);
+  }
+  async _getPairRewarders(params, tx) {
+    tx = tx || new import_transactions12.Transaction();
+    const { integrate } = this.sdk.sdkOptions;
+    const typeArguments = [params.coin_a, params.coin_b];
+    const args = [tx.object(params.pool_id)];
+    tx.moveCall({
+      target: `${integrate.published_at}::${DlmmScript}::get_pair_rewarders`,
+      arguments: args,
+      typeArguments
+    });
+    return tx;
+  }
+  async _parsePairRewarders(tx) {
+    const { simulationAccount } = this.sdk.sdkOptions;
+    const simulateRes = await this.sdk.fullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: simulationAccount.address
+    });
+    const out = /* @__PURE__ */ new Map();
+    if (simulateRes.error != null) {
+      throw new Error(`fetchBins error code: ${simulateRes.error ?? "unknown error"}`);
+    }
+    simulateRes.events?.forEach((item) => {
+      if (extractStructTagFromType(item.type).name === `EventPairRewardTypes`) {
+        const pairRewards = {
+          pair_id: "",
+          tokens: []
+        };
+        pairRewards.pair_id = item.parsedJson.pair_id;
+        item.parsedJson.tokens.contents.forEach((token) => {
+          pairRewards.tokens.push(token.name);
+        });
+      }
+    });
+    return out;
+  }
 };
 
 // src/sdk.ts