@0xobelisk/sui-client 0.5.2 → 0.5.4

package/dist/index.js

@@ -44,28 +44,31 @@ var __privateAdd = (obj, member, value) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  BCS: () => import_bcs2.BCS,
-  Ed25519Keypair: () => import_ed25519.Ed25519Keypair,
+  BCS: () => import_bcs4.BCS,
+  Ed25519Keypair: () => import_ed255194.Ed25519Keypair,
+  MultiSigClient: () => MultiSigClient,
   Obelisk: () => Obelisk,
   SuiAccountManager: () => SuiAccountManager,
   SuiContractFactory: () => SuiContractFactory,
   SuiTxBlock: () => SuiTxBlock,
-  getSuiMoveConfig: () => import_bcs2.getSuiMoveConfig,
+  getSuiMoveConfig: () => import_bcs4.getSuiMoveConfig,
   loadMetadata: () => loadMetadata
 });
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("@mysten/sui.js"), module.exports);
-var import_ed25519 = require("@mysten/sui.js/keypairs/ed25519");
-var import_bcs2 = require("@mysten/bcs");
+__reExport(src_exports, require("@mysten/sui.js/utils"), module.exports);
+__reExport(src_exports, require("@mysten/sui.js/transactions"), module.exports);
+var import_ed255194 = require("@mysten/sui.js/keypairs/ed25519");
+var import_bcs4 = require("@mysten/bcs");
 
 // src/obelisk.ts
-var import_sui9 = require("@mysten/sui.js");
+var import_client2 = require("@mysten/sui.js/client");
+var import_transactions3 = require("@mysten/sui.js/transactions");
 
 // src/libs/suiAccountManager/index.ts
-var import_sui3 = require("@mysten/sui.js");
+var import_ed255192 = require("@mysten/sui.js/keypairs/ed25519");
 
 // src/libs/suiAccountManager/keypair.ts
