@0xobelisk/sui-client 0.5.16 → 0.5.18

package/dist/index.js

@@ -44,33 +44,36 @@ var __privateAdd = (obj, member, value) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  BCS: () => import_bcs4.BCS,
+  BcsType: () => import_bcs4.BcsType,
   MultiSigClient: () => MultiSigClient,
   Obelisk: () => Obelisk,
   SuiAccountManager: () => SuiAccountManager,
   SuiContractFactory: () => SuiContractFactory,
-  SuiTxBlock: () => SuiTxBlock,
-  getSuiMoveConfig: () => import_bcs4.getSuiMoveConfig,
+  SuiTx: () => SuiTx,
+  bcs: () => import_bcs4.bcs,
   loadMetadata: () => loadMetadata
 });
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("@mysten/sui.js/client"), module.exports);
-__reExport(src_exports, require("@mysten/sui.js/utils"), module.exports);
-__reExport(src_exports, require("@mysten/sui.js/transactions"), module.exports);
-__reExport(src_exports, require("@mysten/sui.js/keypairs/ed25519"), module.exports);
-__reExport(src_exports, require("@mysten/sui.js/keypairs/secp256k1"), module.exports);
-__reExport(src_exports, require("@mysten/sui.js/keypairs/secp256r1"), module.exports);
+__reExport(src_exports, require("@mysten/sui/client"), module.exports);
+__reExport(src_exports, require("@mysten/sui/utils"), module.exports);
+__reExport(src_exports, require("@mysten/sui/transactions"), module.exports);
+__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");
 
 // src/obelisk.ts
-var import_client2 = require("@mysten/sui.js/client");
-var import_transactions3 = require("@mysten/sui.js/transactions");
+var import_keccak256 = __toESM(require("keccak256"));
+var import_client2 = require("@mysten/sui/client");
+var import_transactions3 = require("@mysten/sui/transactions");
 
 // src/libs/suiAccountManager/index.ts
