@msafe/sui3-sdk 1.0.14 → 1.0.17

package/dist/index.js

@@ -1,14 +1,11 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/core/CreateHelper.ts
-import { isSameAddress, MultiSigAccount, PublicKeySerde, SigningMessageHelper } from "@msafe/sui3-utils";
+import {
+  isSameAddress,
+  MultiSigAccount,
+  PublicKeySerde,
+  SigningMessageHelper
+} from "@msafe/sui3-utils";
 var CreateHelper = class {
-  static {
-    __name(this, "CreateHelper");
-  }
-  globals;
-  pkHelper;
   constructor(globals, pkHelper) {
     this.globals = globals;
     this.pkHelper = pkHelper;
@@ -26,13 +23,13 @@ var CreateHelper = class {
     return this.calculateMSafeAddress(createInfo);
   }
   /**
-  * Add user manually added public key for an address. If user input the public key with
-  * extra signature scheme flag, the scheme value will be automatically fixed.
-  *
-  * @param address
-  * @param pkEncoded
-  * @throws error if the public key does not match
-  */
+   * Add user manually added public key for an address. If user input the public key with
+   * extra signature scheme flag, the scheme value will be automatically fixed.
+   *
+   * @param address
+   * @param pkEncoded
+   * @throws error if the public key does not match
+   */
   addPublicKey(address, pkEncoded) {
     const pk = PublicKeySerde.de(pkEncoded);
     if (!isSameAddress(address, pk.toSuiAddress())) {
@@ -43,9 +40,7 @@ var CreateHelper = class {
   async submitMSafeCreation(creationInfo) {
     const msafeAddress = await this.validateCreateInfo(creationInfo);
     const signingMessage = SigningMessageHelper.createMSafeMessage(msafeAddress);
-    const signature = await this.globals.wallet.signPersonalMessage({
-      messageStr: signingMessage
-    });
+    const signature = await this.globals.wallet.signPersonalMessage({ messageStr: signingMessage });
     await this.submitToBackend(creationInfo, signature.signature);
     return msafeAddress;
   }
@@ -76,7 +71,9 @@ var CreateHelper = class {
       })),
       threshold: createInfo.threshold,
       name: createInfo.name,
+      // name validation is deferred to backend
       description: createInfo.description,
+      // description validation is deferred to backend
       creationNonce: createInfo.creationNonce,
       signature
     });
@@ -84,15 +81,14 @@ var CreateHelper = class {
 };
 
 // src/core/MSafeClient.ts
-import { SigningMessageHelper as SigningMessageHelper4, UserMSafeStatus as UserMSafeStatus2 } from "@msafe/sui3-utils";
+import {
+  SigningMessageHelper as SigningMessageHelper4,
+  UserMSafeStatus as UserMSafeStatus2
+} from "@msafe/sui3-utils";
 
 // src/core/AddressBookSDK.ts
 import { SigningMessageHelper as SigningMessageHelper2 } from "@msafe/sui3-utils";
 var AddressBookSDK = class {
-  static {
-    __name(this, "AddressBookSDK");
-  }
-  globals;
   constructor(globals) {
     this.globals = globals;
   }
@@ -101,192 +97,130 @@ var AddressBookSDK = class {
   }
   async update(updates) {
     const messageStr = SigningMessageHelper2.updateAddressBookMessage(updates);
-    const sig = await this.globals.wallet.signPersonalMessage({
-      messageStr
-    });
-    return this.globals.backend.updateAddressBook({
-      updates,
-      signature: sig.signature
-    });
+    const sig = await this.globals.wallet.signPersonalMessage({ messageStr });
+    return this.globals.backend.updateAddressBook({ updates, signature: sig.signature });
   }
   async getMode() {
     const res = await this.globals.backend.getAddressBookMode();
     return res.mode;
   }
   async setMode(mode) {
-    return this.globals.backend.setAddressBookMode({
-      mode
-    });
+    return this.globals.backend.setAddressBookMode({ mode });
   }
 };
 
 // src/core/InvitationSDK.ts
 var InvitationSDK = class {
-  static {
-    __name(this, "InvitationSDK");
-  }
-  globals;
   constructor(globals) {
     this.globals = globals;
   }
   async getMSafeByStatus(status, pagination) {
-    return this.globals.backend.getOwnedMSafeByStatus({
-      status,
-      pagination
-    });
+    return this.globals.backend.getOwnedMSafeByStatus({ status, pagination });
   }
   async updateMSafeStatus(msafeAddress, status) {
-    return this.globals.backend.updateMSafeStatus({
-      msafeAddress,
-      status
-    });
+    return this.globals.backend.updateMSafeStatus({ msafeAddress, status });
   }
 };
 
 // src/core/MSafeAccount.ts
 import { appHelpers } from "@msafe/sui-app-store";
-import { MultiSigAccount as MultiSigAccount2, SigningMessageHelper as SigningMessageHelper3, TransactionDefaultApplication, TransactionSubTypes, TransactionType, buildRejectTxb, isSameAddress as isSameAddress2 } from "@msafe/sui3-utils";
-import { Transaction as Transaction3 } from "@mysten/sui/transactions";
-import { fromHex, normalizeStructTag as normalizeStructTag3, toHex } from "@mysten/sui/utils";
+import {
+  MultiSigAccount as MultiSigAccount2,
+  SigningMessageHelper as SigningMessageHelper3,
+  TransactionDefaultApplication,
+  TransactionSubTypes,
+  TransactionType,
+  buildRejectTxb,
+  isSameAddress as isSameAddress2
+} from "@msafe/sui3-utils";
+import { Transaction as Transaction4 } from "@mysten/sui/transactions";
+import { fromHex as fromHex2, normalizeStructTag as normalizeStructTag3, toHex as toHex2 } from "@mysten/sui/utils";
 import { SUI_MAINNET_CHAIN, SUI_TESTNET_CHAIN } from "@mysten/wallet-standard";
 
 // src/simulate/simulator.ts
+import { Transaction as Transaction2 } from "@mysten/sui/transactions";
+
+// src/utils/gasFunding.ts
 import { Transaction } from "@mysten/sui/transactions";
-var GAS_SAFE_OVERHEAD = 1000n;
-function formatExecutionError(error) {
-  return error.message;
-}
-__name(formatExecutionError, "formatExecutionError");
-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
-  };
-}
-__name(gasObjectToReference, "gasObjectToReference");
-var Simulator = class {
-  static {
-    __name(this, "Simulator");
-  }
-  globals;
-  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 Transaction.from(tx.serialize());
-  }
-};
+import { normalizeSuiObjectId } from "@mysten/sui/utils";
 
