@msafe/sui3-sdk 0.0.90 → 1.0.6

package/dist/index.cjs

@@ -62,7 +62,10 @@ __export(src_exports, {
   getAllCoins: () => getAllCoins,
   getMSafeConfig: () => getMSafeConfig,
   getPublicKeyFromChain: () => getPublicKeyFromChain,
-  stringToBuffer: () => stringToBuffer
+  httpUrlToGrpcBaseUrl: () => httpUrlToGrpcBaseUrl,
+  msafeChainToSuiNetwork: () => msafeChainToSuiNetwork,
+  stringToBuffer: () => stringToBuffer,
+  toSuiTransaction: () => toSuiTransaction
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -185,46 +188,86 @@ 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_transactions2 = require("@mysten/sui.js/transactions");
-var import_utils3 = require("@mysten/sui.js/utils");
+var import_transactions3 = require("@mysten/sui/transactions");
+var import_utils3 = require("@mysten/sui/utils");
 var import_wallet_standard = require("@mysten/wallet-standard");
 
 // src/simulate/simulator.ts
-var import_transactions = require("@mysten/sui.js/transactions");
+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.copyTransactionBlock(input.txb);
+    const tx = this.copyTransaction(input.txb);
     const { suiClient } = this.globals;
     const gasPrice = await this.getGasPrice();
     tx.setGasPrice(gasPrice);
-    const inspectResult = await suiClient.dryRunTransactionBlock({
-      transactionBlock: await tx.build({ client: suiClient })
-    });
-    const success = inspectResult.effects.status.status === "success";
+    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 }
+      });
+    } 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: inspectResult.effects.status.error
+        simulationError: err ? formatExecutionError(err) : "Simulation failed"
       };
     }