-var import_ed255192 = require("@mysten/sui.js/keypairs/ed25519");
+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.js/keypairs/ed25519");
+var import_ed25519 = require("@mysten/sui/keypairs/ed25519");
 var getDerivePathForSUI = (derivePathParams = {}) => {
   const {
     accountIndex = 0,
@@ -85,7 +88,7 @@ var getKeyPair = (mnemonics, derivePathParams = {}) => {
 };
 
 // src/libs/suiAccountManager/util.ts
-var import_utils = require("@mysten/sui.js/utils");
+var import_utils = require("@mysten/sui/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) => {
@@ -137,7 +140,7 @@ var SuiAccountManager = class {
    * If none of them is provided, will generate a random mnemonics with 24 words.
    *
    * @param mnemonics, 12 or 24 mnemonics words, separated by space
-   * @param secretKey, base64 or hex string, when mnemonics is provided, secretKey will be ignored
+   * @param secretKey, base64 or hex string or Bech32 string, when mnemonics is provided, secretKey will be ignored
    */
   constructor({ mnemonics, secretKey } = {}) {
     this.mnemonics = mnemonics || "";
@@ -145,11 +148,23 @@ var SuiAccountManager = class {
     if (!this.mnemonics && !this.secretKey) {
       this.mnemonics = generateMnemonic(24);
     }
-    this.currentKeyPair = this.secretKey ? import_ed255192.Ed25519Keypair.fromSecretKey(
-      normalizePrivateKey(hexOrBase64ToUint8Array(this.secretKey))
-    ) : getKeyPair(this.mnemonics);
+    this.currentKeyPair = this.secretKey ? this.parseSecretKey(this.secretKey) : getKeyPair(this.mnemonics);
     this.currentAddress = this.currentKeyPair.getPublicKey().toSuiAddress();
   }
+  /**
+   * Check if the secretKey starts with bench32 format
+   */
+  parseSecretKey(secretKey) {
+    if (secretKey.startsWith(import_cryptography.SUI_PRIVATE_KEY_PREFIX)) {
+      const { secretKey: uint8ArraySecretKey } = (0, import_cryptography.decodeSuiPrivateKey)(secretKey);
+      return import_ed255192.Ed25519Keypair.fromSecretKey(
+        normalizePrivateKey(uint8ArraySecretKey)
+      );
+    }
+    return import_ed255192.Ed25519Keypair.fromSecretKey(
+      normalizePrivateKey(hexOrBase64ToUint8Array(secretKey))
+    );
+  }
   /**
    * if derivePathParams is not provided or mnemonics is empty, it will return the currentKeyPair.
    * else:
@@ -183,14 +198,14 @@ var SuiAccountManager = class {
 };
 
 // src/libs/suiTxBuilder/index.ts
-var import_transactions2 = require("@mysten/sui.js/transactions");
-var import_utils3 = require("@mysten/sui.js/utils");
+var import_transactions2 = require("@mysten/sui/transactions");
+var import_utils3 = require("@mysten/sui/utils");
 
 // src/libs/suiTxBuilder/util.ts
-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 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";
@@ -202,7 +217,10 @@ var getDefaultSuiInputType = (value) => {
     return void 0;
   }
 };
-function makeVecParam(txBlock, args, type) {
+function isPureArg(arg) {
+  return arg.Pure !== void 0;
+}
+function makeVecParam(tx, args, type) {
   if (args.length === 0)
     throw new Error("Transaction builder error: Empty array is not allowed");
   const defaultSuiType = getDefaultSuiInputType(args[0]);
@@ -210,17 +228,33 @@ function makeVecParam(txBlock, args, type) {
   const STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
   type = type || defaultSuiType;
   if (type === "object") {
-    const objects = args.map(
-      (arg) => typeof arg === "string" && (0, import_utils2.isValidSuiObjectId)(arg) ? txBlock.object((0, import_utils2.normalizeSuiObjectId)(arg)) : convertObjArg(txBlock, arg)
+    const elements = args.map(
+      (arg) => typeof arg === "string" && (0, import_utils2.isValidSuiObjectId)(arg) ? tx.object((0, import_utils2.normalizeSuiObjectId)(arg)) : convertObjArg(tx, arg)
     );
-    return txBlock.makeMoveVec({ objects });
+    return tx.makeMoveVec({ elements });
   } else if (typeof type === "string" && !VECTOR_REGEX.test(type) && !STRUCT_REGEX.test(type)) {
-    return txBlock.pure(args, `vector<${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));
+    }
   } else {
-    const objects = args.map(
-      (arg) => convertObjArg(txBlock, arg)
-    );
-    return txBlock.makeMoveVec({ objects, type });
+    const elements = args.map((arg) => convertObjArg(tx, arg));
+    return tx.makeMoveVec({ elements, type });
   }
 }
 function isMoveVecArg(arg) {
@@ -231,48 +265,65 @@ function isMoveVecArg(arg) {
   }
   return false;
 }
-function convertArgs(txBlock, args) {
+function convertArgs(tx, args) {
   return args.map((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);
+      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)) {
       const vecType = "vecType" in arg;
-      return vecType ? makeVecParam(txBlock, arg.value, arg.vecType) : makeVecParam(txBlock, arg);
-    } else if ((0, import_bcs2.isSerializedBcs)(arg)) {
+      return vecType ? makeVecParam(tx, arg.value, arg.vecType) : makeVecParam(tx, arg);
+    } else if ((0, import_bcs.isSerializedBcs)(arg)) {
       return arg;
     } else {
-      return txBlock.pure(arg);
+      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);
+      }
     }
   });
 }
-function convertAddressArg(txBlock, arg) {
+function convertAddressArg(tx, 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);
+    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));
   } else {
     return arg;
   }
 }
-function convertObjArg(txb, arg) {
+function convertObjArg(tx, arg) {
   if (typeof arg === "string") {
-    return txb.object(arg);
+    return tx.object(arg);
   }
   if ("digest" in arg && "version" in arg && "objectId" in arg) {
-    return txb.objectRef(arg);
+    return tx.objectRef(arg);
   }
   if ("objectId" in arg && "initialSharedVersion" in arg && "mutable" in arg) {
-    return txb.sharedObjectRef(arg);
+    return tx.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));
+    if ("ImmOrOwnedObject" in arg.Object) {
+      return tx.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));
     } else {
       throw new Error("Invalid argument type");
     }
@@ -284,108 +335,123 @@ function convertObjArg(txb, arg) {
 }
 
 // src/libs/suiTxBuilder/index.ts
-var SuiTxBlock = class {
+var SuiTx = class {
   constructor(transaction) {
-    this.txBlock = new import_transactions2.TransactionBlock(transaction);
+    if (transaction !== void 0) {
+      this.tx = import_transactions2.Transaction.from(transaction);
+    } else {
+      this.tx = new import_transactions2.Transaction();
+    }
   }
   /* Directly wrap methods and properties of TransactionBlock */
   get gas() {
-    return this.txBlock.gas;
+    return this.tx.gas;
   }
   get blockData() {
-    return this.txBlock.blockData;
+    return this.tx.blockData;
+  }
+  autoPure(value, type) {
+    if (type === void 0) {
+      return convertArgs(this.tx, [value]);
+    }
+    return;
   }
   address(value) {
-    return this.txBlock.pure(value, "address");
+    return this.tx.pure.address(value);
   }
-  pure(value, type) {
-    return this.txBlock.pure(value, type);
+  pure(value) {
+    return this.tx.pure(value);
   }
   object(value) {
-    return this.txBlock.object(value);
+    return this.tx.object(value);
   }
   objectRef(ref) {
-    return this.txBlock.objectRef(ref);
+    return this.tx.objectRef(ref);
   }
   sharedObjectRef(ref) {
-    return this.txBlock.sharedObjectRef(ref);
+    return this.tx.sharedObjectRef(ref);
   }
   setSender(sender) {
-    return this.txBlock.setSender(sender);
+    return this.tx.setSender(sender);
   }
   setSenderIfNotSet(sender) {
-    return this.txBlock.setSenderIfNotSet(sender);
+    return this.tx.setSenderIfNotSet(sender);
   }
   setExpiration(expiration) {
-    return this.txBlock.setExpiration(expiration);
+    return this.tx.setExpiration(expiration);
   }
   setGasPrice(price) {
-    return this.txBlock.setGasPrice(price);
+    return this.tx.setGasPrice(price);
   }
   setGasBudget(budget) {
-    return this.txBlock.setGasBudget(budget);
+    return this.tx.setGasBudget(budget);
   }
   setGasOwner(owner) {
-    return this.txBlock.setGasOwner(owner);
+    return this.tx.setGasOwner(owner);
   }
   setGasPayment(payments) {
-    return this.txBlock.setGasPayment(payments);
+    return this.tx.setGasPayment(payments);
   }
   serialize() {
-    return this.txBlock.serialize();
+    return this.tx.serialize();
   }
   sign(params) {
-    return this.txBlock.sign(params);
+    return this.tx.sign(params);
   }
   build(params = {}) {
-    return this.txBlock.build(params);
+    return this.tx.build(params);
   }
   getDigest(params = {}) {
-    return this.txBlock.getDigest(params);
+    return this.tx.getDigest(params);
   }
   add(...args) {
-    return this.txBlock.add(...args);
+    return this.tx.add(...args);
   }
   publish({
     modules,
     dependencies
   }) {
-    return this.txBlock.publish({ modules, dependencies });
+    return this.tx.publish({ modules, dependencies });
   }
   upgrade({
     modules,
     dependencies,
-    packageId,
+    package: packageId,
     ticket
   }) {
-    return this.txBlock.upgrade({ modules, dependencies, packageId, ticket });
+    return this.tx.upgrade({
+      modules,
+      dependencies,
+      package: packageId,
+      ticket
+    });
   }
   makeMoveVec({
-    objects,
+    elements,
     type
   }) {
-    return this.txBlock.makeMoveVec({ objects, type });
+    return this.tx.makeMoveVec({ elements, type });
   }
   /* Override methods of TransactionBlock */
   transferObjects(objects, address) {
-    return this.txBlock.transferObjects(
-      objects.map((object) => convertObjArg(this.txBlock, object)),
-      convertAddressArg(this.txBlock, address)
+    return this.tx.transferObjects(
+      objects.map((object) => convertObjArg(this.tx, object)),
+      convertAddressArg(this.tx, address)
     );
   }
   splitCoins(coin, amounts) {
-    const res = this.txBlock.splitCoins(
-      convertObjArg(this.txBlock, coin),
-      convertArgs(this.txBlock, amounts)
+    const res = this.tx.splitCoins(
+      convertObjArg(this.tx, coin),
+      convertArgs(this.tx, amounts)
     );
     return amounts.map((_, i) => res[i]);
   }
   mergeCoins(destination, sources) {
-    const destinationObject = convertObjArg(this.txBlock, destination);
+    const destinationObject = convertObjArg(this.tx, destination);
     const sourceObjects = sources.map(
-      (source) => convertObjArg(this.txBlock, source)
+      (source) => convertObjArg(this.tx, source)
     );
-    return this.txBlock.mergeCoins(destinationObject, sourceObjects);
+    return this.tx.mergeCoins(destinationObject, sourceObjects);
   }
   /**
    * @description Move call
@@ -400,8 +466,8 @@ var SuiTxBlock = class {
       throw new Error(
         "Invalid target format. Expected `${string}::${string}::${string}`"
       );
-    const convertedArgs = convertArgs(this.txBlock, args);
-    return this.txBlock.moveCall({
+    const convertedArgs = convertArgs(this.tx, args);
+    return this.tx.moveCall({
       target,
       arguments: convertedArgs,
       typeArguments: typeArgs
@@ -414,15 +480,15 @@ var SuiTxBlock = class {
         "transferSuiToMany: recipients.length !== amounts.length"
       );
     }
-    const coins = this.txBlock.splitCoins(
-      this.txBlock.gas,
-      convertArgs(this.txBlock, amounts)
+    const coins = this.tx.splitCoins(
+      this.tx.gas,
+      convertArgs(this.tx, amounts)
     );
     const recipientObjects = recipients.map(
-      (recipient) => convertAddressArg(this.txBlock, recipient)
+      (recipient) => convertAddressArg(this.tx, recipient)
     );
     recipientObjects.forEach((address, index) => {
-      this.txBlock.transferObjects([coins[index]], address);
+      this.tx.transferObjects([coins[index]], address);
     });
     return this;
   }
@@ -430,32 +496,29 @@ var SuiTxBlock = class {
     return this.transferSuiToMany([address], [amount]);
   }
   takeAmountFromCoins(coins, amount) {
-    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
+    const coinObjects = coins.map((coin) => convertObjArg(this.tx, coin));
     const mergedCoin = coinObjects[0];
     if (coins.length > 1) {
-      this.txBlock.mergeCoins(mergedCoin, coinObjects.slice(1));
+      this.tx.mergeCoins(mergedCoin, coinObjects.slice(1));
     }
-    const [sendCoin] = this.txBlock.splitCoins(
+    const [sendCoin] = this.tx.splitCoins(
       mergedCoin,
-      convertArgs(this.txBlock, [amount])
+      convertArgs(this.tx, [amount])
     );
     return [sendCoin, mergedCoin];
   }
   splitSUIFromGas(amounts) {
-    return this.txBlock.splitCoins(
-      this.txBlock.gas,
-      convertArgs(this.txBlock, amounts)
-    );
+    return this.tx.splitCoins(this.tx.gas, convertArgs(this.tx, amounts));
   }
   splitMultiCoins(coins, amounts) {
-    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
+    const coinObjects = coins.map((coin) => convertObjArg(this.tx, coin));
     const mergedCoin = coinObjects[0];
     if (coins.length > 1) {
-      this.txBlock.mergeCoins(mergedCoin, coinObjects.slice(1));
+      this.tx.mergeCoins(mergedCoin, coinObjects.slice(1));
     }
-    const splitedCoins = this.txBlock.splitCoins(
+    const splitedCoins = this.tx.splitCoins(
       mergedCoin,
-      convertArgs(this.txBlock, amounts)
+      convertArgs(this.tx, amounts)
     );
     return { splitedCoins, mergedCoin };
   }
@@ -465,45 +528,42 @@ var SuiTxBlock = class {
         "transferSuiToMany: recipients.length !== amounts.length"
       );
     }
-    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
+    const coinObjects = coins.map((coin) => convertObjArg(this.tx, coin));
     const { splitedCoins, mergedCoin } = this.splitMultiCoins(
       coinObjects,
       amounts
     );
     const recipientObjects = recipients.map(
-      (recipient) => convertAddressArg(this.txBlock, recipient)
+      (recipient) => convertAddressArg(this.tx, recipient)
     );
     recipientObjects.forEach((address, index) => {
-      this.txBlock.transferObjects([splitedCoins[index]], address);
+      this.tx.transferObjects([splitedCoins[index]], address);
     });
-    this.txBlock.transferObjects(
-      [mergedCoin],
-      convertAddressArg(this.txBlock, sender)
-    );
+    this.tx.transferObjects([mergedCoin], convertAddressArg(this.tx, sender));
     return this;
   }
   transferCoin(coins, sender, recipient, amount) {
     return this.transferCoinToMany(coins, sender, [recipient], [amount]);
   }
   stakeSui(amount, validatorAddr) {
-    const [stakeCoin] = this.txBlock.splitCoins(
-      this.txBlock.gas,
-      convertArgs(this.txBlock, [amount])
+    const [stakeCoin] = this.tx.splitCoins(
+      this.tx.gas,
+      convertArgs(this.tx, [amount])
     );
-    return this.txBlock.moveCall({
+    return this.tx.moveCall({
       target: "0x3::sui_system::request_add_stake",
-      arguments: convertArgs(this.txBlock, [
+      arguments: convertArgs(this.tx, [
         import_utils3.SUI_SYSTEM_STATE_OBJECT_ID,
         stakeCoin,
-        this.txBlock.pure(validatorAddr)
+        this.tx.pure.address(validatorAddr.toString())
       ])
     });
   }
 };
 
 // src/libs/suiInteractor/suiInteractor.ts
-var import_client = require("@mysten/sui.js/client");
-var import_faucet = require("@mysten/sui.js/faucet");
+var import_client = require("@mysten/sui/client");
+var import_faucet = require("@mysten/sui/faucet");
 
 // src/libs/suiModel/suiOwnedObject.ts
 var SuiOwnedObject = class {
@@ -525,8 +585,10 @@ var SuiOwnedObject = class {
       return this.objectId;
     }
     return {
+      $kind: "Object",
       Object: {
-        ImmOrOwned: {
+        $kind: "ImmOrOwnedObject",
+        ImmOrOwnedObject: {
           objectId: this.objectId,
           version: this.version,
           digest: this.digest
@@ -565,8 +627,10 @@ var SuiSharedObject = class {
       return this.objectId;
     }
     return {
+      $kind: "Object",
       Object: {
-        Shared: {
+        $kind: "SharedObject",
+        SharedObject: {
           objectId: this.objectId,
           initialSharedVersion: this.initialSharedVersion,
           mutable
@@ -926,7 +990,6 @@ function numberToAddressHex(num) {
 }
 
 // src/obelisk.ts
-var import_keccak256 = __toESM(require("keccak256"));
 var import_bcs3 = require("@mysten/bcs");
 function isUndefined(value) {
   return value === void 0;
@@ -952,7 +1015,7 @@ function createTx(meta, fn) {
     }
   );
 }
-var _query, _tx, _exec, _read;
+var _query, _tx, _struct, _exec, _read;
 var Obelisk = class {
   /**
    * Support the following ways to init the ObeliskClient:
@@ -961,7 +1024,7 @@ var Obelisk = class {
    * If none of them is provided, will generate a random mnemonics with 24 words.
    *
    * @param mnemonics, 12 or 24 mnemonics words, separated by space
-   * @param secretKey, base64 or hex string, when mnemonics is provided, secretKey will be ignored
+   * @param secretKey, base64 or hex string or bech32, when mnemonics is provided, secretKey will be ignored
    * @param networkType, 'testnet' | 'mainnet' | 'devnet' | 'localnet', default is 'devnet'
    * @param fullnodeUrl, the fullnode url, default is the preconfig fullnode url for the given network type
    * @param packageId
@@ -976,6 +1039,7 @@ var Obelisk = class {
   } = {}) {
     __privateAdd(this, _query, {});
     __privateAdd(this, _tx, {});
+    __privateAdd(this, _struct, {});
     __privateAdd(this, _exec, async (meta, tx, params, typeArguments, isRaw) => {
       if (isRaw === true) {
         return tx.moveCall({
@@ -1012,33 +1076,37 @@ var Obelisk = class {
     this.packageId = packageId;
     if (metadata !== void 0) {
       this.metadata = metadata;
-      Object.values(metadata).forEach((value) => {
-        const data = value;
-        const moduleName = data.name;
-        Object.entries(data.exposedFunctions).forEach(([funcName, value2]) => {
-          const meta = value2;
-          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)
-            );
-          }
-        });
-      });
+      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)
+                );
+              }
+              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)
+                );
+              }
+            }
+          );
+        }
+      );
     }
     this.contractFactory = new SuiContractFactory({
       packageId,
@@ -1051,6 +1119,9 @@ var Obelisk = class {
   get tx() {
     return __privateGet(this, _tx);
   }
+  get struct() {
+    return __privateGet(this, _struct);
+  }
   /**
    * if derivePathParams is not provided or mnemonics is empty, it will return the keypair.
    * else:
@@ -1083,11 +1154,20 @@ var Obelisk = class {
   getMetadata() {
     return this.contractFactory.metadata;
   }
+  getNetwork() {
+    return this.suiInteractor.network;
+  }
   /**
    * Request some SUI from faucet
    * @Returns {Promise<boolean>}, true if the request is successful, false otherwise.
    */
-  async requestFaucet(address, network) {
+  async requestFaucet(address, network, derivePathParams) {
+    if (address === void 0) {
+      address = this.accountManager.getAddress(derivePathParams);
+    }
+    if (network === void 0) {
+      network = this.getNetwork();
+    }
     return this.suiInteractor.requestFaucet(address, network);
   }
   async getBalance(coinType, derivePathParams) {
@@ -1111,18 +1191,21 @@ var Obelisk = class {
     return this.suiInteractor.getObjects(objectIds);
   }
   async signTxn(tx, derivePathParams) {
-    if (tx instanceof SuiTxBlock || tx instanceof import_transactions3.TransactionBlock) {
+    if (tx instanceof SuiTx || tx instanceof import_transactions3.Transaction) {
       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 txBlock = tx instanceof SuiTx ? tx.tx : tx;
+    const txBytes = txBlock instanceof import_transactions3.Transaction ? await txBlock.build({ client: this.client() }) : txBlock;
     const keyPair = this.getKeypair(derivePathParams);
-    return await keyPair.signTransactionBlock(txBytes);
+    return await keyPair.signTransaction(txBytes);
   }
   async signAndSendTxn(tx, derivePathParams) {
     const { bytes, signature } = await this.signTxn(tx, derivePathParams);
     return this.suiInteractor.sendTx(bytes, signature);
   }
+  async sendTxn(transactionBlock, signature) {
+    return this.suiInteractor.sendTx(transactionBlock, signature);
+  }
   /**
    * Transfer the given amount of SUI to the recipient
    * @param recipient
@@ -1130,7 +1213,7 @@ var Obelisk = class {
    * @param derivePathParams
    */
   async transferSui(recipient, amount, derivePathParams) {
-    const tx = new SuiTxBlock();
+    const tx = new SuiTx();
     tx.transferSui(recipient, amount);
     return this.signAndSendTxn(tx, derivePathParams);
   }
@@ -1141,7 +1224,7 @@ var Obelisk = class {
    * @param derivePathParams
    */
   async transferSuiToMany(recipients, amounts, derivePathParams) {
-    const tx = new SuiTxBlock();
+    const tx = new SuiTx();
     tx.transferSuiToMany(recipients, amounts);
     return this.signAndSendTxn(tx, derivePathParams);
   }
@@ -1153,7 +1236,7 @@ var Obelisk = class {
    * @param derivePathParams the derive path params for the current signer
    */
   async transferCoinToMany(recipients, amounts, coinType, derivePathParams) {
-    const tx = new SuiTxBlock();
+    const tx = new SuiTx();
     const owner = this.accountManager.getAddress(derivePathParams);
     const totalAmount = amounts.reduce((a, b) => a + b, 0);
     const coins = await this.suiInteractor.selectCoins(
@@ -1178,7 +1261,7 @@ var Obelisk = class {
     );
   }
   async transferObjects(objects, recipient, derivePathParams) {
-    const tx = new SuiTxBlock();
+    const tx = new SuiTx();
     tx.transferObjects(objects, recipient);
     return this.signAndSendTxn(tx, derivePathParams);
   }
@@ -1189,7 +1272,7 @@ var Obelisk = class {
       typeArguments = [],
       derivePathParams
     } = callParams;
-    const tx = new SuiTxBlock();
+    const tx = new SuiTx();
     tx.moveCall(target, args, typeArguments);
     return this.signAndSendTxn(tx, derivePathParams);
   }
@@ -1216,7 +1299,7 @@ var Obelisk = class {
    * @param derivePathParams the derive path params for the current signer
    */
   async stakeSui(amount, validatorAddr, derivePathParams) {
-    const tx = new SuiTxBlock();
+    const tx = new SuiTx();
     tx.stakeSui(amount, validatorAddr);
     return this.signAndSendTxn(tx, derivePathParams);
   }
@@ -1228,7 +1311,7 @@ var Obelisk = class {
    * @returns the effects and events of the transaction, such as object changes, gas cost, event emitted.
    */
   async inspectTxn(tx, derivePathParams) {
-    const txBlock = tx instanceof SuiTxBlock ? tx.txBlock : tx;
+    const txBlock = tx instanceof SuiTx ? tx.tx : tx;
     return this.suiInteractor.currentClient.devInspectTransactionBlock({
       transactionBlock: txBlock,
       sender: this.getAddress(derivePathParams)
@@ -1250,36 +1333,62 @@ var Obelisk = class {
   }
   async getEntity(worldId, schemaName, entityId) {
     const schemaModuleName = `${schemaName}_schema`;
-    const tx = new import_transactions3.TransactionBlock();
-    const params = [tx.pure(worldId)];
+    const tx = new import_transactions3.Transaction();
+    const params = [tx.pure.address(worldId)];
     if (entityId !== void 0) {
-      params.push(tx.pure(entityId));
+      params.push(tx.pure.address(entityId));
     }
     const getResult = await this.query[schemaModuleName].get(
       tx,
       params
     );
-    let returnValue = [];
+    let returnValues = [];
     if (getResult.effects.status.status === "success") {
       const resultList = getResult.results[0].returnValues;
       for (const res of resultList) {
-        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);
-        returnValue.push(data);
+        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 returnValue;
+      return returnValues;
     } else {
       return void 0;
     }
   }
   async containEntity(worldId, schemaName, entityId) {
     const schemaModuleName = `${schemaName}_schema`;
-    const tx = new import_transactions3.TransactionBlock();
-    const params = [tx.pure(worldId)];
+    const tx = new import_transactions3.Transaction();
+    const params = [tx.pure.address(worldId)];
     if (entityId !== void 0) {
-      params.push(tx.pure(entityId));
+      params.push(tx.pure.address(entityId));
     }
     const getResult = await this.query[schemaModuleName].contains(
       tx,
@@ -1287,9 +1396,9 @@ var Obelisk = class {
     );
     if (getResult.effects.status.status === "success") {
       const res = getResult.results[0].returnValues[0];
-      const bcs = new import_bcs3.BCS((0, import_bcs3.getSuiMoveConfig)());
-      const value = Uint8Array.from(res[0]);
-      return bcs.de(res[1], value);
+      let baseValue = res[0];
+      const value = Uint8Array.from(baseValue);
+      return import_bcs3.bcs.bool().parse(value);
     } else {
       return void 0;
     }
@@ -1351,9 +1460,13 @@ 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_bcs3.BCS((0, import_bcs3.getSuiMoveConfig)());
     const value = Uint8Array.from(hashU8Array);
-    const data = bcs.de("address", value);
+    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)
+    });
+    const data = Address.parse(value);
     return "0x" + data;
   }
   async entity_key_from_address_with_seed(objectId, seed) {
@@ -1371,9 +1484,8 @@ var Obelisk = class {
     const checkObjectId = normalizeHexAddress(objectId);
     if (checkObjectId !== null) {
       objectId = checkObjectId;
-      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();
+      const numberBytes = import_bcs3.bcs.u256().serialize(x).toBytes();
       return this.entity_key_from_bytes(Buffer.concat([bytes, numberBytes]));
     } else {
       return void 0;
@@ -1382,23 +1494,65 @@ var Obelisk = class {
   async entity_key_from_u256(x) {
     return numberToAddressHex(x);
   }
-  async formatData(type, value) {
-    const bcs = new import_bcs3.BCS((0, import_bcs3.getSuiMoveConfig)());
-    const u8Value = Uint8Array.from(value);
-    return bcs.de(type, u8Value);
+  // async formatData(type: string, value: Buffer | number[] | Uint8Array) {
+  //   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();
 _exec = new WeakMap();
 _read = new WeakMap();
 
 // src/libs/multiSig/client.ts
-var import_multisig = require("@mysten/sui.js/multisig");
+var import_multisig = require("@mysten/sui/multisig");
 
 // src/libs/multiSig/publickey.ts
-var import_ed255193 = require("@mysten/sui.js/keypairs/ed25519");
-var import_utils5 = require("@mysten/sui.js/utils");
+var import_ed255193 = require("@mysten/sui/keypairs/ed25519");
+var import_utils5 = require("@mysten/sui/utils");
 function ed25519PublicKeyFromBase64(rawPubkey) {
   let bytes = (0, import_utils5.fromB64)(rawPubkey);
   if (bytes.length !== 32 && bytes.length !== 33)
@@ -1435,7 +1589,7 @@ var MultiSigClient = class _MultiSigClient {
 };
 
 // src/metadata/index.ts
-var import_client4 = require("@mysten/sui.js/client");
+var import_client4 = require("@mysten/sui/client");
 async function loadMetadata(networkType, packageId) {
   const fullnodeUrls = [(0, import_client4.getFullnodeUrl)(networkType)];
   const suiInteractor = new SuiInteractor(fullnodeUrls);
@@ -1450,19 +1604,20 @@ async function loadMetadata(networkType, packageId) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BCS,
+  BcsType,
   MultiSigClient,
   Obelisk,
   SuiAccountManager,
   SuiContractFactory,
-  SuiTxBlock,
-  getSuiMoveConfig,
+  SuiTx,
+  bcs,
   loadMetadata,
-  ...require("@mysten/sui.js/client"),
-  ...require("@mysten/sui.js/utils"),
-  ...require("@mysten/sui.js/transactions"),
-  ...require("@mysten/sui.js/keypairs/ed25519"),
-  ...require("@mysten/sui.js/keypairs/secp256k1"),
-  ...require("@mysten/sui.js/keypairs/secp256r1")
+  ...require("@mysten/sui/client"),
+  ...require("@mysten/sui/utils"),
+  ...require("@mysten/sui/transactions"),
+  ...require("@mysten/sui/bcs"),
+  ...require("@mysten/sui/keypairs/ed25519"),
+  ...require("@mysten/sui/keypairs/secp256k1"),
+  ...require("@mysten/sui/keypairs/secp256r1")
 });
 //# sourceMappingURL=index.js.map