-// src/utils/buffer.ts
-import { Buffer as Buffer2 } from "buffer";
-function stringToBuffer(s) {
-  return Buffer2.from(s, "utf-8");
+// src/utils/coinReservation.ts
+import { bcs, TypeTagSerializer } from "@mysten/sui/bcs";
+import { deriveDynamicFieldID, fromBase58, fromHex, normalizeSuiAddress, toBase58, toHex } from "@mysten/sui/utils";
+var SUI_ACCUMULATOR_ROOT_OBJECT_ID = normalizeSuiAddress("0xacc");
+var ACCUMULATOR_KEY_TYPE_TAG = 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 = fromBase58(digestBase58);
+  const last20Bytes = digestBytes.slice(12, 32);
+  return last20Bytes.every((byte, i) => byte === COIN_RESERVATION_MAGIC[i]);
 }
-__name(stringToBuffer, "stringToBuffer");
-function Uint8ArrayToHex(b) {
-  return `0x${Array.prototype.map.call(b, (x) => `0${x.toString(16)}`.slice(-2)).join("")}`;
+function deriveReservationObjectId(owner, chainIdentifier) {
+  const keyBcs = bcs.Address.serialize(owner).toBytes();
+  const accumulatorId = deriveDynamicFieldID(SUI_ACCUMULATOR_ROOT_OBJECT_ID, ACCUMULATOR_KEY_TYPE_TAG, keyBcs);
+  const accBytes = fromHex(accumulatorId.slice(2));
+  const chainBytes = 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${toHex(xored)}`;
 }
-__name(Uint8ArrayToHex, "Uint8ArrayToHex");
-function HexToUint8Array(hex) {
-  return Uint8Array.from(Buffer2.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: toBase58(digestBytes)
+  };
 }
-__name(HexToUint8Array, "HexToUint8Array");
 
-// src/utils/crypto.ts
-import { verifyPersonalMessageSignature, verifyTransactionSignature } from "@mysten/sui/verify";
+// src/utils/sui.ts
+import { PublicKeySerde as PublicKeySerde2 } from "@msafe/sui3-utils";
+import { parseSerializedSignature } from "@mysten/sui/cryptography";
+import { SuiGraphQLClient } from "@mysten/sui/graphql";
+import { MultiSigPublicKey } from "@mysten/sui/multisig";
 
 // src/utils/format.ts
-import { normalizeSuiAddress, normalizeStructTag as normalizeStructTag2 } from "@mysten/sui/utils";
+import { normalizeSuiAddress as normalizeSuiAddress2, normalizeStructTag as normalizeStructTag2 } from "@mysten/sui/utils";
 
 // src/utils/coin.ts
 import { normalizeStructTag } from "@mysten/sui/utils";
 var CoinHelper = class {
-  static {
-    __name(this, "CoinHelper");
-  }
   _client;
   _coinMetaReg;
   constructor(client) {
@@ -305,17 +239,12 @@ var CoinHelper = class {
     return meta;
   }
   async queryCoinMeta(coinType) {
-    const res = await this._client.getCoinMetadata({
-      coinType
-    });
+    const res = await this._client.getCoinMetadata({ coinType });
     return res.coinMetadata ?? void 0;
   }
 };
 var COIN_TYPE_ARG_REGEX = /^0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<(.+)>$/;
 var Coin = class _Coin {
-  static {
-    __name(this, "Coin");
-  }
   static isCoin(type) {
     if (!type) {
       return false;
@@ -350,17 +279,14 @@ var Coin = class _Coin {
 
 // src/utils/format.ts
 var Formatter = class {
-  static {
-    __name(this, "Formatter");
-  }
   static normalizeSuiAddress(addr) {
-    return normalizeSuiAddress(addr);
+    return normalizeSuiAddress2(addr);
   }
   static normalizeStructTag(struct) {
     return normalizeStructTag2(struct);
   }
   static isSuiAddressEqual(addr1, addr2) {
-    return normalizeSuiAddress(addr1) === normalizeSuiAddress(addr2);
+    return normalizeSuiAddress2(addr1) === normalizeSuiAddress2(addr2);
   }
   static isSuiStructEqual(struct1, struct2) {
     return normalizeStructTag2(struct1) === normalizeStructTag2(struct2);
@@ -375,55 +301,8 @@ function addPrefix(s, prefix) {
   }
   return prefix + s;
 }
-__name(addPrefix, "addPrefix");
-
-// src/utils/crypto.ts
-var SignatureVerifier = class _SignatureVerifier {
-  static {
-    __name(this, "SignatureVerifier");
-  }
-  static async getPublicKeyFromSignature(input) {
-    if (input.messageType === "TransactionBlock") {
-      return verifyTransactionSignature(input.message, input.signature);
-    }
-    return 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
-import { PublicKeySerde as PublicKeySerde2 } from "@msafe/sui3-utils";
-import { parseSerializedSignature } from "@mysten/sui/cryptography";
-import { SuiGraphQLClient } from "@mysten/sui/graphql";
-import { MultiSigPublicKey } from "@mysten/sui/multisig";
 var SUI_COIN = "0x2::sui::SUI";
 var GRAPHQL_URL_BY_NETWORK = {
   mainnet: "https://sui-mainnet.mystenlabs.com/graphql",
@@ -432,35 +311,24 @@ var GRAPHQL_URL_BY_NETWORK = {
 };
 function graphqlClientForGrpc(suiClient) {
   const url = GRAPHQL_URL_BY_NETWORK[suiClient.network] ?? GRAPHQL_URL_BY_NETWORK.testnet;
-  return new SuiGraphQLClient({
-    url,
-    network: suiClient.network
-  });
+  return new SuiGraphQLClient({ url, network: suiClient.network });
 }
-__name(graphqlClientForGrpc, "graphqlClientForGrpc");
 function collectSignatureStrings(value) {
   if (typeof value === "string") {
-    return [
-      value
-    ];
+    return [value];
   }
   if (!value || typeof value !== "object") {
     return [];
   }
   if ("base64" in value && typeof value.base64 === "string") {
-    return [
-      value.base64
-    ];
+    return [value.base64];
   }
   if ("scheme" in value && "base64" in value) {
     const b64 = value.base64;
-    return typeof b64 === "string" ? [
-      b64
-    ] : [];
+    return typeof b64 === "string" ? [b64] : [];
   }
   return [];
 }
-__name(collectSignatureStrings, "collectSignatureStrings");
 var TX_SIG_QUERY = `
   query PublicKeyTxSigs($sender: SuiAddress!, $first: Int!) {
     transactions(first: $first, filter: { sentAddress: $sender }) {
@@ -476,10 +344,7 @@ async function getPublicKeyFromChain(suiClient, address) {
   try {
     const res = await graphql.query({
       query: TX_SIG_QUERY,
-      variables: {
-        sender: address,
-        first: 2
-      }
+      variables: { sender: address, first: 2 }
     });
     if (res.errors?.length) {
       return void 0;
@@ -508,7 +373,6 @@ async function getPublicKeyFromChain(suiClient, address) {
   }
   return void 0;
 }
-__name(getPublicKeyFromChain, "getPublicKeyFromChain");
 function getAddressFromSignatures(serializedSig, targetAddress) {
   const decoded = parseSerializedSignature(serializedSig);
   switch (decoded.signatureScheme) {
@@ -523,10 +387,7 @@ function getAddressFromSignatures(serializedSig, targetAddress) {
     case "ED25519":
     case "Secp256k1":
     case "Secp256r1": {
-      const pk = PublicKeySerde2.de({
-        publicKeyEncoded: decoded.publicKey,
-        schema: decoded.signatureScheme
-      });
+      const pk = PublicKeySerde2.de({ publicKeyEncoded: decoded.publicKey, schema: decoded.signatureScheme });
       if (Formatter.isSuiAddressEqual(pk.toSuiAddress(), targetAddress)) {
         return pk;
       }
@@ -536,7 +397,6 @@ function getAddressFromSignatures(serializedSig, targetAddress) {
       throw new Error("Unknown schema");
   }
 }
-__name(getAddressFromSignatures, "getAddressFromSignatures");
 async function getAllCoins(input) {
   let hasNext = true;
   let cursor;
@@ -553,18 +413,357 @@ async function getAllCoins(input) {
   }
   return res;
 }
-__name(getAllCoins, "getAllCoins");
+
+// 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(normalizeSuiObjectId(immOrOwned));
+      return used;
+    }
+    const unresolved = input.UnresolvedObject?.objectId;
+    if (unresolved) {
+      used.add(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(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);
+}
+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 probe = 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) {
+    if (bakedAddressBalanceGas || existingBudget == null) {
+      gasBudget = await estimateGasBudget({ tx, suiClient, owner, gasPrice });
+    } else {
+      gasBudget = BigInt(existingBudget);
+    }
+  }
+  tx.setGasBudget(gasBudget);
+  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 Transaction2.from(tx);
+  }
+};
+
+// src/utils/buffer.ts
+import { Buffer } from "buffer";
+function stringToBuffer(s) {
+  return 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(Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex"));
+}
+
+// src/utils/crypto.ts
+import { verifyPersonalMessageSignature, verifyTransactionSignature } from "@mysten/sui/verify";
+var SignatureVerifier = class _SignatureVerifier {
+  static async getPublicKeyFromSignature(input) {
+    if (input.messageType === "TransactionBlock") {
+      return verifyTransactionSignature(input.message, input.signature);
+    }
+    return 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
-import { Transaction as Transaction2, isTransaction } from "@mysten/sui/transactions";
+import { Transaction as Transaction3, isTransaction } from "@mysten/sui/transactions";
 function toSuiTransaction(txb) {
   if (isTransaction(txb)) {
     return txb;
   }
+  if (typeof txb === "string" || txb instanceof Uint8Array) {
+    return Transaction3.from(txb);
+  }
   const legacy = txb;
-  return Transaction2.from(legacy.serialize());
+  if (typeof legacy?.serialize === "function") {
+    return Transaction3.from(legacy.serialize());
+  }
+  throw new Error("Unsupported transaction value for toSuiTransaction");
 }
-__name(toSuiTransaction, "toSuiTransaction");
 
 // src/utils/iter/iterator.ts
 var REQUEST_PAGE_SIZE = 25;
@@ -579,19 +778,14 @@ async function getAllFromIterator(it) {
   }
   return res;
 }
-__name(getAllFromIterator, "getAllFromIterator");
 var PagedIterator = class {
-  static {
-    __name(this, "PagedIterator");
-  }
-  requester;
-  curPage;
-  init;
   constructor(requester) {
     this.requester = requester;
     this.curPage = void 0;
     this.init = true;
   }
+  curPage;
+  init;
   async hasNext() {
     if (this.init) {
       if (!this.curPage) {
@@ -617,19 +811,15 @@ var PagedIterator = class {
   }
 };
 var EntryIterator = class {
-  static {
-    __name(this, "EntryIterator");
-  }
-  requester;
-  cursor;
-  pager;
-  curData;
   constructor(requester) {
     this.requester = requester;
     this.pager = new PagedIterator(requester);
     this.curData = [];
     this.cursor = 0;
   }
+  cursor;
+  pager;
+  curData;
   async hasNext() {
     if (this.cursor < this.curData.length - 1) {
       return true;
@@ -651,28 +841,15 @@ var EntryIterator = class {
 };
 
 // src/utils/iter/object.ts
-var defaultObjectInclude = {
-  json: true
-};
+var defaultObjectInclude = { json: true };
 function mergeInclude(options) {
-  return {
-    ...defaultObjectInclude,
-    ...options?.objectInclude
-  };
+  return { ...defaultObjectInclude, ...options?.objectInclude };
 }
-__name(mergeInclude, "mergeInclude");
 async function getAllOwnedObjects(provider, owner, options) {
   const iter = new OwnedObjectIterator(provider, owner, options);
   return await getAllFromIterator(iter);
 }
-__name(getAllOwnedObjects, "getAllOwnedObjects");
 var OwnedObjectIterator = class extends EntryIterator {
-  static {
-    __name(this, "OwnedObjectIterator");
-  }
-  provider;
-  owner;
-  options;
   constructor(provider, owner, options) {
     super(new OwnedObjectRequester(provider, owner, options));
     this.provider = provider;
@@ -681,16 +858,6 @@ var OwnedObjectIterator = class extends EntryIterator {
   }
 };
 var OwnedObjectRequester = class {
-  static {
-    __name(this, "OwnedObjectRequester");
-  }
-  provider;
-  owner;
-  options;
-  nextCursor;
-  filter;
-  pageSize;
-  objectInclude;
   constructor(provider, owner, options) {
     this.provider = provider;
     this.owner = owner;
@@ -700,6 +867,10 @@ var OwnedObjectRequester = class {
     this.pageSize = options?.pageSize || REQUEST_PAGE_SIZE;
     this.objectInclude = mergeInclude(options);
   }
+  nextCursor;
+  filter;
+  pageSize;
+  objectInclude;
   async doNextRequest() {
     const res = await this.provider.listOwnedObjects({
       owner: this.owner,
@@ -724,14 +895,6 @@ var OwnedObjectRequester = class {
 
 // src/core/MSafeAccount.ts
 var MSafeAccount = class _MSafeAccount {
-  static {
-    __name(this, "MSafeAccount");
-  }
-  globals;
-  info;
-  multiSig;
-  simulator;
-  coinHelper;
   constructor(globals, info) {
     this.globals = globals;
     this.info = info;
@@ -743,6 +906,9 @@ var MSafeAccount = class _MSafeAccount {
     this.coinHelper = new CoinHelper(this.suiClient);
     this.simulator = new Simulator(globals);
   }
+  multiSig;
+  simulator;
+  coinHelper;
   static async New(globals, address) {
     const info = await globals.backend.getMSafeAccountInfo(address);
     const ms = new _MSafeAccount(globals, info);
@@ -755,23 +921,21 @@ var MSafeAccount = class _MSafeAccount {
     let cursor = null;
     let hasNext = true;
     while (hasNext) {
-      const page = await this.suiClient.listBalances({
-        owner: this.address,
-        cursor,
-        limit: 50
-      });
+      const page = await this.suiClient.listBalances({ owner: this.address, cursor, limit: 50 });
       balances.push(...page.balances);
       hasNext = page.hasNextPage;
       cursor = page.cursor;
     }
-    return Promise.all(balances.map(async (balance) => {
-      const meta = await this.coinHelper.getCoinMeta(balance.coinType);
-      return {
-        type: normalizeStructTag3(balance.coinType),
-        balance: BigInt(balance.addressBalance),
-        metadata: meta
-      };
-    }));
+    return Promise.all(
+      balances.map(async (balance) => {
+        const meta = await this.coinHelper.getCoinMeta(balance.coinType);
+        return {
+          type: normalizeStructTag3(balance.coinType),
+          balance: BigInt(balance.addressBalance),
+          metadata: meta
+        };
+      })
+    );
   }
   async ownedObjects(options) {
     const filterCoinObjectOptions = {
@@ -781,9 +945,7 @@ var MSafeAccount = class _MSafeAccount {
     return getAllOwnedObjects(this.suiClient, this.address, filterCoinObjectOptions);
   }
   async pendingTransaction() {
-    const res = await this.backend.getPendingTransactions({
-      msafeAddress: this.address
-    });
+    const res = await this.backend.getPendingTransactions({ msafeAddress: this.address });
     if (!res?.pending) {
       return void 0;
     }
@@ -815,10 +977,7 @@ var MSafeAccount = class _MSafeAccount {
     });
   }
   async futureIntentions(pagination) {
-    return this.backend.getFutureIntentions({
-      msafeAddress: this.address,
-      ...pagination
-    });
+    return this.backend.getFutureIntentions({ msafeAddress: this.address, ...pagination });
   }
   async currentSequenceNumber() {
     return this.backend.getCurrentSequenceNumber(this.address);
@@ -835,28 +994,24 @@ var MSafeAccount = class _MSafeAccount {
       if (!appHelper) {
         throw new Error(`Can't find app helper for application ${request.application}`);
       }
-      txb = toSuiTransaction(await appHelper.build({
-        network: this.globals.config.network,
-        intentionData: request.intention,
-        txType: request.txType,
-        txSubType: request.txSubType,
-        clientUrl: this.globals.config.suiClient.url,
-        account: {
-          address: this.address,
-          publicKey: fromHex(this.address),
-          chains: [
-            SUI_MAINNET_CHAIN,
-            SUI_TESTNET_CHAIN
-          ],
-          features: []
-        }
-      }));
+      txb = toSuiTransaction(
+        await appHelper.build({
+          network: this.globals.config.network,
+          intentionData: request.intention,
+          txType: request.txType,
+          txSubType: request.txSubType,
+          clientUrl: this.globals.config.suiClient.url,
+          account: {
+            address: this.address,
+            publicKey: fromHex2(this.address),
+            chains: [SUI_MAINNET_CHAIN, SUI_TESTNET_CHAIN],
+            features: []
+          }
+        })
+      );
     }
     txb.setSender(this.address);
-    return this.simulator.simulate({
-      txb,
-      sender: this.address
-    });
+    return this.simulator.simulate({ txb, sender: this.address });
   }
   async proposeIntention(input) {
     const message = SigningMessageHelper3.proposeIntentionMessage({
@@ -882,38 +1037,37 @@ var MSafeAccount = class _MSafeAccount {
       if (!appHelper) {
         throw new Error(`Can't find app helper for application ${input.application}`);
       }
-      txb = toSuiTransaction(await appHelper.build({
-        network: this.globals.config.network,
-        intentionData: input.intention,
-        txType: input.txType,
-        txSubType: input.txSubType,
-        clientUrl: this.globals.config.suiClient.url,
-        account: {
-          address: this.address,
-          publicKey: fromHex(this.address),
-          chains: [
-            SUI_MAINNET_CHAIN,
-            SUI_TESTNET_CHAIN
-          ],
-          features: []
-        }
-      }));
+      txb = toSuiTransaction(
+        await appHelper.build({
+          network: this.globals.config.network,
+          intentionData: input.intention,
+          txType: input.txType,
+          txSubType: input.txSubType,
+          clientUrl: this.globals.config.suiClient.url,
+          account: {
+            address: this.address,
+            publicKey: fromHex2(this.address),
+            chains: [SUI_MAINNET_CHAIN, SUI_TESTNET_CHAIN],
+            features: []
+          }
+        })
+      );
     }
     txb.setGasPrice(input.gasPrice);
-    txb.setGasBudget(input.gasBudget);
     txb.setSender(this.address);
-    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
-    });
+    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: toHex(payload),
+      payload: toHex2(payload),
       digest,
       msafeAddress: this.address,
       signature: signature.signature
@@ -971,7 +1125,7 @@ var MSafeAccount = class _MSafeAccount {
   }
   async proposePlainPayloadIntention(intention) {
     const sn = await this.nextSequenceNumber();
-    const tb = Transaction3.from(intention.payload);
+    const tb = Transaction4.from(intention.payload);
     const data = tb.getData();
     if (!data.sender || !isSameAddress2(data.sender, this.address)) {
       throw new Error("Transaction sender is not same as the multisig address");
@@ -986,9 +1140,7 @@ var MSafeAccount = class _MSafeAccount {
   }
   async voteForTransaction(digest, payload) {
     const payloadBytes = HexToUint8Array(payload);
-    const signature = await this.wallet.signTransactionBlock({
-      transactionBlock: payloadBytes
-    });
+    const signature = await this.wallet.signTransactionBlock({ transactionBlock: payloadBytes });
     return this.backend.voteForTransaction({
       msafeAddress: this.address,
       digest,
@@ -1002,10 +1154,7 @@ var MSafeAccount = class _MSafeAccount {
     }
     const txb = toSuiTransaction(buildRejectTxb(this.address));
     txb.setSender(this.address);
-    return this.simulator.simulate({
-      txb,
-      sender: this.address
-    });
+    return this.simulator.simulate({ txb, sender: this.address });
   }
   async rejectCurrentTx(input) {
     const pendingTx = await this.pendingTransaction();
@@ -1013,15 +1162,17 @@ var MSafeAccount = class _MSafeAccount {
       throw new Error("Already rejected");
     }
     const rejectTxb = toSuiTransaction(buildRejectTxb(this.address));
-    const digest = await rejectTxb.getDigest({
-      client: this.suiClient
-    });
-    const payload = await rejectTxb.build({
-      client: this.suiClient
-    });
-    const signature = await this.wallet.signTransactionBlock({
-      transactionBlock: payload
-    });
+    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 });
     return this.backend.rejectCurrentTx({
       msafeAddress: this.address,
       digest,
@@ -1030,34 +1181,28 @@ var MSafeAccount = class _MSafeAccount {
     });
   }
   async simulateBuildTransaction() {
-    const intention = await this.backend.getNextIntention({
-      msafeAddress: this.address
-    });
+    const intention = await this.backend.getNextIntention({ msafeAddress: this.address });
     const appHelper = appHelpers.getAppHelper(intention.application);
     if (!appHelper) {
       throw new Error(`Can't find app helper for application ${intention.application}`);
     }
-    const txb = toSuiTransaction(await appHelper.build({
-      network: this.globals.config.network,
-      intentionData: intention.intention,
-      txType: intention.txType,
-      txSubType: intention.txSubType,
-      clientUrl: this.globals.config.suiClient.url,
-      account: {
-        address: this.address,
-        publicKey: fromHex(this.address),
-        chains: [
-          SUI_MAINNET_CHAIN,
-          SUI_TESTNET_CHAIN
-        ],
-        features: []
-      }
-    }));
+    const txb = toSuiTransaction(
+      await appHelper.build({
+        network: this.globals.config.network,
+        intentionData: intention.intention,
+        txType: intention.txType,
+        txSubType: intention.txSubType,
+        clientUrl: this.globals.config.suiClient.url,
+        account: {
+          address: this.address,
+          publicKey: fromHex2(this.address),
+          chains: [SUI_MAINNET_CHAIN, SUI_TESTNET_CHAIN],
+          features: []
+        }
+      })
+    );
     txb.setSender(this.address);
-    return this.simulator.simulate({
-      txb,
-      sender: this.address
-    });
+    return this.simulator.simulate({ txb, sender: this.address });
   }
   async buildNextIntentionAndAddToPending(gasOption) {
     return this.backend.buildNextIntentionAndAddToPending({
@@ -1068,14 +1213,10 @@ var MSafeAccount = class _MSafeAccount {
     });
   }
   async skipNextFailedIntention() {
-    return this.backend.skipNextFailedIntention({
-      msafeAddress: this.address
-    });
+    return this.backend.skipNextFailedIntention({ msafeAddress: this.address });
   }
   async fetchTransaction() {
-    return this.backend.fetchTransaction({
-      msafeAddress: this.address
-    });
+    return this.backend.fetchTransaction({ msafeAddress: this.address });
   }
   async executePendingTx(pending, isRejectTx = false) {
     const votes = isRejectTx ? pending.rejectVotes : pending.votes;
@@ -1084,10 +1225,7 @@ var MSafeAccount = class _MSafeAccount {
       throw new Error("Not enough signature");
     }
     const sortedSigs = [];
-    const gotSigs = new Map(votes.map((vote) => [
-      vote.userAddress,
-      vote.signature
-    ]));
+    const gotSigs = new Map(votes.map((vote) => [vote.userAddress, vote.signature]));
     for (let i = 0; i < this.info.owners.length; i++) {
       const owner = this.info.owners[i];
       const signature = gotSigs.get(owner.address);
@@ -1098,13 +1236,8 @@ var MSafeAccount = class _MSafeAccount {
     const multiSignature = this.multiSig.combinePartialSignatures(sortedSigs);
     return this.suiClient.executeTransaction({
       transaction: HexToUint8Array(payload),
-      signatures: [
-        multiSignature
-      ],
-      include: {
-        effects: true,
-        events: true
-      }
+      signatures: [multiSignature],
+      include: { effects: true, events: true }
     });
   }
   async dashboard() {
@@ -1144,17 +1277,13 @@ var MSafeAccount = class _MSafeAccount {
 
 // src/core/PublicKeyHelper.ts
 import { isSameAddress as isSameAddress3 } from "@msafe/sui3-utils";
-import { normalizeSuiAddress as normalizeSuiAddress2 } from "@mysten/sui/utils";
+import { normalizeSuiAddress as normalizeSuiAddress3 } from "@mysten/sui/utils";
 var PublicKeyHelper = class {
-  static {
-    __name(this, "PublicKeyHelper");
-  }
-  globals;
-  knownPublicKeys;
   constructor(globals) {
     this.globals = globals;
     this.knownPublicKeys = /* @__PURE__ */ new Map();
   }
+  knownPublicKeys;
   async getPublicKey(address) {
     const cached = this.knownPublicKeys.get(address);
     if (cached) {
@@ -1197,7 +1326,7 @@ var PublicKeyHelper = class {
     if (!isSameAddress3(address, publicKey.toSuiAddress())) {
       throw new Error("Invalid public key");
     }
-    this.knownPublicKeys.set(normalizeSuiAddress2(address), publicKey);
+    this.knownPublicKeys.set(normalizeSuiAddress3(address), publicKey);
   }
   async _getPublicKey(address) {
     const pkBackend = await this.getPublicKeyFromBackend(address);
@@ -1225,10 +1354,6 @@ var PublicKeyHelper = class {
 
 // src/core/ReportSDK.ts
 var ReportSDK = class {
-  static {
-    __name(this, "ReportSDK");
-  }
-  globals;
   constructor(globals) {
     this.globals = globals;
   }
@@ -1241,19 +1366,17 @@ var ReportSDK = class {
 import { SuiGrpcClient } from "@mysten/sui/grpc";
 
 // src/backend/BackendImpl.ts
-import { PublicKeySerde as PublicKeySerde3, UserMSafeStatus } from "@msafe/sui3-utils";
+import {
+  PublicKeySerde as PublicKeySerde3,
+  UserMSafeStatus
+} from "@msafe/sui3-utils";
 import axios from "axios";
 var BackendImpl = class _BackendImpl {
-  static {
-    __name(this, "BackendImpl");
-  }
-  apiURL;
-  mockAddress;
-  _token;
   constructor(apiURL, mockAddress) {
     this.apiURL = apiURL;
     this.mockAddress = mockAddress;
   }
+  _token;
   getNotificationInfo() {
     return this.get(`/notification`, {
       headers: this.headers()
@@ -1276,9 +1399,7 @@ var BackendImpl = class _BackendImpl {
   }
   async verifyToken(jwt) {
     try {
-      const res = await this.get(`/auth`, {
-        headers: this.headers(jwt)
-      });
+      const res = await this.get(`/auth`, { headers: this.headers(jwt) });
       return res.status === 200;
     } catch (_) {
       return false;
@@ -1288,9 +1409,7 @@ var BackendImpl = class _BackendImpl {
     this._token = token;
   }
   async getPublicKey(address) {
-    return (await this.getPublicKeyBatch([
-      address
-    ]))[0];
+    return (await this.getPublicKeyBatch([address]))[0];
   }
   async getPublicKeyBatch(addresses) {
     const query = {
@@ -1300,7 +1419,9 @@ var BackendImpl = class _BackendImpl {
       params: query,
       headers: this.headers()
     });
-    return res.data?.map((publicKeyWithSchema) => publicKeyWithSchema ? PublicKeySerde3.de(publicKeyWithSchema) : void 0);
+    return res.data?.map(
+      (publicKeyWithSchema) => publicKeyWithSchema ? PublicKeySerde3.de(publicKeyWithSchema) : void 0
+    );
   }
   async getMSafeAccountInfo(msafeAddress) {
     const q = {
@@ -1337,9 +1458,7 @@ var BackendImpl = class _BackendImpl {
   }
   async updateMSafeStatus(input) {
     const p = input;
-    await this.post(`/msafe/status`, p, {
-      headers: this.headers()
-    });
+    await this.post(`/msafe/status`, p, { headers: this.headers() });
   }
   async getPendingTransactions(input) {
     const res = await this.get(`/transaction/pending`, {
@@ -1393,18 +1512,16 @@ var BackendImpl = class _BackendImpl {
     });
   }
   async proposeIntention(input) {
-    await this.post(`/transaction/intention`, input, {
-      headers: this.headers()
-    });
+    await this.post(`/transaction/intention`, input, { headers: this.headers() });
   }
   async rejectCurrentTx(input) {
-    await this.post(`/transaction/pending/reject`, {
-      ...input,
-      gasPrice: input.gasPrice.toString(),
-      gasBudget: input.gasBudget.toString()
-    }, {
-      headers: this.headers()
-    });
+    await this.post(
+      `/transaction/pending/reject`,
+      { ...input, gasPrice: input.gasPrice.toString(), gasBudget: input.gasBudget.toString() },
+      {
+        headers: this.headers()
+      }
+    );
   }
   async voteForTransaction(input) {
     await this.post(`/transaction/pending/vote`, input, {
@@ -1412,32 +1529,24 @@ var BackendImpl = class _BackendImpl {
     });
   }
   async buildNextIntentionAndAddToPending(input) {
-    await this.post(`/transaction/pending/build`, {
-      ...input,
-      gasPrice: input.gasPrice.toString(),
-      gasBudget: input.gasBudget.toString()
-    }, {
-      headers: this.headers()
-    });
+    await this.post(
+      `/transaction/pending/build`,
+      { ...input, gasPrice: input.gasPrice.toString(), gasBudget: input.gasBudget.toString() },
+      { headers: this.headers() }
+    );
   }
   async proposeIntentionAndBuildVote(input) {
-    await this.post(`/transaction/intention/build`, {
-      ...input,
-      gasPrice: input.gasPrice.toString(),
-      gasBudget: input.gasBudget.toString()
-    }, {
-      headers: this.headers()
-    });
+    await this.post(
+      `/transaction/intention/build`,
+      { ...input, gasPrice: input.gasPrice.toString(), gasBudget: input.gasBudget.toString() },
+      { headers: this.headers() }
+    );
   }
   async skipNextFailedIntention(input) {
-    await this.post(`/transaction/pending/skip`, input, {
-      headers: this.headers()
-    });
+    await this.post(`/transaction/pending/skip`, input, { headers: this.headers() });
   }
   async fetchTransaction(input) {
-    const res = await this.post(`/transaction/fetch`, input, {
-      headers: this.headers()
-    });
+    const res = await this.post(`/transaction/fetch`, input, { headers: this.headers() });
     return res.data;
   }
   async getAddressBookEntries(pagination) {
@@ -1448,22 +1557,14 @@ var BackendImpl = class _BackendImpl {
     return res.data;
   }
   async updateAddressBook(input) {
-    await this.post(`/address-book`, input, {
-      headers: this.headers()
-    });
+    await this.post(`/address-book`, input, { headers: this.headers() });
   }
   async getAddressBookMode() {
-    const res = await this.get("/address-book/mode", {
-      headers: this.headers()
-    });
+    const res = await this.get("/address-book/mode", { headers: this.headers() });
     return res.data;
   }
   async setAddressBookMode(input) {
-    await this.post("/address-book/mode", {
-      mode: input.mode
-    }, {
-      headers: this.headers()
-    });
+    await this.post("/address-book/mode", { mode: input.mode }, { headers: this.headers() });
   }
   async submitReport(report) {
     await this.post("/report", report);
@@ -1476,10 +1577,7 @@ var BackendImpl = class _BackendImpl {
     return res.data;
   }
   headers(token) {
-    return {
-      Authorization: `Bearer ${token || this._token}`,
-      "sui-mock-user": this.mockAddress
-    };
+    return { Authorization: `Bearer ${token || this._token}`, "sui-mock-user": this.mockAddress };
   }
   static toMSafeConfig(resp) {
     return {
@@ -1535,9 +1633,7 @@ var BackendImpl = class _BackendImpl {
     } else if (transformRequest instanceof Array) {
       transformRequests = transformRequest;
     } else {
-      transformRequests = [
-        transformRequest
-      ];
+      transformRequests = [transformRequest];
     }
     return [
       (d) => JSON.parse(JSON.stringify(d, (_, value) => typeof value === "bigint" ? `${value.toString()}n` : value)),
@@ -1546,10 +1642,6 @@ var BackendImpl = class _BackendImpl {
   }
 };
 var BackendError = class _BackendError extends Error {
-  static {
-    __name(this, "BackendError");
-  }
-  e;
   constructor(e) {
     super();
     this.e = e;
@@ -1586,15 +1678,14 @@ var BackendError = class _BackendError extends Error {
 function msafeChainToSuiNetwork(chain) {
   return chain === "sui:mainnet" ? "mainnet" : "testnet";
 }
-__name(msafeChainToSuiNetwork, "msafeChainToSuiNetwork");
-var MSafeEnv;
-(function(MSafeEnv2) {
-  MSafeEnv2["local"] = "local";
-  MSafeEnv2["unit"] = "unit";
-  MSafeEnv2["dev"] = "dev";
-  MSafeEnv2["prev"] = "prev";
-  MSafeEnv2["prod"] = "prod";
-})(MSafeEnv || (MSafeEnv = {}));
+var MSafeEnv = /* @__PURE__ */ ((MSafeEnv3) => {
+  MSafeEnv3["local"] = "local";
+  MSafeEnv3["unit"] = "unit";
+  MSafeEnv3["dev"] = "dev";
+  MSafeEnv3["prev"] = "prev";
+  MSafeEnv3["prod"] = "prod";
+  return MSafeEnv3;
+})(MSafeEnv || {});
 function httpUrlToGrpcBaseUrl(url) {
   const parsed = new URL(url);
   if (parsed.protocol === "https:" && parsed.port === "") {
@@ -1605,7 +1696,6 @@ function httpUrlToGrpcBaseUrl(url) {
   }
   return `${parsed.origin}${parsed.pathname}${parsed.search}`;
 }
-__name(httpUrlToGrpcBaseUrl, "httpUrlToGrpcBaseUrl");
 var TESTNET_RPC_URL = "https://fullnode.testnet.sui.io";
 var MAINNET_RPC_URL = "https://fullnode.mainnet.sui.io";
 var LOCAL_API_URL = "http://127.0.0.1:3000";
@@ -1616,7 +1706,7 @@ var PREV_API_URL = "https://sui-preview.m-safe.link";
 var PROD_API_URL = "https://sui.m-safe.link";
 var ENV_CONFIGS = /* @__PURE__ */ new Map([
   [
-    "unit",
+    "unit" /* unit */,
     {
       suiClient: {
         url: TESTNET_RPC_URL
@@ -1629,7 +1719,7 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
     }
   ],
   [
-    "local",
+    "local" /* local */,
     {
       suiClient: {
         url: TESTNET_RPC_URL
@@ -1642,7 +1732,7 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
     }
   ],
   [
-    "dev",
+    "dev" /* dev */,
     {
       suiClient: {
         url: TESTNET_RPC_URL
@@ -1655,7 +1745,7 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
     }
   ],
   [
-    "prev",
+    "prev" /* prev */,
     {
       suiClient: {
         url: MAINNET_RPC_URL
@@ -1668,7 +1758,7 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
     }
   ],
   [
-    "prod",
+    "prod" /* prod */,
     {
       suiClient: {
         url: MAINNET_RPC_URL
@@ -1697,13 +1787,9 @@ function getMSafeConfig(env, options) {
   }
   return config;
 }
-__name(getMSafeConfig, "getMSafeConfig");
 
 // src/globals/MSafeGlobals.ts
 var MSafeGlobals = class _MSafeGlobals {
-  static {
-    __name(this, "MSafeGlobals");
-  }
   backend;
   suiClient;
   config;
@@ -1745,15 +1831,11 @@ var MSafeGlobals = class _MSafeGlobals {
 
 // src/core/MSafeClient.ts
 var MSafeClient = class _MSafeClient {
-  static {
-    __name(this, "MSafeClient");
-  }
-  globals;
-  _creationHelper;
-  _publicKeyHelper;
   constructor(globals) {
     this.globals = globals;
   }
+  _creationHelper;
+  _publicKeyHelper;
   static async New(env, options) {
     const globals = await MSafeGlobals.New(env, options);
     return new _MSafeClient(globals);
@@ -1788,10 +1870,7 @@ var MSafeClient = class _MSafeClient {
     return this.globals.backend.getUserInfo();
   }
   async ownedMSafe(pagination) {
-    return this.globals.backend.getOwnedMSafeByStatus({
-      status: UserMSafeStatus2.active,
-      pagination
-    });
+    return this.globals.backend.getOwnedMSafeByStatus({ status: UserMSafeStatus2.active, pagination });
   }
   async createAccount(info) {
     return this.creationHelper.submitMSafeCreation(info);
@@ -1841,43 +1920,32 @@ var MSafeClient = class _MSafeClient {
 };
 
 // src/backend/types/notification.ts
-var InfoTypeKey;
-(function(InfoTypeKey2) {
+var InfoTypeKey = /* @__PURE__ */ ((InfoTypeKey2) => {
   InfoTypeKey2["receive"] = "info_type_receive";
   InfoTypeKey2["send"] = "info_type_send";
   InfoTypeKey2["invitation"] = "info_type_invitation";
   InfoTypeKey2["awaitApproval"] = "info_type_await_approval";
-})(InfoTypeKey || (InfoTypeKey = {}));
+  return InfoTypeKey2;
+})(InfoTypeKey || {});
 var NotificationSubscribeDto = class {
-  static {
-    __name(this, "NotificationSubscribeDto");
-  }
   email;
 };
 var NotificationUpdateDto = class {
-  static {
-    __name(this, "NotificationUpdateDto");
-  }
   email;
   infoTypes;
   msafeEnabled;
 };
 var InfoTypeEnabledDto = class {
-  static {
-    __name(this, "InfoTypeEnabledDto");
-  }
   infoType;
   enabled;
 };
 var MSafeEnabledDto = class {
-  static {
-    __name(this, "MSafeEnabledDto");
-  }
   msafeAddress;
   enabled;
 };
 export {
   AddressBookSDK,
+  COIN_RESERVATION_MAGIC,
   COIN_TYPE_ARG_REGEX,
   Coin,
   CoinHelper,
@@ -1889,6 +1957,7 @@ export {
   HexToUint8Array,
   InfoTypeEnabledDto,
   InfoTypeKey,
+  InsufficientGasFundsError,
   LOCAL_API_URL,
   LOCAL_SYNCING_URL,
   MAINNET_RPC_URL,
@@ -1906,11 +1975,18 @@ export {
   TESTNET_RPC_URL,
   Uint8ArrayToHex,
   addPrefix,
+  computeGasBudget,
+  createCoinReservationRef,
+  estimateGasBudget,
   getAllCoins,
   getMSafeConfig,
   getPublicKeyFromChain,
   httpUrlToGrpcBaseUrl,
+  isCoinReservationDigest,
   msafeChainToSuiNetwork,
+  preferClassicGasPayment,
+  prepareGasFunding,
+  selectGasFunding,
   stringToBuffer,
   toSuiTransaction
 };