@0xobelisk/sui-client 0.5.18 → 0.5.20

package/dist/index.js

@@ -44,13 +44,13 @@ var __privateAdd = (obj, member, value) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  BcsType: () => import_bcs4.BcsType,
+  BcsType: () => import_bcs3.BcsType,
   MultiSigClient: () => MultiSigClient,
   Obelisk: () => Obelisk,
   SuiAccountManager: () => SuiAccountManager,
   SuiContractFactory: () => SuiContractFactory,
   SuiTx: () => SuiTx,
-  bcs: () => import_bcs4.bcs,
+  bcs: () => import_bcs3.bcs,
   loadMetadata: () => loadMetadata
 });
 module.exports = __toCommonJS(src_exports);
@@ -61,7 +61,7 @@ __reExport(src_exports, require("@mysten/sui/bcs"), module.exports);
 __reExport(src_exports, require("@mysten/sui/keypairs/ed25519"), module.exports);
 __reExport(src_exports, require("@mysten/sui/keypairs/secp256k1"), module.exports);
 __reExport(src_exports, require("@mysten/sui/keypairs/secp256r1"), module.exports);
-var import_bcs4 = require("@mysten/bcs");
+var import_bcs3 = require("@mysten/bcs");
 
 // src/obelisk.ts
 var import_keccak256 = __toESM(require("keccak256"));
@@ -70,7 +70,6 @@ var import_transactions3 = require("@mysten/sui/transactions");
 
 // src/libs/suiAccountManager/index.ts
 var import_ed255192 = require("@mysten/sui/keypairs/ed25519");
-var import_cryptography = require("@mysten/sui/cryptography");
 
 // src/libs/suiAccountManager/keypair.ts
 var import_ed25519 = require("@mysten/sui/keypairs/ed25519");
@@ -132,6 +131,7 @@ var generateMnemonic = (numberOfWords = 24) => {
 };
 
 // src/libs/suiAccountManager/index.ts
