@msafe/sui3-sdk 1.0.15 → 1.0.18

package/dist/index.cjs

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   AddressBookSDK: () => AddressBookSDK,
+  COIN_RESERVATION_MAGIC: () => COIN_RESERVATION_MAGIC,
   COIN_TYPE_ARG_REGEX: () => COIN_TYPE_ARG_REGEX,
   Coin: () => Coin,
   CoinHelper: () => CoinHelper,
@@ -42,6 +43,7 @@ __export(src_exports, {
   HexToUint8Array: () => HexToUint8Array,
   InfoTypeEnabledDto: () => InfoTypeEnabledDto,
   InfoTypeKey: () => InfoTypeKey,
+  InsufficientGasFundsError: () => InsufficientGasFundsError,
   LOCAL_API_URL: () => LOCAL_API_URL,
   LOCAL_SYNCING_URL: () => LOCAL_SYNCING_URL,
   MAINNET_RPC_URL: () => MAINNET_RPC_URL,
@@ -59,11 +61,18 @@ __export(src_exports, {
   TESTNET_RPC_URL: () => TESTNET_RPC_URL,
   Uint8ArrayToHex: () => Uint8ArrayToHex,
   addPrefix: () => addPrefix,
+  computeGasBudget: () => computeGasBudget,
+  createCoinReservationRef: () => createCoinReservationRef,
+  estimateGasBudget: () => estimateGasBudget,
   getAllCoins: () => getAllCoins,
   getMSafeConfig: () => getMSafeConfig,
   getPublicKeyFromChain: () => getPublicKeyFromChain,
   httpUrlToGrpcBaseUrl: () => httpUrlToGrpcBaseUrl,
+  isCoinReservationDigest: () => isCoinReservationDigest,
   msafeChainToSuiNetwork: () => msafeChainToSuiNetwork,
+  preferClassicGasPayment: () => preferClassicGasPayment,
+  prepareGasFunding: () => prepareGasFunding,
+  selectGasFunding: () => selectGasFunding,
   stringToBuffer: () => stringToBuffer,
   toSuiTransaction: () => toSuiTransaction
 });
@@ -188,128 +197,93 @@ var InvitationSDK = class {
 // src/core/MSafeAccount.ts
 var import_sui_app_store = require("@msafe/sui-app-store");
 var import_sui3_utils4 = require("@msafe/sui3-utils");
-var import_transactions3 = require("@mysten/sui/transactions");
-var import_utils3 = require("@mysten/sui/utils");
+var import_transactions4 = require("@mysten/sui/transactions");
+var import_utils5 = require("@mysten/sui/utils");
 var import_wallet_standard = require("@mysten/wallet-standard");
 
 // src/simulate/simulator.ts
+var import_transactions2 = require("@mysten/sui/transactions");
+
+// src/utils/gasFunding.ts
 var import_transactions = require("@mysten/sui/transactions");
-var GAS_SAFE_OVERHEAD = 1000n;
-function formatExecutionError(error) {
-  return error.message;
-}
-function gasObjectToReference(gas) {
-  if (!gas?.objectId) {
-    throw new Error("Gas object missing from simulation effects");
-  }
-  const version = gas.outputVersion ?? gas.inputVersion ?? "0";
-  const digest = gas.outputDigest ?? gas.inputDigest ?? "";
-  return { objectId: gas.objectId, version, digest };
-}
-var Simulator = class {
-  constructor(globals) {
-    this.globals = globals;
-  }
-  async simulate(input) {
-    const tx = this.copyTransaction(input.txb);
-    const { suiClient } = this.globals;
-    const gasPrice = await this.getGasPrice();
-    tx.setGasPrice(gasPrice);
-    tx.setSender(input.sender);
-    let built;
-    try {
-      built = await tx.build({ client: suiClient });
-    } catch (e) {
-      const message = e instanceof Error ? e.message : String(e);
-      return {
-        success: false,
-        gasPrice,
-        simulationError: message
-      };
-    }
-    let inspectResult;
-    try {
-      inspectResult = await suiClient.simulateTransaction({
-        transaction: built,
-        include: {
-          effects: true,
-          balanceChanges: true,
-          events: true,
-          objectTypes: true,
-          transaction: true,
-          bcs: true,
-          commandResults: true
-        }
-      });
-    } catch (e) {
-      const message = e instanceof Error ? e.message : String(e);
-      return {
-        success: false,
-        gasPrice,
-        simulationError: message
-      };
-    }
-    const txRow = inspectResult.Transaction ?? inspectResult.FailedTransaction;
-    const { effects } = txRow;
-    if (!effects) {
-      throw new Error("simulateTransaction did not return effects");
-    }
-    const success = effects.status.success === true;
-    if (!success) {
-      const err = effects.status.success === false ? effects.status.error : null;
-      return {
-        success,
-        gasPrice,
-        response: inspectResult,
-        simulationError: err ? formatExecutionError(err) : "Simulation failed"
-      };
-    }
-    const gasBudget = this.toGasBudget(effects.gasUsed, gasPrice);
-    return {
-      success,
-      gasPrice,
-      gasObject: gasObjectToReference(effects.gasObject),
-      gasUsed: effects.gasUsed,
-      gasBudget,
-      response: inspectResult
-    };
-  }
-  async getGasPrice() {
-    const { referenceGasPrice } = await this.globals.suiClient.getReferenceGasPrice();
-    return BigInt(referenceGasPrice);
-  }
-  toGasBudget(gasUsed, gasPrice) {
-    const { computationCost, storageCost, storageRebate } = gasUsed;
-    const safeOverhead = GAS_SAFE_OVERHEAD * gasPrice;
-    const baseComputationCostWithOverhead = BigInt(computationCost) + safeOverhead;
-    const gasBudget = baseComputationCostWithOverhead + BigInt(storageCost) - BigInt(storageRebate);
-    return gasBudget > baseComputationCostWithOverhead ? gasBudget : baseComputationCostWithOverhead;
-  }
-  copyTransaction(tx) {
-    return import_transactions.Transaction.from(tx);
-  }
-};
+var import_utils4 = require("@mysten/sui/utils");
 
-// src/utils/buffer.ts
-var import_buffer = require("buffer");
-function stringToBuffer(s) {
-  return import_buffer.Buffer.from(s, "utf-8");
+// src/utils/coinReservation.ts
+var import_bcs = require("@mysten/sui/bcs");
+var import_utils = require("@mysten/sui/utils");
+var SUI_ACCUMULATOR_ROOT_OBJECT_ID = (0, import_utils.normalizeSuiAddress)("0xacc");
+var ACCUMULATOR_KEY_TYPE_TAG = import_bcs.TypeTagSerializer.parseFromStr(
+  "0x2::accumulator::Key<0x2::balance::Balance<0x2::sui::SUI>>"
+);
+var COIN_RESERVATION_MAGIC = new Uint8Array([
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172,
+  172
+]);
+function isCoinReservationDigest(digestBase58) {
+  const digestBytes = (0, import_utils.fromBase58)(digestBase58);
+  const last20Bytes = digestBytes.slice(12, 32);
+  return last20Bytes.every((byte, i) => byte === COIN_RESERVATION_MAGIC[i]);
 }
-function Uint8ArrayToHex(b) {
-  return `0x${Array.prototype.map.call(b, (x) => `0${x.toString(16)}`.slice(-2)).join("")}`;
+function deriveReservationObjectId(owner, chainIdentifier) {
+  const keyBcs = import_bcs.bcs.Address.serialize(owner).toBytes();
+  const accumulatorId = (0, import_utils.deriveDynamicFieldID)(SUI_ACCUMULATOR_ROOT_OBJECT_ID, ACCUMULATOR_KEY_TYPE_TAG, keyBcs);
+  const accBytes = (0, import_utils.fromHex)(accumulatorId.slice(2));
+  const chainBytes = (0, import_utils.fromBase58)(chainIdentifier);
+  if (chainBytes.length !== 32) {
+    throw new Error(`Invalid chain identifier length: expected 32 bytes, got ${chainBytes.length}`);
+  }
+  const xored = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    xored[i] = accBytes[i] ^ chainBytes[i];
+  }
+  return `0x${(0, import_utils.toHex)(xored)}`;
 }
-function HexToUint8Array(hex) {
-  return Uint8Array.from(import_buffer.Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex"));
+function createCoinReservationRef(reservedBalance, owner, chainIdentifier, epoch) {
+  const digestBytes = new Uint8Array(32);
+  const view = new DataView(digestBytes.buffer);
+  view.setBigUint64(0, reservedBalance, true);
+  const epochNum = Number(epoch);
+  if (!Number.isSafeInteger(epochNum) || epochNum < 0 || epochNum > 4294967295) {
+    throw new Error(`Epoch ${epoch} out of u32 range for coin reservation digest`);
+  }
+  view.setUint32(8, epochNum, true);
+  digestBytes.set(COIN_RESERVATION_MAGIC, 12);
+  return {
+    objectId: deriveReservationObjectId(owner, chainIdentifier),
+    version: "0",
+    digest: (0, import_utils.toBase58)(digestBytes)
+  };
 }
 
-// src/utils/crypto.ts
-var import_verify = require("@mysten/sui/verify");
+// src/utils/sui.ts
+var import_sui3_utils3 = require("@msafe/sui3-utils");
+var import_cryptography = require("@mysten/sui/cryptography");
+var import_graphql = require("@mysten/sui/graphql");
+var import_multisig = require("@mysten/sui/multisig");
 
 // src/utils/format.ts
-var import_utils2 = require("@mysten/sui/utils");
+var import_utils3 = require("@mysten/sui/utils");
 
 // src/utils/coin.ts
-var import_utils = require("@mysten/sui/utils");
+var import_utils2 = require("@mysten/sui/utils");
 var CoinHelper = class {
   _client;
   _coinMetaReg;
@@ -318,7 +292,7 @@ var CoinHelper = class {
     this._coinMetaReg = /* @__PURE__ */ new Map();
   }
   async getCoinMeta(coinType) {
-    const normalized = (0, import_utils.normalizeStructTag)(coinType);
+    const normalized = (0, import_utils2.normalizeStructTag)(coinType);
     if (this._coinMetaReg.has(normalized)) {
       return this._coinMetaReg.get(normalized);
     }
@@ -339,10 +313,10 @@ var Coin = class _Coin {
     if (!type) {
       return false;
     }
-    return (0, import_utils.normalizeStructTag)(type).match(COIN_TYPE_ARG_REGEX) != null;
+    return (0, import_utils2.normalizeStructTag)(type).match(COIN_TYPE_ARG_REGEX) != null;
   }
   static getCoinType(type) {
-    const [, res] = (0, import_utils.normalizeStructTag)(type).match(COIN_TYPE_ARG_REGEX) ?? [];
+    const [, res] = (0, import_utils2.normalizeStructTag)(type).match(COIN_TYPE_ARG_REGEX) ?? [];
     return res || null;
   }
   static getBalance(data) {
@@ -370,16 +344,16 @@ var Coin = class _Coin {
 // src/utils/format.ts
 var Formatter = class {
   static normalizeSuiAddress(addr) {
-    return (0, import_utils2.normalizeSuiAddress)(addr);
+    return (0, import_utils3.normalizeSuiAddress)(addr);
   }
   static normalizeStructTag(struct) {
-    return (0, import_utils2.normalizeStructTag)(struct);
+    return (0, import_utils3.normalizeStructTag)(struct);
   }
   static isSuiAddressEqual(addr1, addr2) {
-    return (0, import_utils2.normalizeSuiAddress)(addr1) === (0, import_utils2.normalizeSuiAddress)(addr2);
+    return (0, import_utils3.normalizeSuiAddress)(addr1) === (0, import_utils3.normalizeSuiAddress)(addr2);
   }
   static isSuiStructEqual(struct1, struct2) {
-    return (0, import_utils2.normalizeStructTag)(struct1) === (0, import_utils2.normalizeStructTag)(struct2);
+    return (0, import_utils3.normalizeStructTag)(struct1) === (0, import_utils3.normalizeStructTag)(struct2);
   }
   static isCoinObjectType(struct) {
     return Coin.isCoin(struct);
@@ -392,50 +366,7 @@ function addPrefix(s, prefix) {
   return prefix + s;
 }
 
-// src/utils/crypto.ts
-var SignatureVerifier = class _SignatureVerifier {
-  static async getPublicKeyFromSignature(input) {
-    if (input.messageType === "TransactionBlock") {
-      return (0, import_verify.verifyTransactionSignature)(input.message, input.signature);
-    }
-    return (0, import_verify.verifyPersonalMessageSignature)(input.message, input.signature);
-  }
-  static async getPublicKeyFromPersonalSignature(input) {
-    const message = stringToBuffer(input.messageStr);
-    return this.getPublicKeyFromSignature({
-      message,
-      messageType: "Personal",
-      signature: input.signature
-    });
-  }
-  static async verifySignature(input) {
-    const publicKey = await _SignatureVerifier.getPublicKeyFromSignature(input);
-    return Formatter.isSuiAddressEqual(publicKey.toSuiAddress(), input.targetAddress);
-  }
-  static async verifyPersonalSignature(input) {
-    const message = stringToBuffer(input.messageStr);
-    return this.verifySignature({
-      message,
-      messageType: "Personal",
-      signature: input.signature,
-      targetAddress: input.targetAddress
-    });
-  }
-  static async verifyTransactionSignature(input) {
-    return this.verifySignature({
-      messageType: "TransactionBlock",
-      message: input.payload,
-      signature: input.signature,
-      targetAddress: input.targetAddress
-    });
-  }
-};
-
 // src/utils/sui.ts
-var import_sui3_utils3 = require("@msafe/sui3-utils");
-var import_cryptography = require("@mysten/sui/cryptography");
-var import_graphql = require("@mysten/sui/graphql");
-var import_multisig = require("@mysten/sui/multisig");
 var SUI_COIN = "0x2::sui::SUI";
 var GRAPHQL_URL_BY_NETWORK = {
   mainnet: "https://sui-mainnet.mystenlabs.com/graphql",
@@ -547,14 +478,382 @@ async function getAllCoins(input) {
   return res;
 }
 
+// src/utils/gasFunding.ts
+var GAS_SAFE_OVERHEAD = 1000n;
+var InsufficientGasFundsError = class extends Error {
+  gasBudget;
+  coinBalance;
+  addressBalance;
+  constructor(gasBudget, coinBalance, addressBalance) {
+    const total = coinBalance + addressBalance;
+    super(
+      `Insufficient gas funds: need ${gasBudget}, have coinBalance=${coinBalance} + addressBalance=${addressBalance} = ${total}`
+    );
+    this.name = "InsufficientGasFundsError";
+    this.gasBudget = gasBudget;
+    this.coinBalance = coinBalance;
+    this.addressBalance = addressBalance;
+  }
+};
+function computeGasBudget(gasUsed, gasPrice) {
+  const { computationCost, storageCost } = gasUsed;
+  const safeOverhead = GAS_SAFE_OVERHEAD * gasPrice;
+  return BigInt(computationCost) + BigInt(storageCost) + safeOverhead;
+}
+function collectUsedObjectIds(tx) {
+  return tx.getData().inputs.reduce((used, input) => {
+    const immOrOwned = input.Object?.ImmOrOwnedObject?.objectId;
+    if (immOrOwned) {
+      used.add((0, import_utils4.normalizeSuiObjectId)(immOrOwned));
+      return used;
+    }
+    const unresolved = input.UnresolvedObject?.objectId;
+    if (unresolved) {
+      used.add((0, import_utils4.normalizeSuiObjectId)(unresolved));
+    }
+    return used;
+  }, /* @__PURE__ */ new Set());
+}
+async function loadSuiGasFunding(suiClient, owner, tx) {
+  const usedObjectIds = collectUsedObjectIds(tx);
+  const [coins, balanceRes] = await Promise.all([
+    getAllCoins({ suiClient, owner, coinType: SUI_COIN }),
+    suiClient.getBalance({ owner, coinType: SUI_COIN })
+  ]);
+  const paymentCoins = coins.filter((coin) => !usedObjectIds.has((0, import_utils4.normalizeSuiObjectId)(coin.objectId)) && BigInt(coin.balance) > 0n).map((coin) => ({
+    objectId: coin.objectId,
+    version: coin.version,
+    digest: coin.digest,
+    balance: BigInt(coin.balance)
+  }));
+  const coinBalance = paymentCoins.reduce((sum, coin) => sum + coin.balance, 0n);
+  const addressBalance = BigInt(balanceRes.balance.addressBalance);
+  return {
+    paymentCoins,
+    coinBalance,
+    addressBalance,
+    total: coinBalance + addressBalance
+  };
+}
+function toObjectRefs(coins) {
+  return coins.map(({ objectId, version, digest }) => ({ objectId, version, digest }));
+}
+async function applyMixedTopUp(input) {
+  const { tx, suiClient, owner, paymentCoins, topUpAmount } = input;
+  if (paymentCoins.length === 0) {
+    throw new Error("mixed gas top-up requires at least one SUI coin object");
+  }
+  if (topUpAmount <= 0n) {
+    tx.setGasPayment(toObjectRefs(paymentCoins));
+    return;
+  }
+  const [{ chainIdentifier }, { systemState }] = await Promise.all([
+    suiClient.core.getChainIdentifier(),
+    suiClient.core.getCurrentSystemState()
+  ]);
+  const reservation = createCoinReservationRef(topUpAmount, owner, chainIdentifier, systemState.epoch);
+  tx.setGasPayment([...toObjectRefs(paymentCoins), reservation]);
+}
+async function selectGasFunding(input) {
+  const { tx, suiClient, owner, gasBudget } = input;
+  const { payment } = tx.getData().gasData;
+  if (payment != null && payment.length > 0) {
+    const funding2 = await loadSuiGasFunding(suiClient, owner, tx);
+    return {
+      mode: "classic",
+      gasBudget,
+      coinBalance: funding2.coinBalance,
+      addressBalance: funding2.addressBalance
+    };
+  }
+  const funding = await loadSuiGasFunding(suiClient, owner, tx);
+  const { paymentCoins, coinBalance, addressBalance, total } = funding;
+  if (total < gasBudget) {
+    throw new InsufficientGasFundsError(gasBudget, coinBalance, addressBalance);
+  }
+  if (paymentCoins.length > 0 && coinBalance >= gasBudget) {
+    tx.setGasPayment(toObjectRefs(paymentCoins));
+    return { mode: "classic", gasBudget, coinBalance, addressBalance };
+  }
+  if (paymentCoins.length > 0 && total >= gasBudget) {
+    const topUpAmount = gasBudget - coinBalance;
+    await applyMixedTopUp({
+      tx,
+      suiClient,
+      owner,
+      paymentCoins,
+      topUpAmount
+    });
+    return { mode: "mixedTopUp", gasBudget, coinBalance, addressBalance };
+  }
+  if (addressBalance >= gasBudget) {
+    tx.setGasPayment([]);
+    return { mode: "addressBalance", gasBudget, coinBalance, addressBalance };
+  }
+  throw new InsufficientGasFundsError(gasBudget, coinBalance, addressBalance);
+}
+function cloneWithClearedGasConfig(tx) {
+  const data = structuredClone(tx.getData());
+  data.gasData.budget = null;
+  data.gasData.price = null;
+  data.gasData.payment = null;
+  data.expiration = null;
+  return import_transactions.Transaction.from(JSON.stringify(data));
+}
+function isPositiveBudget(budget) {
+  if (budget == null) {
+    return false;
+  }
+  try {
+    return BigInt(budget) > 0n;
+  } catch {
+    return false;
+  }
+}
+async function estimateGasBudget(input) {
+  const { tx, suiClient, owner, gasPrice } = input;
+  const funding = await loadSuiGasFunding(suiClient, owner, tx);
+  if (funding.total <= 0n) {
+    throw new InsufficientGasFundsError(0n, funding.coinBalance, funding.addressBalance);
+  }
+  const { budget, payment } = tx.getData().gasData;
+  const mustResetGas = payment != null && payment.length === 0 || budget != null && !isPositiveBudget(budget);
+  const probe = mustResetGas ? cloneWithClearedGasConfig(tx) : import_transactions.Transaction.from(tx);
+  probe.setSender(owner);
+  probe.setGasPrice(gasPrice);
+  if (funding.paymentCoins.length > 0) {
+    probe.setGasPayment(toObjectRefs(funding.paymentCoins));
+  }
+  let built;
+  try {
+    built = await probe.build({ client: suiClient });
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    throw new Error(`Failed to estimate gas budget: ${message}`);
+  }
+  const inspect = await suiClient.simulateTransaction({
+    transaction: built,
+    include: { effects: true }
+  });
+  const effects = (inspect.Transaction ?? inspect.FailedTransaction)?.effects;
+  if (!effects?.gasUsed) {
+    throw new Error("Failed to estimate gas budget: simulateTransaction returned no gasUsed");
+  }
+  if (effects.status.success !== true) {
+    const err = effects.status.success === false ? effects.status.error?.message : void 0;
+    throw new Error(`Failed to estimate gas budget: ${err ?? "simulation failed"}`);
+  }
+  return computeGasBudget(effects.gasUsed, gasPrice);
+}
+async function prepareGasFunding(input) {
+  const { tx, suiClient, owner, gasPrice } = input;
+  const { payment, budget: existingBudget } = tx.getData().gasData;
+  const bakedAddressBalanceGas = payment != null && payment.length === 0;
+  let { gasBudget } = input;
+  if (gasBudget != null && gasBudget <= 0n) {
+    gasBudget = void 0;
+  }
+  const existingPositive = isPositiveBudget(existingBudget) ? BigInt(existingBudget) : null;
+  if (gasBudget == null) {
+    if (bakedAddressBalanceGas || existingPositive == null) {
+      gasBudget = await estimateGasBudget({ tx, suiClient, owner, gasPrice });
+    } else {
+      gasBudget = existingPositive;
+    }
+  }
+  tx.setGasBudget(gasBudget);
+  if (bakedAddressBalanceGas) {
+    tx.setExpiration(null);
+  }
+  return selectGasFunding({ tx, suiClient, owner, gasBudget });
+}
+async function preferClassicGasPayment(input) {
+  const { tx, suiClient, owner } = input;
+  const { payment } = tx.getData().gasData;
+  if (payment != null) {
+    return payment.length > 0;
+  }
+  const funding = await loadSuiGasFunding(suiClient, owner, tx);
+  if (funding.paymentCoins.length === 0) {
+    return false;
+  }
+  tx.setGasPayment(toObjectRefs(funding.paymentCoins));
+  return true;
+}
+
+// src/simulate/simulator.ts
+function formatExecutionError(error) {
+  return error.message;
+}
+function gasObjectToReference(gas) {
+  if (!gas?.objectId) {
+    throw new Error("Gas object missing from simulation effects");
+  }
+  const version = gas.outputVersion ?? gas.inputVersion ?? "0";
+  const digest = gas.outputDigest ?? gas.inputDigest ?? "";
+  return { objectId: gas.objectId, version, digest };
+}
+var Simulator = class {
+  constructor(globals) {
+    this.globals = globals;
+  }
+  async simulate(input) {
+    const tx = this.copyTransaction(input.txb);
+    const { suiClient } = this.globals;
+    const gasPrice = await this.getGasPrice();
+    tx.setGasPrice(gasPrice);
+    tx.setSender(input.sender);
+    try {
+      await prepareGasFunding({
+        tx,
+        suiClient,
+        owner: input.sender,
+        gasPrice
+      });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      return {
+        success: false,
+        gasPrice,
+        simulationError: message
+      };
+    }
+    let built;
+    try {
+      built = await tx.build({ client: suiClient });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      return {
+        success: false,
+        gasPrice,
+        simulationError: message
+      };
+    }
+    let inspectResult;
+    try {
+      inspectResult = await suiClient.simulateTransaction({
+        transaction: built,
+        include: {
+          effects: true,
+          balanceChanges: true,
+          events: true,
+          objectTypes: true,
+          transaction: true,
+          bcs: true,
+          commandResults: true
+        }
+      });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      return {
+        success: false,
+        gasPrice,
+        simulationError: message
+      };
+    }
+    const txRow = inspectResult.Transaction ?? inspectResult.FailedTransaction;
+    const { effects } = txRow;
+    if (!effects) {
+      throw new Error("simulateTransaction did not return effects");
+    }
+    const success = effects.status.success === true;
+    if (!success) {
+      const err = effects.status.success === false ? effects.status.error : null;
+      return {
+        success,
+        gasPrice,
+        response: inspectResult,
+        simulationError: err ? formatExecutionError(err) : "Simulation failed"
+      };
+    }
+    const gasBudget = this.toGasBudget(effects.gasUsed, gasPrice);
+    return {
+      success,
+      gasPrice,
+      gasObject: gasObjectToReference(effects.gasObject),
+      gasUsed: effects.gasUsed,
+      gasBudget,
+      response: inspectResult
+    };
+  }
+  async getGasPrice() {
+    const { referenceGasPrice } = await this.globals.suiClient.getReferenceGasPrice();
+    return BigInt(referenceGasPrice);
+  }
+  toGasBudget(gasUsed, gasPrice) {
+    return computeGasBudget(gasUsed, gasPrice);
+  }
+  copyTransaction(tx) {
+    return import_transactions2.Transaction.from(tx);
+  }
+};
+
+// src/utils/buffer.ts
+var import_buffer = require("buffer");
+function stringToBuffer(s) {
+  return import_buffer.Buffer.from(s, "utf-8");
+}
+function Uint8ArrayToHex(b) {
+  return `0x${Array.prototype.map.call(b, (x) => `0${x.toString(16)}`.slice(-2)).join("")}`;
+}
+function HexToUint8Array(hex) {
+  return Uint8Array.from(import_buffer.Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex"));
+}
+
+// src/utils/crypto.ts
+var import_verify = require("@mysten/sui/verify");
+var SignatureVerifier = class _SignatureVerifier {
+  static async getPublicKeyFromSignature(input) {
+    if (input.messageType === "TransactionBlock") {
+      return (0, import_verify.verifyTransactionSignature)(input.message, input.signature);
+    }
+    return (0, import_verify.verifyPersonalMessageSignature)(input.message, input.signature);
+  }
+  static async getPublicKeyFromPersonalSignature(input) {
+    const message = stringToBuffer(input.messageStr);
+    return this.getPublicKeyFromSignature({
+      message,
+      messageType: "Personal",
+      signature: input.signature
+    });
+  }
+  static async verifySignature(input) {
+    const publicKey = await _SignatureVerifier.getPublicKeyFromSignature(input);
+    return Formatter.isSuiAddressEqual(publicKey.toSuiAddress(), input.targetAddress);
+  }
+  static async verifyPersonalSignature(input) {
+    const message = stringToBuffer(input.messageStr);
+    return this.verifySignature({
+      message,
+      messageType: "Personal",
+      signature: input.signature,
+      targetAddress: input.targetAddress
+    });
+  }
+  static async verifyTransactionSignature(input) {
+    return this.verifySignature({
+      messageType: "TransactionBlock",
+      message: input.payload,
+      signature: input.signature,
+      targetAddress: input.targetAddress
+    });
+  }
+};
+
 // src/utils/transaction.ts
-var import_transactions2 = require("@mysten/sui/transactions");
+var import_transactions3 = require("@mysten/sui/transactions");
 function toSuiTransaction(txb) {
-  if ((0, import_transactions2.isTransaction)(txb)) {
+  if ((0, import_transactions3.isTransaction)(txb)) {
     return txb;
   }
+  if (typeof txb === "string" || txb instanceof Uint8Array) {
+    return import_transactions3.Transaction.from(txb);
+  }
   const legacy = txb;
-  return import_transactions2.Transaction.from(legacy.serialize());
+  if (typeof legacy?.serialize === "function") {
+    return import_transactions3.Transaction.from(legacy.serialize());
+  }
+  throw new Error("Unsupported transaction value for toSuiTransaction");
 }
 
 // src/utils/iter/iterator.ts
@@ -722,7 +1021,7 @@ var MSafeAccount = class _MSafeAccount {
       balances.map(async (balance) => {
         const meta = await this.coinHelper.getCoinMeta(balance.coinType);
         return {
-          type: (0, import_utils3.normalizeStructTag)(balance.coinType),
+          type: (0, import_utils5.normalizeStructTag)(balance.coinType),
           balance: BigInt(balance.addressBalance),
           metadata: meta
         };
@@ -795,7 +1094,7 @@ var MSafeAccount = class _MSafeAccount {
           clientUrl: this.globals.config.suiClient.url,
           account: {
             address: this.address,
-            publicKey: (0, import_utils3.fromHex)(this.address),
+            publicKey: (0, import_utils5.fromHex)(this.address),
             chains: [import_wallet_standard.SUI_MAINNET_CHAIN, import_wallet_standard.SUI_TESTNET_CHAIN],
             features: []
           }
@@ -838,7 +1137,7 @@ var MSafeAccount = class _MSafeAccount {
           clientUrl: this.globals.config.suiClient.url,
           account: {
             address: this.address,
-            publicKey: (0, import_utils3.fromHex)(this.address),
+            publicKey: (0, import_utils5.fromHex)(this.address),
             chains: [import_wallet_standard.SUI_MAINNET_CHAIN, import_wallet_standard.SUI_TESTNET_CHAIN],
             features: []
           }
@@ -846,14 +1145,20 @@ var MSafeAccount = class _MSafeAccount {
       );
     }
     txb.setGasPrice(input.gasPrice);
-    txb.setGasBudget(input.gasBudget);
     txb.setSender(this.address);
+    await prepareGasFunding({
+      tx: txb,
+      suiClient: this.globals.suiClient,
+      owner: this.address,
+      gasPrice: input.gasPrice,
+      gasBudget: input.gasBudget
+    });
     const payload = await txb.build({ client: this.globals.suiClient });
     const digest = await txb.getDigest({ client: this.globals.suiClient });
     const signature = await this.wallet.signTransactionBlock({ transactionBlock: payload });
     return this.backend.proposeIntentionAndBuildVote({
       ...input,
-      payload: (0, import_utils3.toHex)(payload),
+      payload: (0, import_utils5.toHex)(payload),
       digest,
       msafeAddress: this.address,
       signature: signature.signature
@@ -911,7 +1216,7 @@ var MSafeAccount = class _MSafeAccount {
   }
   async proposePlainPayloadIntention(intention) {
     const sn = await this.nextSequenceNumber();
-    const tb = import_transactions3.Transaction.from(intention.payload);
+    const tb = import_transactions4.Transaction.from(intention.payload);
     const data = tb.getData();
     if (!data.sender || !(0, import_sui3_utils4.isSameAddress)(data.sender, this.address)) {
       throw new Error("Transaction sender is not same as the multisig address");
@@ -948,6 +1253,14 @@ var MSafeAccount = class _MSafeAccount {
       throw new Error("Already rejected");
     }
     const rejectTxb = toSuiTransaction((0, import_sui3_utils4.buildRejectTxb)(this.address));
+    rejectTxb.setGasPrice(input.gasPrice);
+    await prepareGasFunding({
+      tx: rejectTxb,
+      suiClient: this.suiClient,
+      owner: this.address,
+      gasPrice: input.gasPrice,
+      gasBudget: input.gasBudget
+    });
     const digest = await rejectTxb.getDigest({ client: this.suiClient });
     const payload = await rejectTxb.build({ client: this.suiClient });
     const signature = await this.wallet.signTransactionBlock({ transactionBlock: payload });
@@ -973,7 +1286,7 @@ var MSafeAccount = class _MSafeAccount {
         clientUrl: this.globals.config.suiClient.url,
         account: {
           address: this.address,
-          publicKey: (0, import_utils3.fromHex)(this.address),
+          publicKey: (0, import_utils5.fromHex)(this.address),
           chains: [import_wallet_standard.SUI_MAINNET_CHAIN, import_wallet_standard.SUI_TESTNET_CHAIN],
           features: []
         }
@@ -1055,7 +1368,7 @@ var MSafeAccount = class _MSafeAccount {
 
 // src/core/PublicKeyHelper.ts
 var import_sui3_utils5 = require("@msafe/sui3-utils");
-var import_utils5 = require("@mysten/sui/utils");
+var import_utils7 = require("@mysten/sui/utils");
 var PublicKeyHelper = class {
   constructor(globals) {
     this.globals = globals;
@@ -1104,7 +1417,7 @@ var PublicKeyHelper = class {
     if (!(0, import_sui3_utils5.isSameAddress)(address, publicKey.toSuiAddress())) {
       throw new Error("Invalid public key");
     }
-    this.knownPublicKeys.set((0, import_utils5.normalizeSuiAddress)(address), publicKey);
+    this.knownPublicKeys.set((0, import_utils7.normalizeSuiAddress)(address), publicKey);
   }
   async _getPublicKey(address) {
     const pkBackend = await this.getPublicKeyFromBackend(address);