-    const gasBudget = this.toGasBudget(inspectResult.effects.gasUsed, gasPrice);
+    const gasBudget = this.toGasBudget(effects.gasUsed, gasPrice);
     return {
       success,
       gasPrice,
-      gasObject: inspectResult.effects.gasObject.reference,
-      gasUsed: inspectResult.effects.gasUsed,
+      gasObject: gasObjectToReference(effects.gasObject),
+      gasUsed: effects.gasUsed,
       gasBudget,
       response: inspectResult
     };
   }
   async getGasPrice() {
-    return this.globals.suiClient.getReferenceGasPrice();
+    const { referenceGasPrice } = await this.globals.suiClient.getReferenceGasPrice();
+    return BigInt(referenceGasPrice);
   }
   toGasBudget(gasUsed, gasPrice) {
     const { computationCost, storageCost, storageRebate } = gasUsed;
@@ -233,8 +276,8 @@ var Simulator = class {
     const gasBudget = baseComputationCostWithOverhead + BigInt(storageCost) - BigInt(storageRebate);
     return gasBudget > baseComputationCostWithOverhead ? gasBudget : baseComputationCostWithOverhead;
   }
-  copyTransactionBlock(tx) {
-    return import_transactions.TransactionBlock.from(tx.serialize());
+  copyTransaction(tx) {
+    return import_transactions.Transaction.from(tx.serialize());
   }
 };
 
@@ -251,13 +294,13 @@ function HexToUint8Array(hex) {
 }
 
 // src/utils/crypto.ts
-var import_verify = require("@mysten/sui.js/verify");
+var import_verify = require("@mysten/sui/verify");
 
 // src/utils/format.ts
-var import_utils2 = require("@mysten/sui.js/utils");
+var import_utils2 = require("@mysten/sui/utils");
 
 // src/utils/coin.ts
-var import_utils = require("@mysten/sui.js/utils");
+var import_utils = require("@mysten/sui/utils");
 var CoinHelper = class {
   _client;
   _coinMetaReg;
@@ -278,7 +321,7 @@ var CoinHelper = class {
   }
   async queryCoinMeta(coinType) {
     const res = await this._client.getCoinMetadata({ coinType });
-    return res || void 0;
+    return res.coinMetadata ?? void 0;
   }
 };
 var COIN_TYPE_ARG_REGEX = /^0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<(.+)>$/;
@@ -297,6 +340,13 @@ var Coin = class _Coin {
     if (!_Coin.isCoin(data.type)) {
       return void 0;
     }
+    if (data.json && typeof data.json === "object" && "balance" in data.json) {
+      const { balance: balance2 } = data.json;
+      if (balance2 === void 0) {
+        return void 0;
+      }
+      return BigInt(balance2);
+    }
     if (data.content?.dataType !== "moveObject") {
       return void 0;
     }
@@ -337,9 +387,9 @@ function addPrefix(s, prefix) {
 var SignatureVerifier = class _SignatureVerifier {
   static async getPublicKeyFromSignature(input) {
     if (input.messageType === "TransactionBlock") {
-      return (0, import_verify.verifyTransactionBlock)(input.message, input.signature);
+      return (0, import_verify.verifyTransactionSignature)(input.message, input.signature);
     }
-    return (0, import_verify.verifyPersonalMessage)(input.message, input.signature);
+    return (0, import_verify.verifyPersonalMessageSignature)(input.message, input.signature);
   }
   static async getPublicKeyFromPersonalSignature(input) {
     const message = stringToBuffer(input.messageStr);
@@ -374,26 +424,69 @@ var SignatureVerifier = class _SignatureVerifier {
 
 // src/utils/sui.ts
 var import_sui3_utils3 = require("@msafe/sui3-utils");
-var import_cryptography = require("@mysten/sui.js/cryptography");
-var import_multisig = require("@mysten/sui.js/multisig");
+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",
+  testnet: "https://sui-testnet.mystenlabs.com/graphql",
+  devnet: "https://sui-devnet.mystenlabs.com/graphql"
+};
+function graphqlClientForGrpc(suiClient) {
+  const url = GRAPHQL_URL_BY_NETWORK[suiClient.network] ?? GRAPHQL_URL_BY_NETWORK.testnet;
+  return new import_graphql.SuiGraphQLClient({ url, network: suiClient.network });
+}
+function collectSignatureStrings(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+  if ("base64" in value && typeof value.base64 === "string") {
+    return [value.base64];
+  }
+  if ("scheme" in value && "base64" in value) {
+    const b64 = value.base64;
+    return typeof b64 === "string" ? [b64] : [];
+  }
+  return [];
+}
+var TX_SIG_QUERY = `
+  query PublicKeyTxSigs($sender: SuiAddress!, $first: Int!) {
+    transactions(first: $first, filter: { sentAddress: $sender }) {
+      nodes {
+        signatures
+      }
+    }
+  }
+`;
 async function getPublicKeyFromChain(suiClient, address) {
+  const graphql = graphqlClientForGrpc(suiClient);
   let txs;
   try {
-    txs = await suiClient.queryTransactionBlocks({
-      // Disable naming rule since the variable is defined by Mysten
-      filter: { FromAddress: address },
-      options: { showInput: true },
-      limit: 2
+    const res = await graphql.query({
+      query: TX_SIG_QUERY,
+      variables: { sender: address, first: 2 }
     });
+    if (res.errors?.length) {
+      return void 0;
+    }
+    txs = res.data ?? {};
   } catch (e) {
     return void 0;
   }
-  if (txs.data.length === 0 || !txs.data[0].transaction?.txSignatures) {
+  const nodes = txs.transactions?.nodes ?? [];
+  if (nodes.length === 0) {
+    return void 0;
+  }
+  const first = nodes[0];
+  const rawSigs = first.signatures;
+  const signatures = Array.isArray(rawSigs) ? rawSigs.flatMap((item) => collectSignatureStrings(item)) : [];
+  if (signatures.length === 0) {
     return void 0;
   }
-  const tx = txs.data[0];
-  const signatures = tx.transaction?.txSignatures;
   for (let i = 0; i !== signatures.length; i++) {
     const serializedSig = signatures[i];
     const pk = getAddressFromSignatures(serializedSig, address);
@@ -433,18 +526,28 @@ async function getAllCoins(input) {
   let cursor;
   const res = [];
   while (hasNext) {
-    const currentPage = await input.suiClient.getCoins({
+    const currentPage = await input.suiClient.listCoins({
       owner: input.owner,
       coinType: input.coinType,
       cursor
     });
-    res.push(...currentPage.data);
+    res.push(...currentPage.objects);
     hasNext = currentPage.hasNextPage;
-    cursor = currentPage.nextCursor;
+    cursor = currentPage.cursor;
   }
   return res;
 }
 
+// src/utils/transaction.ts
+var import_transactions2 = require("@mysten/sui/transactions");
+function toSuiTransaction(txb) {
+  if ((0, import_transactions2.isTransaction)(txb)) {
+    return txb;
+  }
+  const legacy = txb;
+  return import_transactions2.Transaction.from(legacy.serialize());
+}
+
 // src/utils/iter/iterator.ts
 var REQUEST_PAGE_SIZE = 25;
 async function getAllFromIterator(it) {
@@ -521,6 +624,10 @@ var EntryIterator = class {
 };
 
 // src/utils/iter/object.ts
+var defaultObjectInclude = { json: true };
+function mergeInclude(options) {
+  return { ...defaultObjectInclude, ...options?.objectInclude };
+}
 async function getAllOwnedObjects(provider, owner, options) {
   const iter = new OwnedObjectIterator(provider, owner, options);
   return await getAllFromIterator(iter);
@@ -541,32 +648,29 @@ var OwnedObjectRequester = class {
     this.nextCursor = null;
     this.filter = options?.filter;
     this.pageSize = options?.pageSize || REQUEST_PAGE_SIZE;
-    this.objectOptions = options?.objectOptions || {
-      showType: true,
-      showContent: true
-    };
+    this.objectInclude = mergeInclude(options);
   }
   nextCursor;
   filter;
   pageSize;
-  objectOptions;
+  objectInclude;
   async doNextRequest() {
-    const res = await this.provider.getOwnedObjects({
+    const res = await this.provider.listOwnedObjects({
       owner: this.owner,
-      options: this.objectOptions,
+      include: this.objectInclude,
       cursor: this.nextCursor,
       limit: this.pageSize
     });
-    this.nextCursor = res.nextCursor;
+    this.nextCursor = res.cursor;
     let filtered;
     if (this.filter) {
       const { filter } = this;
-      filtered = res.data.filter((obj) => filter?.(obj));
+      filtered = res.objects.filter((obj) => filter(obj));
     } else {
-      filtered = res.data;
+      filtered = res.objects;
     }
     return {
-      data: filtered.map((r) => r.data).filter((data) => data),
+      data: filtered,
       hasNext: res.hasNextPage
     };
   }
@@ -596,14 +700,21 @@ var MSafeAccount = class _MSafeAccount {
     }
   }
   async ownedCoins() {
-    const balances = await this.suiClient.getAllBalances({ owner: this.address });
+    const balances = [];
+    let cursor = null;
+    let hasNext = true;
+    while (hasNext) {
+      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);
-        const unlockedBalance = balance.lockedBalance.number ? BigInt(balance.totalBalance) - BigInt(balance.lockedBalance.number) : BigInt(balance.totalBalance);
         return {
           type: (0, import_utils3.normalizeStructTag)(balance.coinType),
-          balance: BigInt(unlockedBalance),
+          balance: BigInt(balance.addressBalance),
           metadata: meta
         };
       })
@@ -611,7 +722,7 @@ var MSafeAccount = class _MSafeAccount {
   }
   async ownedObjects(options) {
     const filterCoinObjectOptions = {
-      filter: (objRes) => !objRes?.data?.type?.startsWith("0x2::coin::Coin"),
+      filter: (obj) => !obj?.type?.startsWith("0x2::coin::Coin"),
       ...options
     };
     return getAllOwnedObjects(this.suiClient, this.address, filterCoinObjectOptions);
@@ -666,19 +777,21 @@ var MSafeAccount = class _MSafeAccount {
       if (!appHelper) {
         throw new Error(`Can't find app helper for application ${request.application}`);
       }
-      txb = 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: (0, import_utils3.fromHEX)(this.address),
-          chains: [import_wallet_standard.SUI_MAINNET_CHAIN, import_wallet_standard.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: (0, import_utils3.fromHex)(this.address),
+            chains: [import_wallet_standard.SUI_MAINNET_CHAIN, import_wallet_standard.SUI_TESTNET_CHAIN],
+            features: []
+          }
+        })
+      );
     }
     txb.setSender(this.address);
     return this.simulator.simulate({ txb, sender: this.address });
@@ -707,19 +820,21 @@ var MSafeAccount = class _MSafeAccount {
       if (!appHelper) {
         throw new Error(`Can't find app helper for application ${input.application}`);
       }
-      txb = 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: (0, import_utils3.fromHEX)(this.address),
-          chains: [import_wallet_standard.SUI_MAINNET_CHAIN, import_wallet_standard.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: (0, import_utils3.fromHex)(this.address),
+            chains: [import_wallet_standard.SUI_MAINNET_CHAIN, import_wallet_standard.SUI_TESTNET_CHAIN],
+            features: []
+          }
+        })
+      );
     }
     txb.setGasPrice(input.gasPrice);
     txb.setGasBudget(input.gasBudget);
@@ -729,7 +844,7 @@ var MSafeAccount = class _MSafeAccount {
     const signature = await this.wallet.signTransactionBlock({ transactionBlock: payload });
     return this.backend.proposeIntentionAndBuildVote({
       ...input,
-      payload: (0, import_utils3.toHEX)(payload),
+      payload: (0, import_utils3.toHex)(payload),
       digest,
       msafeAddress: this.address,
       signature: signature.signature
@@ -787,8 +902,9 @@ var MSafeAccount = class _MSafeAccount {
   }
   async proposePlainPayloadIntention(intention) {
     const sn = await this.nextSequenceNumber();
-    const tb = import_transactions2.TransactionBlock.from(intention.payload);
-    if (!tb.blockData.sender || !(0, import_sui3_utils4.isSameAddress)(tb.blockData.sender, this.address)) {
+    const tb = import_transactions3.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");
     }
     return this.proposeIntention({
@@ -813,7 +929,7 @@ var MSafeAccount = class _MSafeAccount {
     if (!pendingTx || pendingTx.rejectDigest !== "") {
       throw new Error("Already rejected");
     }
-    const txb = (0, import_sui3_utils4.buildRejectTxb)(this.address);
+    const txb = toSuiTransaction((0, import_sui3_utils4.buildRejectTxb)(this.address));
     txb.setSender(this.address);
     return this.simulator.simulate({ txb, sender: this.address });
   }
@@ -822,7 +938,7 @@ var MSafeAccount = class _MSafeAccount {
     if (!pendingTx || pendingTx.rejectDigest !== "") {
       throw new Error("Already rejected");
     }
-    const rejectTxb = (0, import_sui3_utils4.buildRejectTxb)(this.address);
+    const rejectTxb = toSuiTransaction((0, import_sui3_utils4.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 });
@@ -839,19 +955,21 @@ var MSafeAccount = class _MSafeAccount {
     if (!appHelper) {
       throw new Error(`Can't find app helper for application ${intention.application}`);
     }
-    const txb = 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: (0, import_utils3.fromHEX)(this.address),
-        chains: [import_wallet_standard.SUI_MAINNET_CHAIN, import_wallet_standard.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: (0, import_utils3.fromHex)(this.address),
+          chains: [import_wallet_standard.SUI_MAINNET_CHAIN, import_wallet_standard.SUI_TESTNET_CHAIN],
+          features: []
+        }
+      })
+    );
     txb.setSender(this.address);
     return this.simulator.simulate({ txb, sender: this.address });
   }
@@ -885,10 +1003,10 @@ var MSafeAccount = class _MSafeAccount {
       }
     }
     const multiSignature = this.multiSig.combinePartialSignatures(sortedSigs);
-    return this.suiClient.executeTransactionBlock({
-      transactionBlock: HexToUint8Array(payload),
-      signature: multiSignature,
-      options: { showEffects: true, showEvents: true }
+    return this.suiClient.executeTransaction({
+      transaction: HexToUint8Array(payload),
+      signatures: [multiSignature],
+      include: { effects: true, events: true }
     });
   }
   async dashboard() {
@@ -928,7 +1046,7 @@ var MSafeAccount = class _MSafeAccount {
 
 // src/core/PublicKeyHelper.ts
 var import_sui3_utils5 = require("@msafe/sui3-utils");
-var import_utils5 = require("@mysten/sui.js/utils");
+var import_utils5 = require("@mysten/sui/utils");
 var PublicKeyHelper = class {
   constructor(globals) {
     this.globals = globals;
@@ -1014,7 +1132,7 @@ var ReportSDK = class {
 };
 
 // src/globals/MSafeGlobals.ts
-var import_client = require("@mysten/sui.js/client");
+var import_grpc = require("@mysten/sui/grpc");
 
 // src/backend/BackendImpl.ts
 var import_sui3_utils6 = require("@msafe/sui3-utils");
@@ -1323,6 +1441,9 @@ var BackendError = class _BackendError extends Error {
 };
 
 // src/globals/const.ts
+function msafeChainToSuiNetwork(chain) {
+  return chain === "sui:mainnet" ? "mainnet" : "testnet";
+}
 var MSafeEnv = /* @__PURE__ */ ((MSafeEnv3) => {
   MSafeEnv3["local"] = "local";
   MSafeEnv3["unit"] = "unit";
@@ -1331,6 +1452,16 @@ var MSafeEnv = /* @__PURE__ */ ((MSafeEnv3) => {
   MSafeEnv3["prod"] = "prod";
   return MSafeEnv3;
 })(MSafeEnv || {});
+function httpUrlToGrpcBaseUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol === "https:" && parsed.port === "") {
+    return `https://${parsed.hostname}:443${parsed.pathname}${parsed.search}`;
+  }
+  if (parsed.protocol === "http:" && parsed.port === "") {
+    return `http://${parsed.hostname}:80${parsed.pathname}${parsed.search}`;
+  }
+  return `${parsed.origin}${parsed.pathname}${parsed.search}`;
+}
 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";
@@ -1347,9 +1478,9 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
         url: TESTNET_RPC_URL
       },
       backend: {
-        url: LOCAL_API_URL
+        url: DEV_API_URL
       },
-      syncingURL: LOCAL_SYNCING_URL,
+      syncingURL: DEV_SYNCING_URL,
       network: "sui:testnet"
     }
   ],
@@ -1436,9 +1567,13 @@ var MSafeGlobals = class _MSafeGlobals {
   }
   static async New(env, options) {
     const config = getMSafeConfig(env, options);
-    const suiClient = new import_client.SuiClient(
-      config.suiClient.transport ? { transport: config.suiClient.transport } : { url: config.suiClient.url }
-    );
+    const suiClient = config.suiClient.transport ? new import_grpc.SuiGrpcClient({
+      transport: config.suiClient.transport,
+      network: msafeChainToSuiNetwork(config.network)
+    }) : new import_grpc.SuiGrpcClient({
+      baseUrl: httpUrlToGrpcBaseUrl(config.suiClient.url),
+      network: msafeChainToSuiNetwork(config.network)
+    });
     const backend = new BackendImpl(config.backend.url, options?.mockAddress);
     return new _MSafeGlobals({
       backend,