@0xobelisk/sui-client 0.5.3 → 0.5.5

package/dist/index.mjs

@@ -13,21 +13,22 @@ var __privateAdd = (obj, member, value) => {
 };
 
 // src/index.ts
-export * from "@mysten/sui.js";
+export * from "@mysten/sui.js/utils";
+export * from "@mysten/sui.js/transactions";
 import { Ed25519Keypair as Ed25519Keypair3 } from "@mysten/sui.js/keypairs/ed25519";
 import { BCS as BCS2, getSuiMoveConfig as getSuiMoveConfig2 } from "@mysten/bcs";
 
 // src/obelisk.ts
+import { getFullnodeUrl } from "@mysten/sui.js/client";
 import {
-  RawSigner,
-  TransactionBlock as TransactionBlock3
-} from "@mysten/sui.js";
+  TransactionBlock as TransactionBlock2
+} from "@mysten/sui.js/transactions";
 
 // src/libs/suiAccountManager/index.ts
-import { Ed25519Keypair as Ed25519Keypair2 } from "@mysten/sui.js";
+import { Ed25519Keypair as Ed25519Keypair2 } from "@mysten/sui.js/keypairs/ed25519";
 
 // src/libs/suiAccountManager/keypair.ts
-import { Ed25519Keypair } from "@mysten/sui.js";
+import { Ed25519Keypair } from "@mysten/sui.js/keypairs/ed25519";
 var getDerivePathForSUI = (derivePathParams = {}) => {
   const {
     accountIndex = 0,
@@ -42,7 +43,7 @@ var getKeyPair = (mnemonics, derivePathParams = {}) => {
 };
 
 // src/libs/suiAccountManager/util.ts
-import { fromB64 as fromB642 } from "@mysten/sui.js";
+import { fromB64 } from "@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) => {
@@ -59,7 +60,7 @@ var hexOrBase64ToUint8Array = (str) => {
   if (isHex(str)) {
     return fromHEX(str);
   } else if (isBase64(str)) {
-    return fromB642(str);
+    return fromB64(str);
   } else {
     throw new Error("The string is not a valid hex or base64 string.");
   }
@@ -140,66 +141,123 @@ var SuiAccountManager = class {
 };
 
 // src/libs/suiTxBuilder/index.ts
-import {
-  TransactionBlock as TransactionBlock2,
-  SUI_SYSTEM_STATE_OBJECT_ID
-} from "@mysten/sui.js";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { SUI_SYSTEM_STATE_OBJECT_ID } from "@mysten/sui.js/utils";
 
 // src/libs/suiTxBuilder/util.ts
 import {
-  normalizeSuiObjectId
-} from "@mysten/sui.js";
+  normalizeSuiObjectId,
+  normalizeSuiAddress,
+  isValidSuiObjectId,
+  isValidSuiAddress
+} from "@mysten/sui.js/utils";
+import { Inputs } from "@mysten/sui.js/transactions";
+import { isPureArg } from "@mysten/sui.js/bcs";
+import { isSerializedBcs } from "@mysten/bcs";
 var getDefaultSuiInputType = (value) => {
-  if (typeof value === "string" && value.startsWith("0x")) {
+  if (typeof value === "string" && 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(normalizeSuiObjectId(arg)) : arg
+      (arg) => typeof arg === "string" && isValidSuiObjectId(arg) ? txBlock.object(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")) {
+    if (typeof arg === "string" && isValidSuiObjectId(arg)) {
       return txBlock.object(normalizeSuiObjectId(arg));
+    } else if (typeof arg == "object" && !isSerializedBcs(arg) && !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 (isSerializedBcs(arg)) {
       return arg;
+    } else {
+      return txBlock.pure(arg);
     }
   });
 }
+function convertAddressArg(txBlock, arg) {
+  if (typeof arg === "string" && isValidSuiAddress(arg)) {
+    return txBlock.pure.address(normalizeSuiAddress(arg));
+  } else if (typeof arg == "object" && !isSerializedBcs(arg) && !isPureArg(arg)) {
+    return convertObjArg(txBlock, arg);
+  } else if (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(Inputs.ObjectRef(arg.Object.ImmOrOwned));
+    } else if ("Shared" in arg.Object) {
+      return txb.object(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 TransactionBlock2(transaction);
+    this.txBlock = new 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");
   }
@@ -236,59 +294,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)
@@ -296,115 +364,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(SUI_SYSTEM_STATE_OBJECT_ID),
+      arguments: convertArgs(this.txBlock, [
+        SUI_SYSTEM_STATE_OBJECT_ID,
         stakeCoin,
-        tx.pure(validatorAddr)
-      ]
+        this.txBlock.pure(validatorAddr)
+      ])
     });
-    return tx;
   }
 };
 
 // src/libs/suiInteractor/suiInteractor.ts
-import {
-  JsonRpcProvider as JsonRpcProvider2,
-  Connection,
-  getObjectDisplay,
-  getObjectFields,
-  getObjectId,
-  getObjectType,
-  getObjectVersion,
-  getSharedObjectInitialVersion
-} from "@mysten/sui.js";
+import { SuiClient } from "@mysten/sui.js/client";
 import { requestSuiFromFaucetV0, getFaucetHost } from "@mysten/sui.js/faucet";
 
 // src/libs/suiModel/suiOwnedObject.ts