+var import_cryptography = require("@mysten/sui/cryptography");
 var SuiAccountManager = class {
   /**
    * Support the following ways to init the SuiToolkit:
@@ -205,7 +205,6 @@ var import_utils3 = require("@mysten/sui/utils");
 var import_utils2 = require("@mysten/sui/utils");
 var import_transactions = require("@mysten/sui/transactions");
 var import_bcs = require("@mysten/bcs");
-var import_bcs2 = require("@mysten/sui/bcs");
 var getDefaultSuiInputType = (value) => {
   if (typeof value === "string" && (0, import_utils2.isValidSuiObjectId)(value)) {
     return "object";
@@ -217,10 +216,7 @@ var getDefaultSuiInputType = (value) => {
     return void 0;
   }
 };
-function isPureArg(arg) {
-  return arg.Pure !== void 0;
-}
-function makeVecParam(tx, args, type) {
+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]);
@@ -229,32 +225,17 @@ function makeVecParam(tx, args, type) {
   type = type || defaultSuiType;
   if (type === "object") {
     const elements = args.map(
-      (arg) => typeof arg === "string" && (0, import_utils2.isValidSuiObjectId)(arg) ? tx.object((0, import_utils2.normalizeSuiObjectId)(arg)) : convertObjArg(tx, arg)
+      (arg) => typeof arg === "string" && (0, import_utils2.isValidSuiObjectId)(arg) ? txBlock.object((0, import_utils2.normalizeSuiObjectId)(arg)) : convertObjArg(txBlock, arg)
     );
-    return tx.makeMoveVec({ elements });
+    return txBlock.makeMoveVec({ elements });
   } else if (typeof type === "string" && !VECTOR_REGEX.test(type) && !STRUCT_REGEX.test(type)) {
-    if (type === "address") {
-      return tx.pure(import_bcs2.bcs.vector(import_bcs2.bcs.Address).serialize(args));
-    } else if (type === "bool") {
-      return tx.pure(import_bcs2.bcs.vector(import_bcs2.bcs.Bool).serialize(args));
-    } else if (type === "u8") {
-      return tx.pure(import_bcs2.bcs.vector(import_bcs2.bcs.U8).serialize(args));
-    } else if (type === "u16") {
-      return tx.pure(import_bcs2.bcs.vector(import_bcs2.bcs.U16).serialize(args));
-    } else if (type === "u32") {
-      return tx.pure(import_bcs2.bcs.vector(import_bcs2.bcs.U32).serialize(args));
-    } else if (type === "u64") {
-      return tx.pure(import_bcs2.bcs.vector(import_bcs2.bcs.U64).serialize(args));
-    } else if (type === "u128") {
-      return tx.pure(import_bcs2.bcs.vector(import_bcs2.bcs.U128).serialize(args));
-    } else if (type === "u256") {
-      return tx.pure(import_bcs2.bcs.vector(import_bcs2.bcs.U256).serialize(args));
-    } else {
-      return tx.pure(import_bcs2.bcs.vector(import_bcs2.bcs.U8).serialize(args));
-    }
+    const bcsSchema = (0, import_transactions.getPureBcsSchema)(type);
+    return txBlock.pure(import_bcs.bcs.vector(bcsSchema).serialize(args));
   } else {
-    const elements = args.map((arg) => convertObjArg(tx, arg));
-    return tx.makeMoveVec({ elements, type });
+    const elements = args.map(
+      (arg) => convertObjArg(txBlock, arg)
+    );
+    return txBlock.makeMoveVec({ elements, type });
   }
 }
 function isMoveVecArg(arg) {
@@ -265,74 +246,61 @@ function isMoveVecArg(arg) {
   }
   return false;
 }
-function convertArgs(tx, args) {
+function convertArgs(txBlock, args) {
   return args.map((arg) => {
-    if (typeof arg === "string" && (0, import_utils2.isValidSuiObjectId)(arg)) {
-      return tx.object((0, import_utils2.normalizeSuiObjectId)(arg));
-    } else if (typeof arg == "object" && !(0, import_bcs.isSerializedBcs)(arg) && !isPureArg(arg) && !isMoveVecArg(arg)) {
-      return convertObjArg(tx, arg);
-    } else if (isMoveVecArg(arg)) {
+    if (arg instanceof import_bcs.SerializedBcs || (0, import_bcs.isSerializedBcs)(arg)) {
+      return txBlock.pure(arg);
+    }
+    if (isMoveVecArg(arg)) {
       const vecType = "vecType" in arg;
-      return vecType ? makeVecParam(tx, arg.value, arg.vecType) : makeVecParam(tx, arg);
-    } else if ((0, import_bcs.isSerializedBcs)(arg)) {
-      return arg;
-    } else {
-      let argType = getDefaultSuiInputType(arg);
-      if (argType === "address") {
-        return tx.pure.address(arg);
-      } else if (argType === "u64") {
-        return tx.pure.u64(arg);
-      } else if (argType === "bool") {
-        return tx.pure.bool(arg);
-      } else {
-        return tx.pure.u64(arg);
-      }
+      return vecType ? makeVecParam(txBlock, arg.value, arg.vecType) : makeVecParam(txBlock, arg);
     }
+    return arg;
   });
 }
-function convertAddressArg(tx, arg) {
+function convertAddressArg(txBlock, arg) {
   if (typeof arg === "string" && (0, import_utils2.isValidSuiAddress)(arg)) {
-    return tx.pure.address((0, import_utils2.normalizeSuiAddress)(arg));
-  } else if (typeof arg == "object" && !(0, import_bcs.isSerializedBcs)(arg) && !isPureArg(arg)) {
-    return convertObjArg(tx, arg);
-  } else if (isPureArg(arg)) {
-    return tx.pure(Uint8Array.from(arg.Pure));
+    return txBlock.pure.address((0, import_utils2.normalizeSuiAddress)(arg));
   } else {
-    return arg;
+    return convertArgs(txBlock, [arg])[0];
   }
 }
-function convertObjArg(tx, arg) {
+function convertObjArg(txb, arg) {
   if (typeof arg === "string") {
-    return tx.object(arg);
+    return txb.object(arg);
   }
   if ("digest" in arg && "version" in arg && "objectId" in arg) {
-    return tx.objectRef(arg);
+    return txb.objectRef(arg);
   }
   if ("objectId" in arg && "initialSharedVersion" in arg && "mutable" in arg) {
-    return tx.sharedObjectRef(arg);
+    return txb.sharedObjectRef(arg);
   }
   if ("Object" in arg) {
     if ("ImmOrOwnedObject" in arg.Object) {
-      return tx.object(
-        import_transactions.Inputs.ObjectRef(arg.Object.ImmOrOwnedObject)
-      );
+      return txb.object(import_transactions.Inputs.ObjectRef(arg.Object.ImmOrOwnedObject));
     } else if ("SharedObject" in arg.Object) {
-      return tx.object(
-        import_transactions.Inputs.SharedObjectRef(
-          arg.Object.SharedObject
-        )
-      );
-    } else if ("Receiving" in arg.Object) {
-      return tx.object(import_transactions.Inputs.ReceivingRef(arg.Object.Receiving));
+      return txb.object(import_transactions.Inputs.SharedObjectRef(arg.Object.SharedObject));
     } else {
       throw new Error("Invalid argument type");
     }
   }
-  if ("kind" in arg) {
+  if (typeof arg === "function") {
+    return arg;
+  }
+  if ("GasCoin" in arg || "Input" in arg || "Result" in arg || "NestedResult" in arg) {
     return arg;
   }
   throw new Error("Invalid argument type");
 }
+function convertAmounts(txBlock, amounts) {
+  return amounts.map((amount) => {
+    if (typeof amount === "number" || typeof amount === "bigint") {
+      return amount;
+    } else {
+      return convertArgs(txBlock, [amount])[0];
+    }
+  });
+}
 
 // src/libs/suiTxBuilder/index.ts
 var SuiTx = class {
@@ -359,8 +327,8 @@ var SuiTx = class {
   address(value) {
     return this.tx.pure.address(value);
   }
-  pure(value) {
-    return this.tx.pure(value);
+  get pure() {
+    return this.tx.pure.bind(this.tx);
   }
   object(value) {
     return this.tx.object(value);
@@ -395,6 +363,9 @@ var SuiTx = class {
   serialize() {
     return this.tx.serialize();
   }
+  toJSON() {
+    return this.tx.toJSON();
+  }
   sign(params) {
     return this.tx.sign(params);
   }
@@ -413,24 +384,11 @@ var SuiTx = class {
   }) {
     return this.tx.publish({ modules, dependencies });
   }
-  upgrade({
-    modules,
-    dependencies,
-    package: packageId,
-    ticket
-  }) {
-    return this.tx.upgrade({
-      modules,
-      dependencies,
-      package: packageId,
-      ticket
-    });
+  upgrade(...args) {
+    return this.tx.upgrade(...args);
   }
-  makeMoveVec({
-    elements,
-    type
-  }) {
-    return this.tx.makeMoveVec({ elements, type });
+  makeMoveVec(...args) {
+    return this.tx.makeMoveVec(...args);
   }
   /* Override methods of TransactionBlock */
   transferObjects(objects, address) {
@@ -482,7 +440,9 @@ var SuiTx = class {
     }
     const coins = this.tx.splitCoins(
       this.tx.gas,
-      convertArgs(this.tx, amounts)
+      amounts.map(
+        (amount) => typeof amount === "number" || typeof amount === "bigint" ? amount : convertArgs(this.tx, [amount])[0]
+      )
     );
     const recipientObjects = recipients.map(
       (recipient) => convertAddressArg(this.tx, recipient)
@@ -501,10 +461,9 @@ var SuiTx = class {
     if (coins.length > 1) {
       this.tx.mergeCoins(mergedCoin, coinObjects.slice(1));
     }
-    const [sendCoin] = this.tx.splitCoins(
-      mergedCoin,
-      convertArgs(this.tx, [amount])
-    );
+    const [sendCoin] = this.tx.splitCoins(mergedCoin, [
+      typeof amount === "number" || typeof amount === "bigint" ? amount : convertArgs(this.tx, [amount])[0]
+    ]);
     return [sendCoin, mergedCoin];
   }
   splitSUIFromGas(amounts) {
@@ -518,7 +477,7 @@ var SuiTx = class {
     }
     const splitedCoins = this.tx.splitCoins(
       mergedCoin,
-      convertArgs(this.tx, amounts)
+      convertAmounts(this.tx, amounts)
     );
     return { splitedCoins, mergedCoin };
   }
@@ -548,14 +507,14 @@ var SuiTx = class {
   stakeSui(amount, validatorAddr) {
     const [stakeCoin] = this.tx.splitCoins(
       this.tx.gas,
-      convertArgs(this.tx, [amount])
+      convertAmounts(this.tx, [amount])
     );
     return this.tx.moveCall({
       target: "0x3::sui_system::request_add_stake",
       arguments: convertArgs(this.tx, [
-        import_utils3.SUI_SYSTEM_STATE_OBJECT_ID,
+        this.tx.object(import_utils3.SUI_SYSTEM_STATE_OBJECT_ID),
         stakeCoin,
-        this.tx.pure.address(validatorAddr.toString())
+        convertAddressArg(this.tx, validatorAddr)
       ])
     });
   }
@@ -990,7 +949,7 @@ function numberToAddressHex(num) {
 }
 
 // src/obelisk.ts
-var import_bcs3 = require("@mysten/bcs");
+var import_bcs2 = require("@mysten/bcs");
 function isUndefined(value) {
   return value === void 0;
 }
@@ -1015,7 +974,7 @@ function createTx(meta, fn) {
     }
   );
 }
-var _query, _tx, _struct, _exec, _read;
+var _query, _tx, _object, _exec, _read, _bcs;
 var Obelisk = class {
   /**
    * Support the following ways to init the ObeliskClient:
@@ -1039,7 +998,49 @@ var Obelisk = class {
   } = {}) {
     __privateAdd(this, _query, {});
     __privateAdd(this, _tx, {});
-    __privateAdd(this, _struct, {});
+    __privateAdd(this, _object, {
+      address: import_bcs2.bcs.bytes(32).transform({
+        // To change the input type, you need to provide a type definition for the input
+        input: (val) => (0, import_bcs2.fromHEX)(val),
+        output: (val) => (0, import_bcs2.toHEX)(val)
+      }),
+      u8: import_bcs2.bcs.u8(),
+      u16: import_bcs2.bcs.u16(),
+      u32: import_bcs2.bcs.u32(),
+      u64: import_bcs2.bcs.u64(),
+      u128: import_bcs2.bcs.u128(),
+      u256: import_bcs2.bcs.u256(),
+      bool: import_bcs2.bcs.bool(),
+      "0x1::ascii::String": import_bcs2.bcs.string(),
+      "0x1::option::Option<address>": import_bcs2.bcs.option(
+        import_bcs2.bcs.bytes(32).transform({
+          // To change the input type, you need to provide a type definition for the input
+          input: (val) => (0, import_bcs2.fromHEX)(val),
+          output: (val) => (0, import_bcs2.toHEX)(val)
+        })
+      ),
+      "0x1::option::Option<u8>": import_bcs2.bcs.option(import_bcs2.bcs.u8()),
+      "0x1::option::Option<u16>": import_bcs2.bcs.option(import_bcs2.bcs.u16()),
+      "0x1::option::Option<u32>": import_bcs2.bcs.option(import_bcs2.bcs.u32()),
+      "0x1::option::Option<u64>": import_bcs2.bcs.option(import_bcs2.bcs.u64()),
+      "0x1::option::Option<u128>": import_bcs2.bcs.option(import_bcs2.bcs.u128()),
+      "0x1::option::Option<u256>": import_bcs2.bcs.option(import_bcs2.bcs.u256()),
+      "0x1::option::Option<bool>": import_bcs2.bcs.option(import_bcs2.bcs.bool()),
+      "vector<address>": import_bcs2.bcs.vector(
+        import_bcs2.bcs.bytes(32).transform({
+          // To change the input type, you need to provide a type definition for the input
+          input: (val) => (0, import_bcs2.fromHEX)(val),
+          output: (val) => (0, import_bcs2.toHEX)(val)
+        })
+      ),
+      "vector<u8>": import_bcs2.bcs.vector(import_bcs2.bcs.u8()),
+      "vector<u16>": import_bcs2.bcs.vector(import_bcs2.bcs.u16()),
+      "vector<u32>": import_bcs2.bcs.vector(import_bcs2.bcs.u32()),
+      "vector<u64>": import_bcs2.bcs.vector(import_bcs2.bcs.u64()),
+      "vector<u128>": import_bcs2.bcs.vector(import_bcs2.bcs.u128()),
+      "vector<u256>": import_bcs2.bcs.vector(import_bcs2.bcs.u256()),
+      "vector<bool>": import_bcs2.bcs.vector(import_bcs2.bcs.bool())
+    });
     __privateAdd(this, _exec, async (meta, tx, params, typeArguments, isRaw) => {
       if (isRaw === true) {
         return tx.moveCall({
@@ -1070,43 +1071,221 @@ var Obelisk = class {
       });
       return await this.inspectTxn(tx);
     });
+    __privateAdd(this, _bcs, (bcsmeta) => {
+      let loopFlag = false;
+      const bcsJson = {};
+      Object.entries(bcsmeta.objectType.fields).forEach(([index, type]) => {
+        const objName = type.name;
+        const objType = type.type;
+        switch (typeof objType) {
+          case "object":
+            for (const [key, value] of Object.entries(objType)) {
+              switch (key) {
+                case "Struct":
+                  const structType = value;
+                  if (structType.address === "0x1" && structType.module === "ascii" && structType.name === "String") {
+                    bcsJson[objName] = import_bcs2.bcs.string();
+                    return;
+                  } else if (structType.address === "0x2" && structType.module === "object" && structType.name === "UID") {
+                    bcsJson[objName] = import_bcs2.bcs.fixedArray(32, import_bcs2.bcs.u8()).transform({
+                      input: (id) => (0, import_bcs2.fromHEX)(id),
+                      output: (id) => (0, import_bcs2.toHEX)(Uint8Array.from(id))
+                    });
+                    return;
+                  } else if (structType.address === "0x2" && structType.module === "object" && structType.name === "ID") {
+                    bcsJson[objName] = import_bcs2.bcs.fixedArray(32, import_bcs2.bcs.u8()).transform({
+                      input: (id) => (0, import_bcs2.fromHEX)(id),
+                      output: (id) => (0, import_bcs2.toHEX)(Uint8Array.from(id))
+                    });
+                    return;
+                  } else if (structType.address === "0x2" && structType.module === "bag" && structType.name === "Bag") {
+                    bcsJson[objName] = import_bcs2.bcs.fixedArray(32, import_bcs2.bcs.u8()).transform({
+                      input: (id) => (0, import_bcs2.fromHEX)(id),
+                      output: (id) => (0, import_bcs2.toHEX)(Uint8Array.from(id))
+                    });
+                    return;
+                  } else if (structType.address === "0x1" && structType.module === "option" && structType.name === "Option") {
+                    switch (structType.typeArguments[0]) {
+                      case "U8":
+                        bcsJson[objName] = import_bcs2.bcs.option(import_bcs2.bcs.u8());
+                        return;
+                      case "U16":
+                        bcsJson[objName] = import_bcs2.bcs.option(import_bcs2.bcs.u16());
+                        return;
+                      case "U32":
+                        bcsJson[objName] = import_bcs2.bcs.option(import_bcs2.bcs.u32());
+                        return;
+                      case "U64":
+                        bcsJson[objName] = import_bcs2.bcs.option(import_bcs2.bcs.u64());
+                        return;
+                      case "U128":
+                        bcsJson[objName] = import_bcs2.bcs.option(import_bcs2.bcs.u128());
+                        return;
+                      case "U256":
+                        bcsJson[objName] = import_bcs2.bcs.option(import_bcs2.bcs.u256());
+                        return;
+                      case "Bool":
+                        bcsJson[objName] = import_bcs2.bcs.option(import_bcs2.bcs.bool());
+                        return;
+                      case "Address":
+                        bcsJson[objName] = import_bcs2.bcs.option(
+                          import_bcs2.bcs.bytes(32).transform({
+                            // To change the input type, you need to provide a type definition for the input
+                            input: (val) => (0, import_bcs2.fromHEX)(val),
+                            output: (val) => (0, import_bcs2.toHEX)(val)
+                          })
+                        );
+                        return;
+                      default:
+                    }
+                  } else {
+                    if (this.object[`${structType.address}::${structType.module}::${structType.name}`] === void 0) {
+                      loopFlag = true;
+                    } else {
+                      bcsJson[objName] = this.object[`${structType.address}::${structType.module}::${structType.name}`];
+                      return;
+                    }
+                  }
+                  return;
+                case "Vector":
+                  switch (value) {
+                    case "U8":
+                      bcsJson[objName] = import_bcs2.bcs.vector(import_bcs2.bcs.u8());
+                      return;
+                    case "U16":
+                      bcsJson[objName] = import_bcs2.bcs.vector(import_bcs2.bcs.u16());
+                      return;
+                    case "U32":
+                      bcsJson[objName] = import_bcs2.bcs.vector(import_bcs2.bcs.u32());
+                      return;
+                    case "U64":
+                      bcsJson[objName] = import_bcs2.bcs.vector(import_bcs2.bcs.u64());
+                      return;
+                    case "U128":
+                      bcsJson[objName] = import_bcs2.bcs.vector(import_bcs2.bcs.u128());
+                      return;
+                    case "U256":
+                      bcsJson[objName] = import_bcs2.bcs.vector(import_bcs2.bcs.u256());
+                      return;
+                    case "Bool":
+                      bcsJson[objName] = import_bcs2.bcs.vector(import_bcs2.bcs.bool());
+                      return;
+                    case "Address":
+                      bcsJson[objName] = import_bcs2.bcs.vector(
+                        import_bcs2.bcs.bytes(32).transform({
+                          // To change the input type, you need to provide a type definition for the input
+                          input: (val) => (0, import_bcs2.fromHEX)(val),
+                          output: (val) => (0, import_bcs2.toHEX)(val)
+                        })
+                      );
+                      return;
+                    default:
+                  }
+                case "TypeParameter":
+                  bcsJson[objName] = import_bcs2.bcs.u128();
+                  return;
+                default:
+                  throw new Error("Unsupported type");
+              }
+            }
+            return;
+          case "string":
+            switch (objType) {
+              case "U8":
+                bcsJson[objName] = import_bcs2.bcs.u8();
+                return;
+              case "U16":
+                bcsJson[objName] = import_bcs2.bcs.u16();
+                return;
+              case "U32":
+                bcsJson[objName] = import_bcs2.bcs.u32();
+                return;
+              case "U64":
+                bcsJson[objName] = import_bcs2.bcs.u64();
+                return;
+              case "U128":
+                bcsJson[objName] = import_bcs2.bcs.u128();
+                return;
+              case "U256":
+                bcsJson[objName] = import_bcs2.bcs.u256();
+                return;
+              case "Bool":
+                bcsJson[objName] = import_bcs2.bcs.bool();
+                return;
+              case "Address":
+                bcsJson[objName] = import_bcs2.bcs.bytes(32).transform({
+                  // To change the input type, you need to provide a type definition for the input
+                  input: (val) => (0, import_bcs2.fromHEX)(val),
+                  output: (val) => (0, import_bcs2.toHEX)(val)
+                });
+                return;
+              default:
+                return;
+            }
+          default:
+            throw new Error("Unsupported type");
+        }
+      });
+      return {
+        bcs: import_bcs2.bcs.struct(bcsmeta.objectName, bcsJson),
+        loopFlag
+      };
+    });
     this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
     fullnodeUrls = fullnodeUrls || [(0, import_client2.getFullnodeUrl)(networkType ?? "mainnet")];
     this.suiInteractor = new SuiInteractor(fullnodeUrls, networkType);
     this.packageId = packageId;
     if (metadata !== void 0) {
       this.metadata = metadata;
-      Object.values(metadata).forEach(
-        (moudlevalue) => {
-          const data = moudlevalue;
-          const moduleName = data.name;
-          Object.entries(data.exposedFunctions).forEach(
-            ([funcName, funcvalue]) => {
-              const meta = funcvalue;
-              meta.moduleName = moduleName;
-              meta.funcName = funcName;
-              if (isUndefined(__privateGet(this, _query)[moduleName])) {
-                __privateGet(this, _query)[moduleName] = {};
-              }
-              if (isUndefined(__privateGet(this, _query)[moduleName][funcName])) {
-                __privateGet(this, _query)[moduleName][funcName] = createQuery(
-                  meta,
-                  (tx, p, typeArguments, isRaw) => __privateGet(this, _read).call(this, meta, tx, p, typeArguments, isRaw)
-                );
+      let stillNeedFormat = true;
+      while (stillNeedFormat === true) {
+        let loopFlag = false;
+        Object.values(metadata).forEach(
+          (moudlevalue) => {
+            const data = moudlevalue;
+            const moduleName = data.name;
+            const objMoudleId = `${packageId}::${moduleName}`;
+            Object.entries(data.structs).forEach(([objectName, objectType]) => {
+              const objId = `${objMoudleId}::${objectName}`;
+              const bcsmeta = {
+                objectName,
+                objectType
+              };
+              let bcsObj = __privateGet(this, _bcs).call(this, bcsmeta);
+              if (bcsObj.loopFlag === true) {
+                loopFlag = bcsObj.loopFlag;
               }
-              if (isUndefined(__privateGet(this, _tx)[moduleName])) {
-                __privateGet(this, _tx)[moduleName] = {};
+              __privateGet(this, _object)[objId] = bcsObj.bcs;
+            });
+            Object.entries(data.exposedFunctions).forEach(
+              ([funcName, funcvalue]) => {
+                const meta = funcvalue;
+                meta.moduleName = moduleName;
+                meta.funcName = funcName;
+                if (isUndefined(__privateGet(this, _query)[moduleName])) {
+                  __privateGet(this, _query)[moduleName] = {};
+                }
+                if (isUndefined(__privateGet(this, _query)[moduleName][funcName])) {
+                  __privateGet(this, _query)[moduleName][funcName] = createQuery(
+                    meta,
+                    (tx, p, typeArguments, isRaw) => __privateGet(this, _read).call(this, meta, tx, p, typeArguments, isRaw)
+                  );
+                }
+                if (isUndefined(__privateGet(this, _tx)[moduleName])) {
+                  __privateGet(this, _tx)[moduleName] = {};
+                }
+                if (isUndefined(__privateGet(this, _tx)[moduleName][funcName])) {
+                  __privateGet(this, _tx)[moduleName][funcName] = createTx(
+                    meta,
+                    (tx, p, typeArguments, isRaw) => __privateGet(this, _exec).call(this, meta, tx, p, typeArguments, isRaw)
+                  );
+                }
               }
-              if (isUndefined(__privateGet(this, _tx)[moduleName][funcName])) {
-                __privateGet(this, _tx)[moduleName][funcName] = createTx(
-                  meta,
-                  (tx, p, typeArguments, isRaw) => __privateGet(this, _exec).call(this, meta, tx, p, typeArguments, isRaw)
-                );
-              }
-            }
-          );
-        }
-      );
+            );
+          }
+        );
+        stillNeedFormat = loopFlag;
+      }
     }
     this.contractFactory = new SuiContractFactory({
       packageId,
@@ -1119,8 +1298,23 @@ var Obelisk = class {
   get tx() {
     return __privateGet(this, _tx);
   }
-  get struct() {
-    return __privateGet(this, _struct);
+  get object() {
+    return __privateGet(this, _object);
+  }
+  view(dryResult) {
+    let returnValues = [];
+    if (dryResult.effects.status.status === "success") {
+      const resultList = dryResult.results[0].returnValues;
+      for (const res of resultList) {
+        let baseValue = res[0];
+        let baseType = res[1];
+        const value = Uint8Array.from(baseValue);
+        returnValues.push(this.object[baseType].parse(value));
+      }
+      return returnValues;
+    } else {
+      return void 0;
+    }
   }
   /**
    * if derivePathParams is not provided or mnemonics is empty, it will return the keypair.
@@ -1338,50 +1532,11 @@ var Obelisk = class {
     if (entityId !== void 0) {
       params.push(tx.pure.address(entityId));
     }
-    const getResult = await this.query[schemaModuleName].get(
+    const dryResult = await this.query[schemaModuleName].get(
       tx,
       params
     );
-    let returnValues = [];
-    if (getResult.effects.status.status === "success") {
-      const resultList = getResult.results[0].returnValues;
-      for (const res of resultList) {
-        let baseValue = res[0];
-        let baseType = res[1];
-        const value = Uint8Array.from(baseValue);
-        if (baseType === "address") {
-          const Address = import_bcs3.bcs.bytes(32).transform({
-            // To change the input type, you need to provide a type definition for the input
-            input: (val) => (0, import_bcs3.fromHEX)(val),
-            output: (val) => (0, import_bcs3.toHEX)(val)
-          });
-          returnValues.push(Address.parse(value));
-        } else if (baseType === "u8") {
-          returnValues.push(import_bcs3.bcs.u8().parse(value));
-        } else if (baseType === "u16") {
-          returnValues.push(import_bcs3.bcs.u16().parse(value));
-        } else if (baseType === "u32") {
-          returnValues.push(import_bcs3.bcs.u32().parse(value));
-        } else if (baseType === "u64") {
-          returnValues.push(import_bcs3.bcs.u64().parse(value));
-        } else if (baseType === "u128") {
-          returnValues.push(import_bcs3.bcs.u128().parse(value));
-        } else if (baseType === "u256") {
-          returnValues.push(import_bcs3.bcs.u256().parse(value));
-        } else if (baseType === "bool") {
-          returnValues.push(import_bcs3.bcs.bool().parse(value));
-        } else if (baseType === "0x1::ascii::String") {
-          returnValues.push(import_bcs3.bcs.string().parse(value));
-        } else if (baseType === "vector<u8>") {
-          returnValues.push(import_bcs3.bcs.vector(import_bcs3.bcs.u8()).parse(value));
-        } else if (baseType === "0x1::option::Option<u8>") {
-          returnValues.push(import_bcs3.bcs.option(import_bcs3.bcs.u8()).parse(value));
-        }
-      }
-      return returnValues;
-    } else {
-      return void 0;
-    }
+    return this.view(dryResult);
   }
   async containEntity(worldId, schemaName, entityId) {
     const schemaModuleName = `${schemaName}_schema`;
@@ -1390,18 +1545,11 @@ var Obelisk = class {
     if (entityId !== void 0) {
       params.push(tx.pure.address(entityId));
     }
-    const getResult = await this.query[schemaModuleName].contains(
+    const dryResult = await this.query[schemaModuleName].contains(
       tx,
       params
     );
-    if (getResult.effects.status.status === "success") {
-      const res = getResult.results[0].returnValues[0];
-      let baseValue = res[0];
-      const value = Uint8Array.from(baseValue);
-      return import_bcs3.bcs.bool().parse(value);
-    } else {
-      return void 0;
-    }
+    return this.view(dryResult);
   }
   // async getEntities(
   //   worldId: string,
@@ -1461,10 +1609,10 @@ var Obelisk = class {
     const hashBytes = (0, import_keccak256.default)(bytes);
     const hashU8Array = Array.from(hashBytes);
     const value = Uint8Array.from(hashU8Array);
-    const Address = import_bcs3.bcs.bytes(32).transform({
+    const Address = import_bcs2.bcs.bytes(32).transform({
       // To change the input type, you need to provide a type definition for the input
-      input: (val) => (0, import_bcs3.fromHEX)(val),
-      output: (val) => (0, import_bcs3.toHEX)(val)
+      input: (val) => (0, import_bcs2.fromHEX)(val),
+      output: (val) => (0, import_bcs2.toHEX)(val)
     });
     const data = Address.parse(value);
     return "0x" + data;
@@ -1485,7 +1633,7 @@ var Obelisk = class {
     if (checkObjectId !== null) {
       objectId = checkObjectId;
       const bytes = Buffer.from(objectId.slice(2), "hex");
-      const numberBytes = import_bcs3.bcs.u256().serialize(x).toBytes();
+      const numberBytes = import_bcs2.bcs.u256().serialize(x).toBytes();
       return this.entity_key_from_bytes(Buffer.concat([bytes, numberBytes]));
     } else {
       return void 0;
@@ -1498,54 +1646,13 @@ var Obelisk = class {
   //   const u8Value = Uint8Array.from(value);
   //   return bcs.de(type, u8Value);
   // }
-  async autoFormatDryValue(value) {
-    let returnValues = [];
-    if (value.effects.status.status === "success") {
-      const resultList = value.results[0].returnValues;
-      for (const res of resultList) {
-        let baseValue = res[0];
-        let baseType = res[1];
-        const value2 = Uint8Array.from(baseValue);
-        if (baseType === "address") {
-          const Address = import_bcs3.bcs.bytes(32).transform({
-            // To change the input type, you need to provide a type definition for the input
-            input: (val) => (0, import_bcs3.fromHEX)(val),
-            output: (val) => (0, import_bcs3.toHEX)(val)
-          });
-          returnValues.push(Address.parse(value2));
-        } else if (baseType === "u8") {
-          returnValues.push(import_bcs3.bcs.u8().parse(value2));
-        } else if (baseType === "u16") {
-          returnValues.push(import_bcs3.bcs.u16().parse(value2));
-        } else if (baseType === "u32") {
-          returnValues.push(import_bcs3.bcs.u32().parse(value2));
-        } else if (baseType === "u64") {
-          returnValues.push(import_bcs3.bcs.u64().parse(value2));
-        } else if (baseType === "u128") {
-          returnValues.push(import_bcs3.bcs.u128().parse(value2));
-        } else if (baseType === "u256") {
-          returnValues.push(import_bcs3.bcs.u256().parse(value2));
-        } else if (baseType === "bool") {
-          returnValues.push(import_bcs3.bcs.bool().parse(value2));
-        } else if (baseType === "0x1::ascii::String") {
-          returnValues.push(import_bcs3.bcs.string().parse(value2));
-        } else if (baseType === "vector<u8>") {
-          returnValues.push(import_bcs3.bcs.vector(import_bcs3.bcs.u8()).parse(value2));
-        } else if (baseType === "0x1::option::Option<u8>") {
-          returnValues.push(import_bcs3.bcs.option(import_bcs3.bcs.u8()).parse(value2));
-        }
-      }
-      return returnValues;
-    } else {
-      return void 0;
-    }
-  }
 };
 _query = new WeakMap();
 _tx = new WeakMap();
-_struct = new WeakMap();
+_object = new WeakMap();
 _exec = new WeakMap();
 _read = new WeakMap();
+_bcs = new WeakMap();
 
 // src/libs/multiSig/client.ts
 var import_multisig = require("@mysten/sui/multisig");