@magmaprotocol/magma-clmm-sdk 0.5.33 → 0.5.34

package/dist/index.d.ts

@@ -3026,6 +3026,8 @@ declare class SwapModule implements IModule {
     }>;
 }
 
+type LockID = string;
+type PoolID = string;
 type LocksInfo = {
     owner: string;
     lockInfo: LockInfo[];
@@ -3100,15 +3102,33 @@ declare class LockModule implements IModule {
     claimVotingBribe(locks: string[], incentive_tokens: string[]): Promise<Transaction>;
     claimVotingFeeAndBribeForPool(lockId: string, poolId: string, feeTokens: string[], incentiveTokens: string[]): Promise<Transaction>;
     fastLocksOfUser(user: string): Promise<LocksInfo>;
+    locksOfUserV2(user: string): Promise<LocksInfo>;
     locksOfUser(user: string): Promise<LocksInfo>;
     aLockInfo(lockId: string): Promise<LockInfo>;
     aLockSummary(lock_id: string): Promise<ALockSummary>;
+    getAllLockSummary(lock_ids: string[]): Promise<Map<LockID, ALockSummary>>;
+    _aLockSummary(lock_id: string, tx?: Transaction): Promise<Transaction>;
+    _parseLockSummary(tx: Transaction): Promise<Map<LockID, ALockSummary>>;
     allLockSummary(): Promise<AllLockSummary>;
     poolWeights(pools: string[]): Promise<PoolWeight[]>;
+    getAllVotingFeeRewardTokens(lock_ids: string[]): Promise<Map<LockID, string[]>>;
+    _getVotingFeeRewardTokens(lock_id: string, tx?: Transaction): Promise<Transaction>;
+    _parseVotingFeeRewardTokens(tx: Transaction): Promise<Map<LockID, string[]>>;
     getVotingFeeRewardTokens(lock_id: string): Promise<Map<string, string[]>>;
+    getAllBribeRewardTokensOfLock(lock_ids: string[]): Promise<Map<LockID, string[]>>;
+    _getVotingBribeRewardTokens(lock_id: string, tx?: Transaction): Promise<Transaction>;
+    _parseVotingBribeRewardTokens(tx: Transaction): Promise<Map<LockID, string[]>>;
     getVotingBribeRewardTokens(lock_id: string): Promise<Map<string, string[]>>;
-    getPoolFeeRewards(lock_id: string, tokens: string[]): Promise<Map<string, Map<string, string>>>;
+    getAllFeeRewards(fee_tokens: Map<LockID, string[]>): Promise<Map<LockID, Map<PoolID, Coin[]>>>;
+    _getFeeRewards(lock_id: string, fee_tokens: string[], tx: Transaction): Transaction;
+    _getFeeRewardsInner(lock_id: LockID, token_a: string, token_b: string, tx?: Transaction): Transaction;
+    _parseFeeRewards(tx: Transaction): Promise<Map<LockID, Map<PoolID, Coin[]>>>;
+    getPoolFeeRewards(lock_id: LockID, tokens: string[]): Promise<Map<string, Map<string, string>>>;
     _getPoolFeeRewards(lock_id: string, token_a: string, token_b: string, poolFeeRewardTokens: Map<string, Map<string, string>>): Promise<Map<string, Map<string, string>>>;
+    getAllIncentiveRewards(lock_incentive_tokens: Map<LockID, string[]>): Promise<Map<LockID, Map<PoolID, Coin[]>>>;
+    _getIncentiveRewards(lock_id: string, incentive_tokens: string[], tx?: Transaction): Transaction;
+    _getIncentiveRewardsInner(locksId: string, incentive_tokens: string[], tx?: Transaction): Transaction;
+    _parseIncentiveRewards(tx: Transaction): Promise<Map<LockID, Map<PoolID, Coin[]>>>;
     getPoolIncentiveRewards(lock_id: string, incentive_tokens: string[]): Promise<Map<string, Map<string, string>>>;
     _getPoolIncentiveRewards(locksId: string, incentive_tokens: string[], poolBribeRewardTokens: Map<string, Map<string, string>>): Promise<Map<string, Map<string, string>>>;
     getPoolBribeRewardTokens(pool_id: string): Promise<Map<string, string[]>>;
@@ -3352,6 +3372,7 @@ declare class GaugeModule implements IModule {
     getPoolCoins(pools: string[]): Promise<Map<string, string[]>>;
     getEmissions(): Promise<EpochEmission>;
     getRewardByPosition(params: GetRewardByPosition): Promise<Transaction>;
+    getAllRewardByPositions(paramsList: GetRewardByPosition[]): Promise<Transaction>;
     getEpochRewardByPool(pool: string, incentive_tokens: string[]): Promise<Map<string, string>>;
 }
 

package/dist/index.js

@@ -7594,6 +7594,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;
@@ -7786,6 +7837,57 @@ var LockModule = class {
     });
     return res;
   }
+  // Return: lock_id => ALockSummary
+  async getAllLockSummary(lock_ids) {
+    let tx = new import_transactions9.Transaction();
+    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 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];
+    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 import_transactions9.Transaction();
     const { integrate, simulationAccount } = this.sdk.sdkOptions;
@@ -7866,6 +7968,54 @@ var LockModule = class {
     });
     return poolWeights;
   }
+  async getAllVotingFeeRewardTokens(lock_ids) {
+    let tx = new import_transactions9.Transaction();
+    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 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)];
+    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 import_transactions9.Transaction();
     const { integrate, simulationAccount } = this.sdk.sdkOptions;
@@ -7889,7 +8039,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, []);
@@ -7902,20 +8052,70 @@ var LockModule = class {
     });
     return poolRewardTokens;
   }
-  async getVotingBribeRewardTokens(lock_id) {
-    const tx = new import_transactions9.Transaction();
+  // tokens
+  async getAllBribeRewardTokensOfLock(lock_ids) {
+    let tx = new import_transactions9.Transaction();
+    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 import_transactions9.Transaction();
     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 import_transactions9.Transaction();
+    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
@@ -7925,7 +8125,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, []);
@@ -7938,6 +8138,68 @@ var LockModule = class {
     });
     return poolBirbeRewardTokens;
   }
+  async getAllFeeRewards(fee_tokens) {
+    let tx = new import_transactions9.Transaction();
+    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 import_transactions9.Transaction();
+    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) {
@@ -7988,6 +8250,78 @@ var LockModule = class {
     });
     return poolFeeRewardTokens;
   }
+  // params: lock_id => incentive_tokens
+  // lock_id => Pool => rewardTokens
+  async getAllIncentiveRewards(lock_incentive_tokens) {
+    let tx = new import_transactions9.Transaction();
+    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 import_transactions9.Transaction();
+    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) {
@@ -8014,14 +8348,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
@@ -9668,6 +10002,21 @@ var GaugeModule = class {
     });
     return tx;
   }
+  async getAllRewardByPositions(paramsList) {
+    const tx = new import_transactions11.Transaction();
+    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 import_transactions11.Transaction();
     const { integrate, simulationAccount } = this.sdk.sdkOptions;