-import {
-  getObjectChanges
-} from "@mysten/sui.js";
 var SuiOwnedObject = class {
   constructor(param) {
     this.objectId = param.objectId;
@@ -438,7 +502,7 @@ var SuiOwnedObject = class {
    * @param txResponse
    */
   updateFromTxResponse(txResponse) {
-    const changes = getObjectChanges(txResponse);
+    const changes = txResponse.objectChanges;
     if (!changes) {
       throw new Error("Bad transaction response!");
     }
@@ -483,15 +547,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 JsonRpcProvider2(new Connection({ fullnode: url }))
-    );
-    this.currentProvider = this.providers[0];
+    this.fullNodes = fullNodeUrls;
+    this.clients = fullNodeUrls.map((url) => new 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 = {
@@ -500,56 +565,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 = getObjectId(object);
-          const objectType = getObjectType(object);
-          const objectVersion = getObjectVersion(object);
-          const objectDigest = object.data ? object.data.digest : void 0;
-          const initialSharedVersion = getSharedObjectInitialVersion(object);
-          const objectFields = getObjectFields(object);
-          const objectDisplay = 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}`
         );
       }
     }
@@ -559,84 +611,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}`
         );
       }
     }
@@ -651,13 +707,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;
       }
     }
   }
@@ -672,7 +732,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
@@ -705,29 +765,6 @@ var SuiInteractor = class {
   }
 };
 
-// src/libs/suiInteractor/defaultConfig.ts
-import {
-  localnetConnection,
-  devnetConnection,
-  testnetConnection,
-  mainnetConnection
-} from "@mysten/sui.js";
-var defaultGasBudget = 10 ** 8;
-var getDefaultConnection = (networkType = "devnet") => {
-  switch (networkType) {
-    case "localnet":
-      return localnetConnection;
-    case "devnet":
-      return devnetConnection;
-    case "testnet":
-      return testnetConnection;
-    case "mainnet":
-      return mainnetConnection;
-    default:
-      return devnetConnection;
-  }
-};
-
 // src/libs/suiContractFactory/index.ts
 var SuiContractFactory = class {
   // readonly #query: MapMessageQuery<ApiTypes> = {};
@@ -906,7 +943,7 @@ var Obelisk = class {
       return await this.inspectTxn(tx);
     });
     this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
-    fullnodeUrls = fullnodeUrls || [getDefaultConnection(networkType).fullnode];
+    fullnodeUrls = fullnodeUrls || [getFullnodeUrl(networkType ?? "mainnet")];
     this.suiInteractor = new SuiInteractor(fullnodeUrls, networkType);
     this.packageId = packageId;
     if (metadata !== void 0) {
@@ -951,14 +988,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 RawSigner(keyPair, this.suiInteractor.currentProvider);
+  getKeypair(derivePathParams) {
+    return this.accountManager.getKeyPair(derivePathParams);
   }
   /**
    * @description Switch the current account with the given derivePathParams
@@ -977,9 +1013,6 @@ var Obelisk = class {
   currentAddress() {
     return this.accountManager.currentAddress;
   }
-  provider() {
-    return this.suiInteractor.currentProvider;
-  }
   getPackageId() {
     return this.contractFactory.packageId;
   }
@@ -995,7 +1028,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);
@@ -1004,16 +1040,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 TransactionBlock2 ? 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
@@ -1115,9 +1152,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)
     });
   }
@@ -1126,12 +1163,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 TransactionBlock3();
+    const tx = new TransactionBlock2();
     const params = [tx.pure(worldId)];
     if (entityId !== void 0) {
       params.push(tx.pure(entityId));
@@ -1157,7 +1200,7 @@ var Obelisk = class {
   }
   async containEntity(worldId, schemaName, entityId) {
     const schemaModuleName = `${schemaName}_schema`;
-    const tx = new TransactionBlock3();
+    const tx = new TransactionBlock2();
     const params = [tx.pure(worldId)];
     if (entityId !== void 0) {
       params.push(tx.pure(entityId));
@@ -1214,7 +1257,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);
       }
     }
@@ -1274,9 +1317,51 @@ _tx = new WeakMap();
 _exec = new WeakMap();
 _read = new WeakMap();
 
+// src/libs/multiSig/client.ts
+import { MultiSigPublicKey } from "@mysten/sui.js/multisig";
+
+// src/libs/multiSig/publickey.ts
+import { Ed25519PublicKey } from "@mysten/sui.js/keypairs/ed25519";
+import { fromB64 as fromB642 } from "@mysten/sui.js/utils";
+function ed25519PublicKeyFromBase64(rawPubkey) {
+  let bytes = fromB642(rawPubkey);
+  if (bytes.length !== 32 && bytes.length !== 33)
+    throw "invalid pubkey length";
+  bytes = bytes.length === 33 ? bytes.slice(1) : bytes;
+  return new Ed25519PublicKey(bytes);
+}
+
+// src/libs/multiSig/client.ts
+var MultiSigClient = class _MultiSigClient {
+  constructor(pks, threshold) {
+    this.pksWeightPairs = pks;
+    this.threshold = threshold;
+    this.multiSigPublicKey = 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
+import { getFullnodeUrl as getFullnodeUrl2 } from "@mysten/sui.js/client";
 async function loadMetadata(networkType, packageId) {
-  const fullnodeUrls = [getDefaultConnection(networkType).fullnode];
+  const fullnodeUrls = [getFullnodeUrl2(networkType)];
   const suiInteractor = new SuiInteractor(fullnodeUrls);
   if (packageId !== void 0) {
     const jsonData = await suiInteractor.getNormalizedMoveModulesByPackage(
@@ -1290,6 +1375,7 @@ async function loadMetadata(networkType, packageId) {
 export {
   BCS2 as BCS,
   Ed25519Keypair3 as Ed25519Keypair,
+  MultiSigClient,
   Obelisk,
   SuiAccountManager,
   SuiContractFactory,