@msafe/sui3-sdk 0.0.35 → 0.0.36

package/src/core/MSafeAccount.ts

@@ -1,5 +1,7 @@
+import { appHelpers } from '@msafe/sui-app-store';
 import {
   CoinTransferIntention,
+  IGasOption,
   IMSafeConfig,
   IProposeIntentionRequest,
   MultiSigAccount,
@@ -21,6 +23,7 @@ import { TransactionBlock } from '@mysten/sui.js/transactions';
 import { normalizeStructTag } from '@mysten/sui.js/utils';
 
 import { MSafeGlobals } from '@/globals/MSafeGlobals';
+import { Simulator } from '@/simulate/simulator';
 import { OwnedCoin } from '@/types/assets';
 import { Pagination, PendingTx, SimulationResult } from '@/types/msafe';
 import { CoinHelper } from '@/utils';
@@ -32,6 +35,8 @@ export class MSafeAccount {
 
   private coinHelper: CoinHelper;
 
+  private simulator: Simulator;
+
   constructor(
     public readonly globals: MSafeGlobals,
     public readonly info: IMSafeConfig,
@@ -42,6 +47,7 @@ export class MSafeAccount {
       creationNonce: info.creationNonce,
     });
     this.coinHelper = new CoinHelper(this.suiClient);
+    this.simulator = new Simulator(globals);
   }
 
   static async New(globals: MSafeGlobals, address: string) {
@@ -78,7 +84,6 @@ export class MSafeAccount {
     return getAllOwnedObjects(this.suiClient, this.address, filterCoinObjectOptions);
   }
 
-  // TODO: Calculate the votes
   async pendingTransaction(): Promise<PendingTx | undefined> {
     const res = await this.backend.getPendingTransactions({ msafeAddress: this.address });
     if (!res.pending) {
@@ -110,7 +115,6 @@ export class MSafeAccount {
     };
   }
 
-  // TODO: Calculate the votes.
   async historyTransaction(pagination?: Pagination) {
     return this.backend.getHistoryTransactions({
       msafeAddress: this.address,
@@ -130,6 +134,23 @@ export class MSafeAccount {
     return this.backend.getNextSequenceNumber(this.address);
   }
 
+  async simulateIntention(request: Omit<IProposeIntentionRequest, 'msafeAddress' | 'signature'>) {
+    const appHelper = appHelpers.getAppHelper(request.application);
+    if (!appHelper) {
+      throw new Error(`Can't find app helper for application ${request.application}`);
+    }
+    const txb = await appHelper.build({
+      intentionData: request.intention,
+      txType: request.txType,
+      txSubType: request.txSubType,
+      suiClient: this.globals.suiClient,
+      account: {
+        address: this.address,
+      },
+    });
+    return this.simulator.simulate({ txb, sender: this.address });
+  }
+
   async proposeIntention(input: Omit<IProposeIntentionRequest, 'signature' | 'msafeAddress'>) {
     const message = SigningMessageHelper.proposeIntentionMessage({
       msafeAddress: this.address,
@@ -140,13 +161,24 @@ export class MSafeAccount {
       messageStr: message,
     });
 
-    await this.backend.proposeIntention({
+    return this.backend.proposeIntention({
       ...input,
       msafeAddress: this.address,
       signature: signature.signature,
     });
   }
 
+  async simulateCoinTransferIntention(intention: CoinTransferIntention) {
+    const sn = await this.nextSequenceNumber();
+    return this.simulateIntention({
+      application: TransactionDefaultApplication,
+      txType: TransactionType.Assets,
+      txSubType: TransactionSubTypes.assets.coin.send,
+      sequenceNumber: sn,
+      intention,
+    });
+  }
+
   async proposeCoinTransferIntention(intention: CoinTransferIntention) {
     const sn = await this.nextSequenceNumber();
     return this.proposeIntention({
@@ -234,37 +266,36 @@ export class MSafeAccount {
     });
   }
 
-  async buildNextIntentionAndAddToPending() {
-    return this.backend.buildNextIntentionAndAddToPending({ msafeAddress: this.address });
-  }
+  async simulateBuildTransaction(): Promise<SimulationResult> {
+    const intention = await this.backend.getNextIntention({ msafeAddress: this.address });
 
-  async skipNextFailedIntention() {
-    return this.backend.skipNextFailedIntention({ msafeAddress: this.address });
-  }
-
-  async simulateIntention(): Promise<SimulationResult> {
-    // Todo, move to API
-    const txb = new TransactionBlock(); // await buildIntentionTransaction(this.suiClient, intention, this.address);
-    txb.setSender(this.address);
-    if (!txb.blockData.gasConfig.price) {
-      const refGas = await this.suiClient.getReferenceGasPrice();
-      txb.setGasPrice(refGas);
+    const appHelper = appHelpers.getAppHelper(intention.application);
+    if (!appHelper) {
+      throw new Error(`Can't find app helper for application ${intention.application}`);
     }
-    const payload = await txb.build({ client: this.suiClient });
-    const dryRunResult = await this.suiClient.dryRunTransactionBlock({ transactionBlock: payload });
+    const txb = await appHelper.build({
+      intentionData: intention.intention,
+      txType: intention.txType as TransactionType,
+      txSubType: intention.txSubType,
+      suiClient: this.globals.suiClient,
+      account: {
+        address: this.address,
+      },
+    });
+    return this.simulator.simulate({ txb, sender: this.address });
+  }
 
-    const success = dryRunResult.effects.status.status === 'success';
-    const errorMsg = dryRunResult.effects.status.error;
-    const gasPrice = BigInt(txb.blockData.gasConfig.price as string);
-    const { gasUsed } = dryRunResult.effects;
+  async buildNextIntentionAndAddToPending(gasOption: IGasOption & { forceBuild: boolean }) {
+    return this.backend.buildNextIntentionAndAddToPending({
+      msafeAddress: this.address,
+      forceBuild: gasOption.forceBuild,
+      gasPrice: gasOption.gasPrice,
+      gasBudget: gasOption.gasBudget,
+    });
+  }
 
-    return {
-      success,
-      errorMsg,
-      gasPrice,
-      gasUsed,
-      dryRunResult,
-    };
+  async skipNextFailedIntention() {
+    return this.backend.skipNextFailedIntention({ msafeAddress: this.address });
   }
 
   async executePendingTx(pending: PendingTx, isRejectTx: boolean = false) {

package/src/globals/const.ts

@@ -24,7 +24,6 @@ export interface MSafeConfigOptions {
     url?: string;
   };
 }
-export const MSAFE_APPLICATION = 'msafe';
 
 export const TESTNET_RPC_URL = 'https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD';
 export const MAINNET_RPC_URL = 'https://sui-mainnet.blockvision.org/v1/2Sgk7NPvqkd7mESYkxF01yX15l7';

package/src/simulate/simulator.ts

@@ -0,0 +1,131 @@
+import { GasCostSummary } from '@mysten/sui.js/client';
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+
+// Default to 120% o the reference gas price
+import { MSafeGlobals } from '@/globals/MSafeGlobals';
+import { SimulationResult } from '@/types';
+
+// Gas price option can be either a multiplier or a fixed amount
+export type GasPriceOption = MultiplierOption | FixedValueOption;
+
+// Gas budget option can be either a multiplier or a fixed amount
+export type GasBudgetOption = MultiplierOption | FixedValueOption;
+
+export interface MultiplierOption {
+  multiplier: {
+    numerator: bigint;
+    denominator: bigint;
+  };
+}
+
+export interface FixedValueOption {
+  fixedVal: bigint;
+}
+
+const GAS_SAFE_OVERHEAD = 1000n;
+// Default to 120% of the reference gas price
+export const DEF_GAS_PRICE_NUM = 120n;
+export const DEF_GAS_PRICE_DEN = 100n;
+
+export const DEF_GAS_PRICE_OPTION: GasPriceOption = {
+  multiplier: {
+    numerator: DEF_GAS_PRICE_NUM,
+    denominator: DEF_GAS_PRICE_DEN,
+  },
+};
+
+// Default to 120% of the reference gas budget
+export const DEF_GAS_BUDGET_NUM = 120n;
+export const DEF_GAS_BUDGET_DEN = 100n;
+
+export const DEF_GAS_BUDGET_OPTION: GasBudgetOption = {
+  multiplier: {
+    numerator: DEF_GAS_BUDGET_NUM,
+    denominator: DEF_GAS_BUDGET_DEN,
+  },
+};
+
+export class Simulator {
+  constructor(private globals: MSafeGlobals) {}
+
+  public async simulate(
+    input: {
+      txb: TransactionBlock;
+      sender: string;
+    },
+    options: GasPriceOption = DEF_GAS_PRICE_OPTION,
+  ): Promise<SimulationResult> {
+    const tx = this.copyTransactionBlock(input.txb);
+
+    const { suiClient } = this.globals;
+
+    const gasPrice = await this.getGasPrice(options);
+    tx.setGasPrice(gasPrice);
+
+    const inspectResult = await suiClient.devInspectTransactionBlock({ transactionBlock: tx, sender: input.sender });
+    const { gasUsed } = inspectResult.effects;
+    const gasBudget = this.toGasBudget(gasUsed, gasPrice);
+    const success = inspectResult.effects.status.status === 'success';
+    let error: string | undefined;
+
+    if (!success) {
+      error = inspectResult.effects.status.error;
+    }
+
+    return {
+      success,
+      gasPrice,
+      gasObject: inspectResult.effects.gasObject.reference,
+      gasUsed,
+      gasBudget,
+      simulationError: error,
+    };
+  }
+
+  private async getGasPrice(option: GasPriceOption) {
+    if (this.isFixedValue(option)) {
+      return option.fixedVal;
+    }
+
+    const refGasPrice = await this.globals.suiClient.getReferenceGasPrice();
+
+    return this.applyGasOption(refGasPrice, option);
+  }
+
+  private toGasBudget(gasUsed: GasCostSummary, gasPrice: bigint) {
+    const { computationCost, storageCost } = gasUsed;
+    const safeOverhead = GAS_SAFE_OVERHEAD * gasPrice;
+
+    const baseComputationCostWithOverhead = BigInt(computationCost) + safeOverhead;
+
+    // do not subtract rebate for now, because it may cause normally tx gas to be lower than empty tx gas
+    // const gasBudget = baseComputationCostWithOverhead + BigInt(storageCost) - BigInt(storageRebate);
+    const gasBudget = baseComputationCostWithOverhead + BigInt(storageCost);
+
+    // Set the budget to max(computation, computation + storage - rebate)
+    return gasBudget > baseComputationCostWithOverhead ? gasBudget : baseComputationCostWithOverhead;
+  }
+
+  private isFixedValue(option: GasPriceOption | GasBudgetOption): option is FixedValueOption {
+    return 'fixedVal' in option;
+  }
+
+  private isMultiplier(option: GasPriceOption | GasBudgetOption): option is MultiplierOption {
+    return 'multiplier' in option;
+  }
+
+  private applyGasOption(val: bigint, option: GasPriceOption) {
+    if (this.isFixedValue(option)) {
+      return option.fixedVal;
+    }
+    if (this.isMultiplier(option)) {
+      const { multiplier } = option;
+      return (val * multiplier.numerator) / multiplier.denominator;
+    }
+    throw new Error('Sanity: Unknown gas price option');
+  }
+
+  private copyTransactionBlock(tx: TransactionBlock): TransactionBlock {
+    return TransactionBlock.from(tx.serialize());
+  }
+}

package/src/types/msafe.ts

@@ -1,5 +1,5 @@
-import { TransactionType, TxIntention } from '@msafe/sui3-utils';
-import { DryRunTransactionBlockResponse, GasCostSummary } from '@mysten/sui.js/client';
+import { IGasOption, TransactionType, TxIntention } from '@msafe/sui3-utils';
+import { GasCostSummary, SuiObjectRef } from '@mysten/sui.js/client';
 import { SerializedSignature } from '@mysten/sui.js/cryptography';
 
 export interface PendingTx {
@@ -81,12 +81,15 @@ export interface ProposeIntention {
 
 export interface SimulationResult {
   success: boolean;
-  errorMsg?: string;
-  // gas price for the simulation
   gasPrice: bigint;
-  // detailed gas cost summary
   gasUsed: GasCostSummary;
-  dryRunResult: DryRunTransactionBlockResponse;
+  gasBudget: bigint;
+  gasObject: SuiObjectRef;
+  simulationError?: string;
+}
+
+export interface SimulationOption extends IGasOption {
+  simulation: boolean;
 }
 
 export interface Pagination {