@msafe/sui3-sdk 0.0.75 → 0.0.77

package/src/simulate/simulator.ts

@@ -5,162 +5,62 @@ import { TransactionBlock } from '@mysten/sui.js/transactions';
 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;
-    },
-    gasOption: GasPriceOption = DEF_GAS_PRICE_OPTION,
-    budgetOption: GasBudgetOption = DEF_GAS_BUDGET_OPTION,
-  ): Promise<SimulationResult> {
+  public async simulate(input: { txb: TransactionBlock; sender: string }): Promise<SimulationResult> {
     const tx = this.copyTransactionBlock(input.txb);
 
     const { suiClient } = this.globals;
 
-    const gasPrice = await this.getGasPrice(gasOption);
+    const gasPrice = await this.getGasPrice();
 
-    // temporary disable gas price setting, unblock alphafi simulate error issue
-    // tx.setGasPrice(gasPrice);
+    tx.setGasPrice(gasPrice);
 
-    try {
-      const inspectResult = await suiClient.dryRunTransactionBlock({
-        transactionBlock: await tx.build({ client: suiClient }),
-      });
-      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;
-      }
+    const inspectResult = await suiClient.dryRunTransactionBlock({
+      transactionBlock: await tx.build({ client: suiClient }),
+    });
+    const success = inspectResult.effects.status.status === 'success';
 
+    if (!success) {
       return {
         success,
         gasPrice,
-        gasObject: inspectResult.effects.gasObject.reference,
-        gasUsed,
-        gasBudget: this.applyBudgetOption(gasBudget, budgetOption),
-        simulationError: error,
         response: inspectResult,
+        simulationError: inspectResult.effects.status.error!,
       };
-    } catch (err) {
-      if (err instanceof Error) {
-        return {
-          success: false,
-          gasObject: { digest: '', objectId: '', version: '' },
-          gasPrice: 0n,
-          gasBudget: 0n,
-          gasUsed: {
-            computationCost: '',
-            nonRefundableStorageFee: '',
-            storageCost: '',
-            storageRebate: '',
-          },
-          simulationError: err.message,
-        };
-      }
-      throw err;
     }
+    const gasBudget = this.toGasBudget(inspectResult.effects.gasUsed, gasPrice);
+
+    return {
+      success,
+      gasPrice,
+      gasObject: inspectResult.effects.gasObject.reference,
+      gasUsed: inspectResult.effects.gasUsed,
+      gasBudget,
+      response: inspectResult,
+    };
   }
 
-  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 async getGasPrice() {
+    return this.globals.suiClient.getReferenceGasPrice();
   }
 
   private toGasBudget(gasUsed: GasCostSummary, gasPrice: bigint) {
-    const { computationCost, storageCost } = gasUsed;
+    const { computationCost, storageCost, storageRebate } = 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);
+    const gasBudget = baseComputationCostWithOverhead + BigInt(storageCost) - BigInt(storageRebate);
 
     // 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 applyBudgetOption(val: bigint, option: GasBudgetOption) {
-    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 budget option');
-  }
-
   private copyTransactionBlock(tx: TransactionBlock): TransactionBlock {
     return TransactionBlock.from(tx.serialize());
   }

package/src/types/msafe.ts

@@ -80,14 +80,22 @@ export interface ProposeIntention {
   signature: SerializedSignature;
 }
 
-export interface SimulationResult {
-  success: boolean;
+export type SimulationResult = SimulationSuccessResult | SimulationFailedResult;
+
+export interface SimulationSuccessResult {
+  success: true;
   gasPrice: bigint;
   gasUsed: GasCostSummary;
   gasBudget: bigint;
   gasObject: SuiObjectRef;
-  simulationError?: string;
-  response?: DryRunTransactionBlockResponse;
+  response: DryRunTransactionBlockResponse;
+}
+
+export interface SimulationFailedResult {
+  success: false;
+  gasPrice: bigint;
+  response: DryRunTransactionBlockResponse;
+  simulationError: string;
 }
 
 export interface SimulationOption extends IGasOption {