-var import_sui = require("@mysten/sui.js");
+var import_ed25519 = require("@mysten/sui.js/keypairs/ed25519");
 var getDerivePathForSUI = (derivePathParams = {}) => {
   const {
     accountIndex = 0,
@@ -76,11 +79,11 @@ var getDerivePathForSUI = (derivePathParams = {}) => {
 };
 var getKeyPair = (mnemonics, derivePathParams = {}) => {
   const derivePath = getDerivePathForSUI(derivePathParams);
-  return import_sui.Ed25519Keypair.deriveKeypair(mnemonics, derivePath);
+  return import_ed25519.Ed25519Keypair.deriveKeypair(mnemonics, derivePath);
 };
 
 // src/libs/suiAccountManager/util.ts
-var import_sui2 = require("@mysten/sui.js");
+var import_utils = require("@mysten/sui.js/utils");
 var isHex = (str) => /^0x[0-9a-fA-F]+$|^[0-9a-fA-F]+$/.test(str);
 var isBase64 = (str) => /^[a-zA-Z0-9+/]+={0,2}$/g.test(str);
 var fromHEX = (hexStr) => {
@@ -97,7 +100,7 @@ var hexOrBase64ToUint8Array = (str) => {
   if (isHex(str)) {
     return fromHEX(str);
   } else if (isBase64(str)) {
-    return (0, import_sui2.fromB64)(str);
+    return (0, import_utils.fromB64)(str);
   } else {
     throw new Error("The string is not a valid hex or base64 string.");
   }
@@ -140,7 +143,7 @@ var SuiAccountManager = class {
     if (!this.mnemonics && !this.secretKey) {
       this.mnemonics = generateMnemonic(24);
     }
-    this.currentKeyPair = this.secretKey ? import_sui3.Ed25519Keypair.fromSecretKey(
+    this.currentKeyPair = this.secretKey ? import_ed255192.Ed25519Keypair.fromSecretKey(
       normalizePrivateKey(hexOrBase64ToUint8Array(this.secretKey))
     ) : getKeyPair(this.mnemonics);
     this.currentAddress = this.currentKeyPair.getPublicKey().toSuiAddress();
@@ -178,61 +181,118 @@ var SuiAccountManager = class {
 };
 
 // src/libs/suiTxBuilder/index.ts
-var import_sui5 = require("@mysten/sui.js");
+var import_transactions2 = require("@mysten/sui.js/transactions");
+var import_utils3 = require("@mysten/sui.js/utils");
 
 // src/libs/suiTxBuilder/util.ts
-var import_sui4 = require("@mysten/sui.js");
+var import_utils2 = require("@mysten/sui.js/utils");
+var import_transactions = require("@mysten/sui.js/transactions");
+var import_bcs = require("@mysten/sui.js/bcs");
+var import_bcs2 = require("@mysten/bcs");
 var getDefaultSuiInputType = (value) => {
-  if (typeof value === "string" && value.startsWith("0x")) {
+  if (typeof value === "string" && (0, import_utils2.isValidSuiObjectId)(value)) {
     return "object";
   } else if (typeof value === "number" || typeof value === "bigint") {
     return "u64";
   } else if (typeof value === "boolean") {
     return "bool";
   } else {
-    return "object";
+    return void 0;
   }
 };
 function makeVecParam(txBlock, args, type) {
   if (args.length === 0)
     throw new Error("Transaction builder error: Empty array is not allowed");
   const defaultSuiType = getDefaultSuiInputType(args[0]);
-  if (type === "object" || !type && defaultSuiType === "object") {
+  const VECTOR_REGEX = /^vector<(.+)>$/;
+  const STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
+  type = type || defaultSuiType;
+  if (type === "object") {
     const objects = args.map(
-      (arg) => typeof arg === "string" ? txBlock.object((0, import_sui4.normalizeSuiObjectId)(arg)) : arg
+      (arg) => typeof arg === "string" && (0, import_utils2.isValidSuiObjectId)(arg) ? txBlock.object((0, import_utils2.normalizeSuiObjectId)(arg)) : convertObjArg(txBlock, arg)
     );
     return txBlock.makeMoveVec({ objects });
+  } else if (typeof type === "string" && !VECTOR_REGEX.test(type) && !STRUCT_REGEX.test(type)) {
+    return txBlock.pure(args, `vector<${type}>`);
   } else {
-    const vecType = type || defaultSuiType;
-    return txBlock.pure(args, `vector<${vecType}>`);
+    const objects = args.map(
+      (arg) => convertObjArg(txBlock, arg)
+    );
+    return txBlock.makeMoveVec({ objects, type });
   }
 }
 function isMoveVecArg(arg) {
-  const isFullMoveVecArg = arg && arg.value && Array.isArray(arg.value) && arg.vecType;
-  const isSimpleMoveVecArg = Array.isArray(arg);
-  return isFullMoveVecArg || isSimpleMoveVecArg;
+  if (typeof arg === "object" && "vecType" in arg && "value" in arg) {
+    return true;
+  } else if (Array.isArray(arg)) {
+    return true;
+  }
+  return false;
 }
 function convertArgs(txBlock, args) {
   return args.map((arg) => {
-    if (typeof arg === "string" && arg.startsWith("0x")) {
-      return txBlock.object((0, import_sui4.normalizeSuiObjectId)(arg));
+    if (typeof arg === "string" && (0, import_utils2.isValidSuiObjectId)(arg)) {
+      return txBlock.object((0, import_utils2.normalizeSuiObjectId)(arg));
+    } else if (typeof arg == "object" && !(0, import_bcs2.isSerializedBcs)(arg) && !(0, import_bcs.isPureArg)(arg) && !isMoveVecArg(arg)) {
+      return convertObjArg(txBlock, arg);
     } else if (isMoveVecArg(arg)) {
-      const vecType = arg.vecType || void 0;
-      return vecType ? makeVecParam(txBlock, arg.value, vecType) : makeVecParam(txBlock, arg);
-    } else if (typeof arg !== "object") {
-      return txBlock.pure(arg);
-    } else {
+      const vecType = "vecType" in arg;
+      return vecType ? makeVecParam(txBlock, arg.value, arg.vecType) : makeVecParam(txBlock, arg);
+    } else if ((0, import_bcs2.isSerializedBcs)(arg)) {
       return arg;
+    } else {
+      return txBlock.pure(arg);
     }
   });
 }
+function convertAddressArg(txBlock, arg) {
+  if (typeof arg === "string" && (0, import_utils2.isValidSuiAddress)(arg)) {
+    return txBlock.pure.address((0, import_utils2.normalizeSuiAddress)(arg));
+  } else if (typeof arg == "object" && !(0, import_bcs2.isSerializedBcs)(arg) && !(0, import_bcs.isPureArg)(arg)) {
+    return convertObjArg(txBlock, arg);
+  } else if ((0, import_bcs.isPureArg)(arg)) {
+    return txBlock.pure(arg);
+  } else {
+    return arg;
+  }
+}
+function convertObjArg(txb, arg) {
+  if (typeof arg === "string") {
+    return txb.object(arg);
+  }
+  if ("digest" in arg && "version" in arg && "objectId" in arg) {
+    return txb.objectRef(arg);
+  }
+  if ("objectId" in arg && "initialSharedVersion" in arg && "mutable" in arg) {
+    return txb.sharedObjectRef(arg);
+  }
+  if ("Object" in arg) {
+    if ("ImmOrOwned" in arg.Object) {
+      return txb.object(import_transactions.Inputs.ObjectRef(arg.Object.ImmOrOwned));
+    } else if ("Shared" in arg.Object) {
+      return txb.object(import_transactions.Inputs.SharedObjectRef(arg.Object.Shared));
+    } else {
+      throw new Error("Invalid argument type");
+    }
+  }
+  if ("kind" in arg) {
+    return arg;
+  }
+  throw new Error("Invalid argument type");
+}
 
 // src/libs/suiTxBuilder/index.ts
 var SuiTxBlock = class {
   constructor(transaction) {
-    this.txBlock = new import_sui5.TransactionBlock(transaction);
+    this.txBlock = new import_transactions2.TransactionBlock(transaction);
+  }
+  /* Directly wrap methods and properties of TransactionBlock */
+  get gas() {
+    return this.txBlock.gas;
+  }
+  get blockData() {
+    return this.txBlock.blockData;
   }
-  //======== override methods of TransactionBlock ============
   address(value) {
     return this.txBlock.pure(value, "address");
   }
@@ -269,59 +329,69 @@ var SuiTxBlock = class {
   setGasPayment(payments) {
     return this.txBlock.setGasPayment(payments);
   }
-  add(transaction) {
-    return this.txBlock.add(transaction);
-  }
   serialize() {
     return this.txBlock.serialize();
   }
+  sign(params) {
+    return this.txBlock.sign(params);
+  }
   build(params = {}) {
     return this.txBlock.build(params);
   }
-  getDigest({ provider } = {}) {
-    return this.txBlock.getDigest({ provider });
+  getDigest(params = {}) {
+    return this.txBlock.getDigest(params);
   }
-  get gas() {
-    return this.txBlock.gas;
+  add(...args) {
+    return this.txBlock.add(...args);
   }
-  get blockData() {
-    return this.txBlock.blockData;
+  publish({
+    modules,
+    dependencies
+  }) {
+    return this.txBlock.publish({ modules, dependencies });
   }
-  transferObjects(objects, recipient) {
-    const tx = this.txBlock;
-    tx.transferObjects(convertArgs(this.txBlock, objects), tx.pure(recipient));
-    return this;
+  upgrade({
+    modules,
+    dependencies,
+    packageId,
+    ticket
+  }) {
+    return this.txBlock.upgrade({ modules, dependencies, packageId, ticket });
+  }
+  makeMoveVec({
+    objects,
+    type
+  }) {
+    return this.txBlock.makeMoveVec({ objects, type });
+  }
+  /* Override methods of TransactionBlock */
+  transferObjects(objects, address) {
+    return this.txBlock.transferObjects(
+      objects.map((object) => convertObjArg(this.txBlock, object)),
+      convertAddressArg(this.txBlock, address)
+    );
   }
   splitCoins(coin, amounts) {
-    const tx = this.txBlock;
-    const coinObject = convertArgs(this.txBlock, [coin])[0];
-    const res = tx.splitCoins(
-      coinObject,
-      amounts.map((m) => tx.pure(m))
+    const res = this.txBlock.splitCoins(
+      convertObjArg(this.txBlock, coin),
+      convertArgs(this.txBlock, amounts)
     );
     return amounts.map((_, i) => res[i]);
   }
   mergeCoins(destination, sources) {
-    const destinationObject = convertArgs(this.txBlock, [destination])[0];
-    const sourceObjects = convertArgs(this.txBlock, sources);
+    const destinationObject = convertObjArg(this.txBlock, destination);
+    const sourceObjects = sources.map(
+      (source) => convertObjArg(this.txBlock, source)
+    );
     return this.txBlock.mergeCoins(destinationObject, sourceObjects);
   }
-  publish(...args) {
-    return this.txBlock.publish(...args);
-  }
-  upgrade(...args) {
-    return this.txBlock.upgrade(...args);
-  }
-  makeMoveVec(...args) {
-    return this.txBlock.makeMoveVec(...args);
-  }
   /**
    * @description Move call
    * @param target `${string}::${string}::${string}`, e.g. `0x3::sui_system::request_add_stake`
    * @param args the arguments of the move call, such as `['0x1', '0x2']`
-   * @param typeArguments the type arguments of the move call, such as `['0x2::sui::SUI']`
+   * @param typeArgs the type arguments of the move call, such as `['0x2::sui::SUI']`
    */
-  moveCall(target, args = [], typeArguments = []) {
+  moveCall(target, args = [], typeArgs = []) {
     const regex = /(?<package>[a-zA-Z0-9]+)::(?<module>[a-zA-Z0-9_]+)::(?<function>[a-zA-Z0-9_]+)/;
     const match = target.match(regex);
     if (match === null)
@@ -329,104 +399,111 @@ var SuiTxBlock = class {
         "Invalid target format. Expected `${string}::${string}::${string}`"
       );
     const convertedArgs = convertArgs(this.txBlock, args);
-    const tx = this.txBlock;
-    return tx.moveCall({
+    return this.txBlock.moveCall({
       target,
       arguments: convertedArgs,
-      typeArguments
+      typeArguments: typeArgs
     });
   }
-  //======== enhance methods ============
+  /* Enhance methods of TransactionBlock */
   transferSuiToMany(recipients, amounts) {
     if (recipients.length !== amounts.length) {
       throw new Error(
         "transferSuiToMany: recipients.length !== amounts.length"
       );
     }
-    const tx = this.txBlock;
-    const coins = tx.splitCoins(
-      tx.gas,
-      amounts.map((amount) => tx.pure(amount))
+    const coins = this.txBlock.splitCoins(
+      this.txBlock.gas,
+      convertArgs(this.txBlock, amounts)
+    );
+    const recipientObjects = recipients.map(
+      (recipient) => convertAddressArg(this.txBlock, recipient)
     );
-    recipients.forEach((recipient, index) => {
-      tx.transferObjects([coins[index]], tx.pure(recipient));
+    recipientObjects.forEach((address, index) => {
+      this.txBlock.transferObjects([coins[index]], address);
     });
     return this;
   }
-  transferSui(recipient, amount) {
-    return this.transferSuiToMany([recipient], [amount]);
+  transferSui(address, amount) {
+    return this.transferSuiToMany([address], [amount]);
   }
   takeAmountFromCoins(coins, amount) {
-    const tx = this.txBlock;
-    const coinObjects = convertArgs(this.txBlock, coins);
+    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
     const mergedCoin = coinObjects[0];
     if (coins.length > 1) {
-      tx.mergeCoins(mergedCoin, coinObjects.slice(1));
+      this.txBlock.mergeCoins(mergedCoin, coinObjects.slice(1));
     }
-    const [sendCoin] = tx.splitCoins(mergedCoin, [tx.pure(amount)]);
+    const [sendCoin] = this.txBlock.splitCoins(
+      mergedCoin,
+      convertArgs(this.txBlock, [amount])
+    );
     return [sendCoin, mergedCoin];
   }
   splitSUIFromGas(amounts) {
-    const tx = this.txBlock;
-    return tx.splitCoins(
-      tx.gas,
-      amounts.map((m) => tx.pure(m))
+    return this.txBlock.splitCoins(
+      this.txBlock.gas,
+      convertArgs(this.txBlock, amounts)
     );
   }
   splitMultiCoins(coins, amounts) {
-    const tx = this.txBlock;
-    const coinObjects = convertArgs(this.txBlock, coins);
+    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
     const mergedCoin = coinObjects[0];
     if (coins.length > 1) {
-      tx.mergeCoins(mergedCoin, coinObjects.slice(1));
+      this.txBlock.mergeCoins(mergedCoin, coinObjects.slice(1));
     }
-    const splitedCoins = tx.splitCoins(
+    const splitedCoins = this.txBlock.splitCoins(
       mergedCoin,
-      amounts.map((m) => tx.pure(m))
+      convertArgs(this.txBlock, amounts)
     );
     return { splitedCoins, mergedCoin };
   }
-  transferCoinToMany(inputCoins, sender, recipients, amounts) {
+  transferCoinToMany(coins, sender, recipients, amounts) {
     if (recipients.length !== amounts.length) {
       throw new Error(
         "transferSuiToMany: recipients.length !== amounts.length"
       );
     }
-    const tx = this.txBlock;
+    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
     const { splitedCoins, mergedCoin } = this.splitMultiCoins(
-      inputCoins,
+      coinObjects,
       amounts
     );
-    recipients.forEach((recipient, index) => {
-      tx.transferObjects([splitedCoins[index]], tx.pure(recipient));
+    const recipientObjects = recipients.map(
+      (recipient) => convertAddressArg(this.txBlock, recipient)
+    );
+    recipientObjects.forEach((address, index) => {
+      this.txBlock.transferObjects([splitedCoins[index]], address);
     });
-    tx.transferObjects([mergedCoin], tx.pure(sender));
+    this.txBlock.transferObjects(
+      [mergedCoin],
+      convertAddressArg(this.txBlock, sender)
+    );
     return this;
   }
-  transferCoin(inputCoins, sender, recipient, amount) {
-    return this.transferCoinToMany(inputCoins, sender, [recipient], [amount]);
+  transferCoin(coins, sender, recipient, amount) {
+    return this.transferCoinToMany(coins, sender, [recipient], [amount]);
   }
   stakeSui(amount, validatorAddr) {
-    const tx = this.txBlock;
-    const [stakeCoin] = tx.splitCoins(tx.gas, [tx.pure(amount)]);
-    tx.moveCall({
+    const [stakeCoin] = this.txBlock.splitCoins(
+      this.txBlock.gas,
+      convertArgs(this.txBlock, [amount])
+    );
+    return this.txBlock.moveCall({
       target: "0x3::sui_system::request_add_stake",
-      arguments: [
-        tx.object(import_sui5.SUI_SYSTEM_STATE_OBJECT_ID),
+      arguments: convertArgs(this.txBlock, [
+        import_utils3.SUI_SYSTEM_STATE_OBJECT_ID,
         stakeCoin,
-        tx.pure(validatorAddr)
-      ]
+        this.txBlock.pure(validatorAddr)
+      ])
     });
-    return tx;
   }
 };
 
 // src/libs/suiInteractor/suiInteractor.ts
-var import_sui7 = require("@mysten/sui.js");
+var import_client = require("@mysten/sui.js/client");
 var import_faucet = require("@mysten/sui.js/faucet");
 
 // src/libs/suiModel/suiOwnedObject.ts
-var import_sui6 = require("@mysten/sui.js");
 var SuiOwnedObject = class {
   constructor(param) {
     this.objectId = param.objectId;
@@ -460,7 +537,7 @@ var SuiOwnedObject = class {
    * @param txResponse
    */
   updateFromTxResponse(txResponse) {
-    const changes = (0, import_sui6.getObjectChanges)(txResponse);
+    const changes = txResponse.objectChanges;
     if (!changes) {
       throw new Error("Bad transaction response!");
     }
@@ -505,15 +582,16 @@ var SuiInteractor = class {
   constructor(fullNodeUrls, network) {
     if (fullNodeUrls.length === 0)
       throw new Error("fullNodeUrls must not be empty");
-    this.providers = fullNodeUrls.map(
-      (url) => new import_sui7.JsonRpcProvider(new import_sui7.Connection({ fullnode: url }))
-    );
-    this.currentProvider = this.providers[0];
+    this.fullNodes = fullNodeUrls;
+    this.clients = fullNodeUrls.map((url) => new import_client.SuiClient({ url }));
+    this.currentFullNode = fullNodeUrls[0];
+    this.currentClient = this.clients[0];
     this.network = network;
   }
-  switchToNextProvider() {
-    const currentProviderIdx = this.providers.indexOf(this.currentProvider);
-    this.currentProvider = this.providers[(currentProviderIdx + 1) % this.providers.length];
+  switchToNextClient() {
+    const currentClientIdx = this.clients.indexOf(this.currentClient);
+    this.currentClient = this.clients[(currentClientIdx + 1) % this.clients.length];
+    this.currentFullNode = this.fullNodes[(currentClientIdx + 1) % this.clients.length];
   }
   async sendTx(transactionBlock, signature) {
     const txResOptions = {
@@ -522,56 +600,43 @@ var SuiInteractor = class {
       showObjectChanges: true,
       showBalanceChanges: true
     };
-    for (const provider of this.providers) {
+    for (const clientIdx in this.clients) {
       try {
-        const res = await provider.executeTransactionBlock({
+        return await this.clients[clientIdx].executeTransactionBlock({
           transactionBlock,
           signature,
           options: txResOptions
         });
-        return res;
       } catch (err) {
         console.warn(
-          `Failed to send transaction with fullnode ${provider.connection.fullnode}: ${err}`
+          `Failed to send transaction with fullnode ${this.fullNodes[clientIdx]}: ${err}`
         );
         await delay(2e3);
       }
     }
     throw new Error("Failed to send transaction with all fullnodes");
   }
-  async getObjects(ids) {
-    const options = {
+  async getObjects(ids, options) {
+    const opts = options ?? {
       showContent: true,
       showDisplay: true,
       showType: true,
       showOwner: true
     };
-    for (const provider of this.providers) {
+    for (const clientIdx in this.clients) {
       try {
-        const objects = await provider.multiGetObjects({ ids, options });
-        const parsedObjects = objects.map((object) => {
-          const objectId = (0, import_sui7.getObjectId)(object);
-          const objectType = (0, import_sui7.getObjectType)(object);
-          const objectVersion = (0, import_sui7.getObjectVersion)(object);
-          const objectDigest = object.data ? object.data.digest : void 0;
-          const initialSharedVersion = (0, import_sui7.getSharedObjectInitialVersion)(object);
-          const objectFields = (0, import_sui7.getObjectFields)(object);
-          const objectDisplay = (0, import_sui7.getObjectDisplay)(object);
-          return {
-            objectId,
-            objectType,
-            objectVersion,
-            objectDigest,
-            objectFields,
-            objectDisplay,
-            initialSharedVersion
-          };
+        const objects = await this.clients[clientIdx].multiGetObjects({
+          ids,
+          options: opts
         });
+        const parsedObjects = objects.map((object) => {
+          return object.data;
+        }).filter((object) => object !== null && object !== void 0);
         return parsedObjects;
       } catch (err) {
         await delay(2e3);
         console.warn(
-          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+          `Failed to get objects with fullnode ${this.fullNodes[clientIdx]}: ${err}`
         );
       }
     }
@@ -581,84 +646,88 @@ var SuiInteractor = class {
     const objects = await this.getObjects([id]);
     return objects[0];
   }
-  // async getEntitiesObjects(ids: string[]) {
-  //   const options = {
-  //     showContent: true,
-  //     showType: true,
-  //   };
-  //   for (const provider of this.providers) {
-  //     try {
-  //       const objects = await provider.multiGetObjects({ ids, options });
-  //       const parsedObjects = objects.map((object) => {
-  //         const objectId = getObjectId(object);
-  //         const objectFields = getObjectFields(object) as ObjectFieldType;
-  //         const index = objectFields.name;
-  //         const key = objectFields.value;
-  //         return {
-  //           objectId,
-  //           index,
-  //           key,
-  //         };
-  //       });
-  //       return parsedObjects as EntityData[];
-  //     } catch (err) {
-  //       await delay(2000);
-  //       console.warn(
-  //         `Failed to get EntitiesObjects with fullnode ${provider.connection.fullnode}: ${err}`
-  //       );
-  //     }
-  //   }
-  //   throw new Error('Failed to get EntitiesObjects with all fullnodes');
-  // }
   async getDynamicFieldObject(parentId, name) {
-    for (const provider of this.providers) {
+    for (const clientIdx in this.clients) {
       try {
-        return provider.getDynamicFieldObject({ parentId, name });
+        return await this.clients[clientIdx].getDynamicFieldObject({
+          parentId,
+          name
+        });
       } catch (err) {
         await delay(2e3);
         console.warn(
-          `Failed to get DynamicFieldObject with fullnode ${provider.connection.fullnode}: ${err}`
+          `Failed to get DynamicFieldObject with fullnode ${this.fullNodes[clientIdx]}: ${err}`
         );
       }
     }
     throw new Error("Failed to get DynamicFieldObject with all fullnodes");
   }
   async getDynamicFields(parentId, cursor, limit) {
-    for (const provider of this.providers) {
+    for (const clientIdx in this.clients) {
       try {
-        return provider.getDynamicFields({ parentId, cursor, limit });
+        return await this.clients[clientIdx].getDynamicFields({
+          parentId,
+          cursor,
+          limit
+        });
       } catch (err) {
         await delay(2e3);
         console.warn(
-          `Failed to get DynamicFields with fullnode ${provider.connection.fullnode}: ${err}`
+          `Failed to get DynamicFields with fullnode ${this.fullNodes[clientIdx]}: ${err}`
         );
       }
     }
     throw new Error("Failed to get DynamicFields with all fullnodes");
   }
+  async getTxDetails(digest) {
+    for (const clientIdx in this.clients) {
+      try {
+        const txResOptions = {
+          showEvents: true,
+          showEffects: true,
+          showObjectChanges: true,
+          showBalanceChanges: true
+        };
+        return await this.clients[clientIdx].getTransactionBlock({
+          digest,
+          options: txResOptions
+        });
+      } catch (err) {
+        await delay(2e3);
+        console.warn(
+          `Failed to get TransactionBlocks with fullnode ${this.fullNodes[clientIdx]}: ${err}`
+        );
+      }
+    }
+    throw new Error("Failed to get TransactionBlocks with all fullnodes");
+  }
   async getOwnedObjects(owner, cursor, limit) {
-    for (const provider of this.providers) {
+    for (const clientIdx in this.clients) {
       try {
-        return await provider.getOwnedObjects({ owner, cursor, limit });
+        return await this.clients[clientIdx].getOwnedObjects({
+          owner,
+          cursor,
+          limit
+        });
       } catch (err) {
         await delay(2e3);
         console.warn(
-          `Failed to get OwnedObjects with fullnode ${provider.connection.fullnode}: ${err}`
+          `Failed to get OwnedObjects with fullnode ${this.fullNodes[clientIdx]}: ${err}`
         );
       }
     }
     throw new Error("Failed to get OwnedObjects with all fullnodes");
   }
   async getNormalizedMoveModulesByPackage(packageId) {
-    for (const provider of this.providers) {
+    for (const clientIdx in this.clients) {
       try {
-        return provider.getNormalizedMoveModulesByPackage({
+        return await this.clients[clientIdx].getNormalizedMoveModulesByPackage({
           package: packageId
         });
       } catch (err) {
         await delay(2e3);
         console.warn(
-          `Failed to get NormalizedMoveModules with fullnode ${provider.connection.fullnode}: ${err}`
+          `Failed to get NormalizedMoveModules with fullnode ${this.fullNodes[clientIdx]}: ${err}`
         );
       }
     }
@@ -673,13 +742,17 @@ var SuiInteractor = class {
     const objects = await this.getObjects(objectIds);
     for (const object of objects) {
       const suiObject = suiObjects.find(
-        (obj) => obj.objectId === object.objectId
+        (obj) => obj.objectId === object?.objectId
       );
       if (suiObject instanceof SuiSharedObject) {
-        suiObject.initialSharedVersion = object.initialSharedVersion;
+        if (object.owner && typeof object.owner === "object" && "Shared" in object.owner) {
+          suiObject.initialSharedVersion = object.owner.Shared.initial_shared_version;
+        } else {
+          suiObject.initialSharedVersion = void 0;
+        }
       } else if (suiObject instanceof SuiOwnedObject) {
-        suiObject.version = object.objectVersion;
-        suiObject.digest = object.objectDigest;
+        suiObject.version = object?.version;
+        suiObject.digest = object?.digest;
       }
     }
   }
@@ -694,7 +767,7 @@ var SuiInteractor = class {
     let totalAmount = 0;
     let hasNext = true, nextCursor = null;
     while (hasNext && totalAmount < amount) {
-      const coins = await this.currentProvider.getCoins({
+      const coins = await this.currentClient.getCoins({
         owner: addr,
         coinType,
         cursor: nextCursor
@@ -727,24 +800,6 @@ var SuiInteractor = class {
   }
 };
 
-// src/libs/suiInteractor/defaultConfig.ts
-var import_sui8 = require("@mysten/sui.js");
-var defaultGasBudget = 10 ** 8;
-var getDefaultConnection = (networkType = "devnet") => {
-  switch (networkType) {
-    case "localnet":
-      return import_sui8.localnetConnection;
-    case "devnet":
-      return import_sui8.devnetConnection;
-    case "testnet":
-      return import_sui8.testnetConnection;
-    case "mainnet":
-      return import_sui8.mainnetConnection;
-    default:
-      return import_sui8.devnetConnection;
-  }
-};
-
 // src/libs/suiContractFactory/index.ts
 var SuiContractFactory = class {
   // readonly #query: MapMessageQuery<ApiTypes> = {};
@@ -843,7 +898,7 @@ function numberToAddressHex(num) {
 
 // src/obelisk.ts
 var import_keccak256 = __toESM(require("keccak256"));
-var import_bcs = require("@mysten/bcs");
+var import_bcs3 = require("@mysten/bcs");
 function isUndefined(value) {
   return value === void 0;
 }
@@ -923,7 +978,7 @@ var Obelisk = class {
       return await this.inspectTxn(tx);
     });
     this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
-    fullnodeUrls = fullnodeUrls || [getDefaultConnection(networkType).fullnode];
+    fullnodeUrls = fullnodeUrls || [(0, import_client2.getFullnodeUrl)(networkType ?? "mainnet")];
     this.suiInteractor = new SuiInteractor(fullnodeUrls, networkType);
     this.packageId = packageId;
     if (metadata !== void 0) {
@@ -968,14 +1023,13 @@ var Obelisk = class {
     return __privateGet(this, _tx);
   }
   /**
-   * if derivePathParams is not provided or mnemonics is empty, it will return the currentSigner.
+   * if derivePathParams is not provided or mnemonics is empty, it will return the keypair.
    * else:
    * it will generate signer from the mnemonic with the given derivePathParams.
    * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
    */
-  getSigner(derivePathParams) {
-    const keyPair = this.accountManager.getKeyPair(derivePathParams);
-    return new import_sui9.RawSigner(keyPair, this.suiInteractor.currentProvider);
+  getKeypair(derivePathParams) {
+    return this.accountManager.getKeyPair(derivePathParams);
   }
   /**
    * @description Switch the current account with the given derivePathParams
@@ -994,9 +1048,6 @@ var Obelisk = class {
   currentAddress() {
     return this.accountManager.currentAddress;
   }
-  provider() {
-    return this.suiInteractor.currentProvider;
-  }
   getPackageId() {
     return this.contractFactory.packageId;
   }
@@ -1012,7 +1063,10 @@ var Obelisk = class {
   }
   async getBalance(coinType, derivePathParams) {
     const owner = this.accountManager.getAddress(derivePathParams);
-    return this.suiInteractor.currentProvider.getBalance({ owner, coinType });
+    return this.suiInteractor.currentClient.getBalance({ owner, coinType });
+  }
+  client() {
+    return this.suiInteractor.currentClient;
   }
   async getObject(objectId) {
     return this.suiInteractor.getObject(objectId);
@@ -1021,16 +1075,17 @@ var Obelisk = class {
     return this.suiInteractor.getObjects(objectIds);
   }
   async signTxn(tx, derivePathParams) {
-    tx = tx instanceof SuiTxBlock ? tx.txBlock : tx;
-    const signer = this.getSigner(derivePathParams);
-    return signer.signTransactionBlock({ transactionBlock: tx });
+    if (tx instanceof SuiTxBlock) {
+      tx.setSender(this.getAddress(derivePathParams));
+    }
+    const txBlock = tx instanceof SuiTxBlock ? tx.txBlock : tx;
+    const txBytes = txBlock instanceof import_transactions3.TransactionBlock ? await txBlock.build({ client: this.client() }) : txBlock;
+    const keyPair = this.getKeypair(derivePathParams);
+    return await keyPair.signTransactionBlock(txBytes);
   }
   async signAndSendTxn(tx, derivePathParams) {
-    const { transactionBlockBytes, signature } = await this.signTxn(
-      tx,
-      derivePathParams
-    );
-    return this.suiInteractor.sendTx(transactionBlockBytes, signature);
+    const { bytes, signature } = await this.signTxn(tx, derivePathParams);
+    return this.suiInteractor.sendTx(bytes, signature);
   }
   /**
    * Transfer the given amount of SUI to the recipient
@@ -1132,9 +1187,9 @@ var Obelisk = class {
    * @returns the effects and events of the transaction, such as object changes, gas cost, event emitted.
    */
   async inspectTxn(tx, derivePathParams) {
-    tx = tx instanceof SuiTxBlock ? tx.txBlock : tx;
-    return this.suiInteractor.currentProvider.devInspectTransactionBlock({
-      transactionBlock: tx,
+    const txBlock = tx instanceof SuiTxBlock ? tx.txBlock : tx;
+    return this.suiInteractor.currentClient.devInspectTransactionBlock({
+      transactionBlock: txBlock,
       sender: this.getAddress(derivePathParams)
     });
   }
@@ -1143,12 +1198,18 @@ var Obelisk = class {
   }
   async listSchemaNames(worldId) {
     const worldObject = await this.getObject(worldId);
-    const newObjectContent = worldObject.objectFields;
-    return newObjectContent["schemaNames"];
+    const newObjectContent = worldObject.content;
+    if (newObjectContent != null) {
+      const objectContent = newObjectContent;
+      const objectFields = objectContent.fields;
+      return objectFields["schema_names"];
+    } else {
+      return [];
+    }
   }
   async getEntity(worldId, schemaName, entityId) {
     const schemaModuleName = `${schemaName}_schema`;
-    const tx = new import_sui9.TransactionBlock();
+    const tx = new import_transactions3.TransactionBlock();
     const params = [tx.pure(worldId)];
     if (entityId !== void 0) {
       params.push(tx.pure(entityId));
@@ -1161,7 +1222,7 @@ var Obelisk = class {
     if (getResult.effects.status.status === "success") {
       const resultList = getResult.results[0].returnValues;
       for (const res of resultList) {
-        const bcs = new import_bcs.BCS((0, import_bcs.getSuiMoveConfig)());
+        const bcs = new import_bcs3.BCS((0, import_bcs3.getSuiMoveConfig)());
         const value = Uint8Array.from(res[0]);
         const bcsType = res[1].replace(/0x1::ascii::String/g, "string");
         const data = bcs.de(bcsType, value);
@@ -1174,7 +1235,7 @@ var Obelisk = class {
   }
   async containEntity(worldId, schemaName, entityId) {
     const schemaModuleName = `${schemaName}_schema`;
-    const tx = new import_sui9.TransactionBlock();
+    const tx = new import_transactions3.TransactionBlock();
     const params = [tx.pure(worldId)];
     if (entityId !== void 0) {
       params.push(tx.pure(entityId));
@@ -1185,7 +1246,7 @@ var Obelisk = class {
     );
     if (getResult.effects.status.status === "success") {
       const res = getResult.results[0].returnValues[0];
-      const bcs = new import_bcs.BCS((0, import_bcs.getSuiMoveConfig)());
+      const bcs = new import_bcs3.BCS((0, import_bcs3.getSuiMoveConfig)());
       const value = Uint8Array.from(res[0]);
       return bcs.de(res[1], value);
     } else {
@@ -1231,7 +1292,7 @@ var Obelisk = class {
     const ownedObjectsRes = [];
     for (const object of ownedObjects.data) {
       const objectDetail = await this.getObject(object.data.objectId);
-      if (objectDetail.objectType.split("::")[0] === this.contractFactory.packageId) {
+      if (objectDetail.type.split("::")[0] === this.contractFactory.packageId) {
         ownedObjectsRes.push(objectDetail);
       }
     }
@@ -1249,7 +1310,7 @@ var Obelisk = class {
   async entity_key_from_bytes(bytes) {
     const hashBytes = (0, import_keccak256.default)(bytes);
     const hashU8Array = Array.from(hashBytes);
-    const bcs = new import_bcs.BCS((0, import_bcs.getSuiMoveConfig)());
+    const bcs = new import_bcs3.BCS((0, import_bcs3.getSuiMoveConfig)());
     const value = Uint8Array.from(hashU8Array);
     const data = bcs.de("address", value);
     return "0x" + data;
@@ -1269,7 +1330,7 @@ var Obelisk = class {
     const checkObjectId = normalizeHexAddress(objectId);
     if (checkObjectId !== null) {
       objectId = checkObjectId;
-      const bcs = new import_bcs.BCS((0, import_bcs.getSuiMoveConfig)());
+      const bcs = new import_bcs3.BCS((0, import_bcs3.getSuiMoveConfig)());
       const bytes = Buffer.from(objectId.slice(2), "hex");
       const numberBytes = bcs.ser("u256", x).toBytes();
       return this.entity_key_from_bytes(Buffer.concat([bytes, numberBytes]));
@@ -1281,7 +1342,7 @@ var Obelisk = class {
     return numberToAddressHex(x);
   }
   async formatData(type, value) {
-    const bcs = new import_bcs.BCS((0, import_bcs.getSuiMoveConfig)());
+    const bcs = new import_bcs3.BCS((0, import_bcs3.getSuiMoveConfig)());
     const u8Value = Uint8Array.from(value);
     return bcs.de(type, u8Value);
   }
@@ -1291,9 +1352,51 @@ _tx = new WeakMap();
 _exec = new WeakMap();
 _read = new WeakMap();
 
+// src/libs/multiSig/client.ts
+var import_multisig = require("@mysten/sui.js/multisig");
+
+// src/libs/multiSig/publickey.ts
+var import_ed255193 = require("@mysten/sui.js/keypairs/ed25519");
+var import_utils5 = require("@mysten/sui.js/utils");
+function ed25519PublicKeyFromBase64(rawPubkey) {
+  let bytes = (0, import_utils5.fromB64)(rawPubkey);
+  if (bytes.length !== 32 && bytes.length !== 33)
+    throw "invalid pubkey length";
+  bytes = bytes.length === 33 ? bytes.slice(1) : bytes;
+  return new import_ed255193.Ed25519PublicKey(bytes);
+}
+
+// src/libs/multiSig/client.ts
+var MultiSigClient = class _MultiSigClient {
+  constructor(pks, threshold) {
+    this.pksWeightPairs = pks;
+    this.threshold = threshold;
+    this.multiSigPublicKey = import_multisig.MultiSigPublicKey.fromPublicKeys({
+      threshold: this.threshold,
+      publicKeys: this.pksWeightPairs
+    });
+  }
+  static fromRawEd25519PublicKeys(rawPublicKeys, weights, threshold) {
+    const pks = rawPublicKeys.map((rawPublicKey, i) => {
+      return {
+        publicKey: ed25519PublicKeyFromBase64(rawPublicKey),
+        weight: weights[i]
+      };
+    });
+    return new _MultiSigClient(pks, threshold);
+  }
+  multiSigAddress() {
+    return this.multiSigPublicKey.toSuiAddress();
+  }
+  combinePartialSigs(sigs) {
+    return this.multiSigPublicKey.combinePartialSignatures(sigs);
+  }
+};
+
 // src/metadata/index.ts
+var import_client4 = require("@mysten/sui.js/client");
 async function loadMetadata(networkType, packageId) {
-  const fullnodeUrls = [getDefaultConnection(networkType).fullnode];
+  const fullnodeUrls = [(0, import_client4.getFullnodeUrl)(networkType)];
   const suiInteractor = new SuiInteractor(fullnodeUrls);
   if (packageId !== void 0) {
     const jsonData = await suiInteractor.getNormalizedMoveModulesByPackage(
@@ -1308,12 +1411,14 @@ async function loadMetadata(networkType, packageId) {
 0 && (module.exports = {
   BCS,
   Ed25519Keypair,
+  MultiSigClient,
   Obelisk,
   SuiAccountManager,
   SuiContractFactory,
   SuiTxBlock,
   getSuiMoveConfig,
   loadMetadata,
-  ...require("@mysten/sui.js")
+  ...require("@mysten/sui.js/utils"),
+  ...require("@mysten/sui.js/transactions")
 });
 //# sourceMappingURL=index.js.map