@0xobelisk/client 0.3.3 → 0.3.4

package/dist/index.js

@@ -0,0 +1,1281 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Ed25519Keypair: () => import_ed25519.Ed25519Keypair,
+  Obelisk: () => Obelisk,
+  SuiAccountManager: () => SuiAccountManager,
+  SuiContractFactory: () => SuiContractFactory,
+  SuiTxBlock: () => SuiTxBlock,
+  getMetadata: () => getMetadata
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("@mysten/sui.js"), module.exports);
+var import_ed25519 = require("@mysten/sui.js/keypairs/ed25519");
+__reExport(src_exports, require("@mysten/bcs"), module.exports);
+
+// src/obelisk.ts
+var import_sui9 = require("@mysten/sui.js");
+
+// src/libs/suiAccountManager/index.ts
+var import_sui3 = require("@mysten/sui.js");
+
+// src/libs/suiAccountManager/keypair.ts
+var import_sui = require("@mysten/sui.js");
+var getDerivePathForSUI = (derivePathParams = {}) => {
+  const {
+    accountIndex = 0,
+    isExternal = false,
+    addressIndex = 0
+  } = derivePathParams;
+  return `m/44'/784'/${accountIndex}'/${isExternal ? 1 : 0}'/${addressIndex}'`;
+};
+var getKeyPair = (mnemonics, derivePathParams = {}) => {
+  const derivePath = getDerivePathForSUI(derivePathParams);
+  return import_sui.Ed25519Keypair.deriveKeypair(mnemonics, derivePath);
+};
+
+// src/libs/suiAccountManager/util.ts
+var import_sui2 = require("@mysten/sui.js");
+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) => {
+  if (!hexStr) {
+    throw new Error("cannot parse empty string to Uint8Array");
+  }
+  const intArr = hexStr.replace("0x", "").match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16));
+  if (!intArr || intArr.length === 0) {
+    throw new Error(`Unable to parse HEX: ${hexStr}`);
+  }
+  return Uint8Array.from(intArr);
+};
+var hexOrBase64ToUint8Array = (str) => {
+  if (isHex(str)) {
+    return fromHEX(str);
+  } else if (isBase64(str)) {
+    return (0, import_sui2.fromB64)(str);
+  } else {
+    throw new Error("The string is not a valid hex or base64 string.");
+  }
+};
+var PRIVATE_KEY_SIZE = 32;
+var LEGACY_PRIVATE_KEY_SIZE = 64;
+var normalizePrivateKey = (key) => {
+  if (key.length === LEGACY_PRIVATE_KEY_SIZE) {
+    key = key.slice(0, PRIVATE_KEY_SIZE);
+  } else if (key.length === PRIVATE_KEY_SIZE + 1 && key[0] === 0) {
+    return key.slice(1);
+  } else if (key.length === PRIVATE_KEY_SIZE) {
+    return key;
+  }
+  throw new Error("invalid secret key");
+};
+
+// src/libs/suiAccountManager/crypto.ts
+var import_bip39 = require("@scure/bip39");
+var import_english = require("@scure/bip39/wordlists/english");
+var generateMnemonic = (numberOfWords = 24) => {
+  const strength = numberOfWords === 12 ? 128 : 256;
+  return (0, import_bip39.generateMnemonic)(import_english.wordlist, strength);
+};
+
+// src/libs/suiAccountManager/index.ts
+var SuiAccountManager = class {
+  /**
+   * Support the following ways to init the SuiToolkit:
+   * 1. mnemonics
+   * 2. secretKey (base64 or hex)
+   * 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
+   */
+  constructor({ mnemonics, secretKey } = {}) {
+    this.mnemonics = mnemonics || "";
+    this.secretKey = secretKey || "";
+    if (!this.mnemonics && !this.secretKey) {
+      this.mnemonics = generateMnemonic(24);
+    }
+    this.currentKeyPair = this.secretKey ? import_sui3.Ed25519Keypair.fromSecretKey(
+      normalizePrivateKey(hexOrBase64ToUint8Array(this.secretKey))
+    ) : getKeyPair(this.mnemonics);
+    this.currentAddress = this.currentKeyPair.getPublicKey().toSuiAddress();
+  }
+  /**
+   * if derivePathParams is not provided or mnemonics is empty, it will return the currentKeyPair.
+   * else:
+   * it will generate keyPair from the mnemonic with the given derivePathParams.
+   */
+  getKeyPair(derivePathParams) {
+    if (!derivePathParams || !this.mnemonics)
+      return this.currentKeyPair;
+    return getKeyPair(this.mnemonics, derivePathParams);
+  }
+  /**
+   * if derivePathParams is not provided or mnemonics is empty, it will return the currentAddress.
+   * else:
+   * it will generate address from the mnemonic with the given derivePathParams.
+   */
+  getAddress(derivePathParams) {
+    if (!derivePathParams || !this.mnemonics)
+      return this.currentAddress;
+    return getKeyPair(this.mnemonics, derivePathParams).getPublicKey().toSuiAddress();
+  }
+  /**
+   * Switch the current account with the given derivePathParams.
+   * This is only useful when the mnemonics is provided. For secretKey mode, it will always use the same account.
+   */
+  switchAccount(derivePathParams) {
+    if (this.mnemonics) {
+      this.currentKeyPair = getKeyPair(this.mnemonics, derivePathParams);
+      this.currentAddress = this.currentKeyPair.getPublicKey().toSuiAddress();
+    }
+  }
+};
+
+// src/libs/suiTxBuilder/index.ts
+var import_sui5 = require("@mysten/sui.js");
+
+// src/libs/suiTxBuilder/util.ts
+var import_sui4 = require("@mysten/sui.js");
+var getDefaultSuiInputType = (value) => {
+  if (typeof value === "string" && value.startsWith("0x")) {
+    return "object";
+  } else if (typeof value === "number" || typeof value === "bigint") {
+    return "u64";
+  } else if (typeof value === "boolean") {
+    return "bool";
+  } else {
+    return "object";
+  }
+};
+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 objects = args.map(
+      (arg) => typeof arg === "string" ? txBlock.object((0, import_sui4.normalizeSuiObjectId)(arg)) : arg
+    );
+    return txBlock.makeMoveVec({ objects });
+  } else {
+    const vecType = type || defaultSuiType;
+    return txBlock.pure(args, `vector<${vecType}>`);
+  }
+}
+function isMoveVecArg(arg) {
+  const isFullMoveVecArg = arg && arg.value && Array.isArray(arg.value) && arg.vecType;
+  const isSimpleMoveVecArg = Array.isArray(arg);
+  return isFullMoveVecArg || isSimpleMoveVecArg;
+}
+function convertArgs(txBlock, args) {
+  return args.map((arg) => {
+    if (typeof arg === "string" && arg.startsWith("0x")) {
+      return txBlock.object((0, import_sui4.normalizeSuiObjectId)(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 {
+      return arg;
+    }
+  });
+}
+
+// src/libs/suiTxBuilder/index.ts
+var SuiTxBlock = class {
+  constructor(transaction) {
+    this.txBlock = new import_sui5.TransactionBlock(transaction);
+  }
+  //======== override methods of TransactionBlock ============
+  address(value) {
+    return this.txBlock.pure(value, "address");
+  }
+  pure(value, type) {
+    return this.txBlock.pure(value, type);
+  }
+  object(value) {
+    return this.txBlock.object(value);
+  }
+  objectRef(ref) {
+    return this.txBlock.objectRef(ref);
+  }
+  sharedObjectRef(ref) {
+    return this.txBlock.sharedObjectRef(ref);
+  }
+  setSender(sender) {
+    return this.txBlock.setSender(sender);
+  }
+  setSenderIfNotSet(sender) {
+    return this.txBlock.setSenderIfNotSet(sender);
+  }
+  setExpiration(expiration) {
+    return this.txBlock.setExpiration(expiration);
+  }
+  setGasPrice(price) {
+    return this.txBlock.setGasPrice(price);
+  }
+  setGasBudget(budget) {
+    return this.txBlock.setGasBudget(budget);
+  }
+  setGasOwner(owner) {
+    return this.txBlock.setGasOwner(owner);
+  }
+  setGasPayment(payments) {
+    return this.txBlock.setGasPayment(payments);
+  }
+  add(transaction) {
+    return this.txBlock.add(transaction);
+  }
+  serialize() {
+    return this.txBlock.serialize();
+  }
+  build(params = {}) {
+    return this.txBlock.build(params);
+  }
+  getDigest({ provider } = {}) {
+    return this.txBlock.getDigest({ provider });
+  }
+  get gas() {
+    return this.txBlock.gas;
+  }
+  get blockData() {
+    return this.txBlock.blockData;
+  }
+  transferObjects(objects, recipient) {
+    const tx = this.txBlock;
+    tx.transferObjects(convertArgs(this.txBlock, objects), tx.pure(recipient));
+    return this;
+  }
+  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))
+    );
+    return amounts.map((_, i) => res[i]);
+  }
+  mergeCoins(destination, sources) {
+    const destinationObject = convertArgs(this.txBlock, [destination])[0];
+    const sourceObjects = convertArgs(this.txBlock, sources);
+    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 typeArgs the type arguments of the move call, such as `['0x2::sui::SUI']`
+   */
+  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)
+      throw new Error(
+        "Invalid target format. Expected `${string}::${string}::${string}`"
+      );
+    const convertedArgs = convertArgs(this.txBlock, args);
+    const tx = this.txBlock;
+    return tx.moveCall({
+      target,
+      arguments: convertedArgs,
+      typeArguments: typeArgs
+    });
+  }
+  //======== enhance methods ============
+  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))
+    );
+    recipients.forEach((recipient, index) => {
+      tx.transferObjects([coins[index]], tx.pure(recipient));
+    });
+    return this;
+  }
+  transferSui(recipient, amount) {
+    return this.transferSuiToMany([recipient], [amount]);
+  }
+  takeAmountFromCoins(coins, amount) {
+    const tx = this.txBlock;
+    const coinObjects = convertArgs(this.txBlock, coins);
+    const mergedCoin = coinObjects[0];
+    if (coins.length > 1) {
+      tx.mergeCoins(mergedCoin, coinObjects.slice(1));
+    }
+    const [sendCoin] = tx.splitCoins(mergedCoin, [tx.pure(amount)]);
+    return [sendCoin, mergedCoin];
+  }
+  splitSUIFromGas(amounts) {
+    const tx = this.txBlock;
+    return tx.splitCoins(
+      tx.gas,
+      amounts.map((m) => tx.pure(m))
+    );
+  }
+  splitMultiCoins(coins, amounts) {
+    const tx = this.txBlock;
+    const coinObjects = convertArgs(this.txBlock, coins);
+    const mergedCoin = coinObjects[0];
+    if (coins.length > 1) {
+      tx.mergeCoins(mergedCoin, coinObjects.slice(1));
+    }
+    const splitedCoins = tx.splitCoins(
+      mergedCoin,
+      amounts.map((m) => tx.pure(m))
+    );
+    return { splitedCoins, mergedCoin };
+  }
+  transferCoinToMany(inputCoins, sender, recipients, amounts) {
+    if (recipients.length !== amounts.length) {
+      throw new Error(
+        "transferSuiToMany: recipients.length !== amounts.length"
+      );
+    }
+    const tx = this.txBlock;
+    const { splitedCoins, mergedCoin } = this.splitMultiCoins(
+      inputCoins,
+      amounts
+    );
+    recipients.forEach((recipient, index) => {
+      tx.transferObjects([splitedCoins[index]], tx.pure(recipient));
+    });
+    tx.transferObjects([mergedCoin], tx.pure(sender));
+    return this;
+  }
+  transferCoin(inputCoins, sender, recipient, amount) {
+    return this.transferCoinToMany(inputCoins, sender, [recipient], [amount]);
+  }
+  stakeSui(amount, validatorAddr) {
+    const tx = this.txBlock;
+    const [stakeCoin] = tx.splitCoins(tx.gas, [tx.pure(amount)]);
+    tx.moveCall({
+      target: "0x3::sui_system::request_add_stake",
+      arguments: [
+        tx.object(import_sui5.SUI_SYSTEM_STATE_OBJECT_ID),
+        stakeCoin,
+        tx.pure(validatorAddr)
+      ]
+    });
+    return tx;
+  }
+};
+
+// src/libs/suiInteractor/suiInteractor.ts
+var import_sui7 = require("@mysten/sui.js");
+var import_faucet = require("@mysten/sui.js/faucet");
+
+// src/libs/suiModel/suiOwnedObject.ts
+var import_sui6 = require("@mysten/sui.js");
+var SuiOwnedObject = class {
+  constructor(param) {
+    this.objectId = param.objectId;
+    this.version = param.version;
+    this.digest = param.digest;
+  }
+  /**
+   * Check if the object is fully initialized.
+   * So that when it's used as an input, it won't be necessary to fetch from fullnode again.
+   * Which can save time when sending transactions.
+   */
+  isFullObject() {
+    return !!this.version && !!this.digest;
+  }
+  asCallArg() {
+    if (!this.version || !this.digest) {
+      return this.objectId;
+    }
+    return {
+      Object: {
+        ImmOrOwned: {
+          objectId: this.objectId,
+          version: this.version,
+          digest: this.digest
+        }
+      }
+    };
+  }
+  /**
+   * Update object version & digest based on the transaction response.
+   * @param txResponse
+   */
+  updateFromTxResponse(txResponse) {
+    const changes = (0, import_sui6.getObjectChanges)(txResponse);
+    if (!changes) {
+      throw new Error("Bad transaction response!");
+    }
+    for (const change of changes) {
+      if (change.type === "mutated" && change.objectId === this.objectId) {
+        this.digest = change.digest;
+        this.version = change.version;
+        return;
+      }
+    }
+    throw new Error("Could not find object in transaction response!");
+  }
+};
+
+// src/libs/suiModel/suiSharedObject.ts
+var SuiSharedObject = class {
+  constructor(param) {
+    this.objectId = param.objectId;
+    this.initialSharedVersion = param.initialSharedVersion;
+  }
+  asCallArg(mutable = false) {
+    if (!this.initialSharedVersion) {
+      return this.objectId;
+    }
+    return {
+      Object: {
+        Shared: {
+          objectId: this.objectId,
+          initialSharedVersion: this.initialSharedVersion,
+          mutable
+        }
+      }
+    };
+  }
+};
+
+// src/libs/suiInteractor/util.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/libs/suiInteractor/suiInteractor.ts
+var SuiInteractor = class {
+  constructor(fullNodeUrls, network) {
+    if (fullNodeUrls.length === 0)
+      throw new Error("fullNodeUrls must not be empty");
+    this.providers = fullNodeUrls.map(
+      (url) => new import_sui7.JsonRpcProvider(new import_sui7.Connection({ fullnode: url }))
+    );
+    this.currentProvider = this.providers[0];
+    this.network = network;
+  }
+  switchToNextProvider() {
+    const currentProviderIdx = this.providers.indexOf(this.currentProvider);
+    this.currentProvider = this.providers[(currentProviderIdx + 1) % this.providers.length];
+  }
+  async sendTx(transactionBlock, signature) {
+    const txResOptions = {
+      showEvents: true,
+      showEffects: true,
+      showObjectChanges: true,
+      showBalanceChanges: true
+    };
+    for (const provider of this.providers) {
+      try {
+        const res = await provider.executeTransactionBlock({
+          transactionBlock,
+          signature,
+          options: txResOptions
+        });
+        return res;
+      } catch (err) {
+        console.warn(
+          `Failed to send transaction with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+        await delay(2e3);
+      }
+    }
+    throw new Error("Failed to send transaction with all fullnodes");
+  }
+  async getObjects(ids) {
+    const options = {
+      showContent: true,
+      showDisplay: true,
+      showType: true,
+      showOwner: true
+    };
+    for (const provider of this.providers) {
+      try {
+        const objects = await provider.multiGetObjects({ ids, options });
+        const parsedObjects = objects.map((object) => {
+          const objectId = (0, import_sui7.getObjectId)(object);
+          const objectType = (0, import_sui7.getObjectType)(object);
+          const objectVersion = (0, import_sui7.getObjectVersion)(object);
+          const objectDigest = object.data ? object.data.digest : void 0;
+          const initialSharedVersion = (0, import_sui7.getSharedObjectInitialVersion)(object);
+          const objectFields = (0, import_sui7.getObjectFields)(object);
+          const objectDisplay = (0, import_sui7.getObjectDisplay)(object);
+          return {
+            objectId,
+            objectType,
+            objectVersion,
+            objectDigest,
+            objectFields,
+            objectDisplay,
+            initialSharedVersion
+          };
+        });
+        return parsedObjects;
+      } catch (err) {
+        await delay(2e3);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error("Failed to get objects with all fullnodes");
+  }
+  async getObject(id) {
+    const objects = await this.getObjects([id]);
+    return objects[0];
+  }
+  async getEntitiesObjects(ids) {
+    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 = (0, import_sui7.getObjectId)(object);
+          const objectFields = (0, import_sui7.getObjectFields)(object);
+          const index = objectFields.name;
+          const key = objectFields.value;
+          return {
+            objectId,
+            index,
+            key
+          };
+        });
+        return parsedObjects;
+      } catch (err) {
+        await delay(2e3);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error("Failed to get objects with all fullnodes");
+  }
+  async getDynamicFieldObject(parentId, name) {
+    for (const provider of this.providers) {
+      try {
+        return provider.getDynamicFieldObject({ parentId, name });
+      } catch (err) {
+        await delay(2e3);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error("Failed to get objects with all fullnodes");
+  }
+  async getDynamicFields(parentId, cursor, limit) {
+    for (const provider of this.providers) {
+      try {
+        return provider.getDynamicFields({ parentId, cursor, limit });
+      } catch (err) {
+        await delay(2e3);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error("Failed to get objects with all fullnodes");
+  }
+  async getOwnedObjects(owner, cursor, limit) {
+    for (const provider of this.providers) {
+      try {
+        return await provider.getOwnedObjects({ owner, cursor, limit });
+      } catch (err) {
+        await delay(2e3);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error("Failed to get objects with all fullnodes");
+  }
+  async getNormalizedMoveModulesByPackage(packageId) {
+    for (const provider of this.providers) {
+      try {
+        return provider.getNormalizedMoveModulesByPackage({
+          package: packageId
+        });
+      } catch (err) {
+        await delay(2e3);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error("Failed to get objects with all fullnodes");
+  }
+  /**
+   * @description Update objects in a batch
+   * @param suiObjects
+   */
+  async updateObjects(suiObjects) {
+    const objectIds = suiObjects.map((obj) => obj.objectId);
+    const objects = await this.getObjects(objectIds);
+    for (const object of objects) {
+      const suiObject = suiObjects.find(
+        (obj) => obj.objectId === object.objectId
+      );
+      if (suiObject instanceof SuiSharedObject) {
+        suiObject.initialSharedVersion = object.initialSharedVersion;
+      } else if (suiObject instanceof SuiOwnedObject) {
+        suiObject.version = object.objectVersion;
+        suiObject.digest = object.objectDigest;
+      }
+    }
+  }
+  /**
+   * @description Select coins that add up to the given amount.
+   * @param addr the address of the owner
+   * @param amount the amount that is needed for the coin
+   * @param coinType the coin type, default is '0x2::SUI::SUI'
+   */
+  async selectCoins(addr, amount, coinType = "0x2::SUI::SUI") {
+    const selectedCoins = [];
+    let totalAmount = 0;
+    let hasNext = true, nextCursor = null;
+    while (hasNext && totalAmount < amount) {
+      const coins = await this.currentProvider.getCoins({
+        owner: addr,
+        coinType,
+        cursor: nextCursor
+      });
+      coins.data.sort((a, b) => parseInt(b.balance) - parseInt(a.balance));
+      for (const coinData of coins.data) {
+        selectedCoins.push({
+          objectId: coinData.coinObjectId,
+          digest: coinData.digest,
+          version: coinData.version
+        });
+        totalAmount = totalAmount + parseInt(coinData.balance);
+        if (totalAmount >= amount) {
+          break;
+        }
+      }
+      nextCursor = coins.nextCursor;
+      hasNext = coins.hasNextPage;
+    }
+    if (!selectedCoins.length) {
+      throw new Error("No valid coins found for the transaction.");
+    }
+    return selectedCoins;
+  }
+  async requestFaucet(address, network) {
+    await (0, import_faucet.requestSuiFromFaucetV0)({
+      host: (0, import_faucet.getFaucetHost)(network),
+      recipient: address
+    });
+  }
+};
+
+// src/libs/suiInteractor/defaultConfig.ts
+var import_sui8 = require("@mysten/sui.js");
+var defaultGasBudget = 10 ** 8;
+var getDefaultConnection = (networkType = "devnet") => {
+  switch (networkType) {
+    case "localnet":
+      return import_sui8.localnetConnection;
+    case "devnet":
+      return import_sui8.devnetConnection;
+    case "testnet":
+      return import_sui8.testnetConnection;
+    case "mainnet":
+      return import_sui8.mainnetConnection;
+    default:
+      return import_sui8.devnetConnection;
+  }
+};
+
+// src/libs/suiContractFactory/index.ts
+var SuiContractFactory = class {
+  // readonly #query: MapMessageQuery<ApiTypes> = {};
+  // readonly #tx: MapMessageTx<ApiTypes> = {};
+  /**
+   * Support the following ways to init the SuiToolkit:
+   * 1. mnemonics
+   * 2. secretKey (base64 or hex)
+   * 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
+   */
+  constructor({ packageId, metadata } = {}) {
+    this.packageId = packageId || "";
+    this.metadata = metadata || void 0;
+  }
+  getFuncByModuleName(moduleName) {
+    Object.values(this.metadata).forEach(
+      (value) => {
+        const data = value;
+        console.log(`moudle name: ${data.name}`);
+        Object.entries(data.exposedFunctions).forEach(([key, value2]) => {
+          console.log(`	func name: ${key}`);
+          Object.values(value2.parameters).forEach((values) => {
+          });
+        });
+      }
+    );
+  }
+  getAllFunc() {
+    Object.values(this.metadata).forEach(
+      (value) => {
+        const data = value;
+        console.log(`moudle name: ${data.name}`);
+        Object.entries(data.exposedFunctions).forEach(([key, value2]) => {
+          console.log(`	func name: ${key}`);
+          console.log(`		${value2.parameters.length}`);
+          Object.values(value2.parameters).forEach((values) => {
+            console.log(`		args: ${values}`);
+          });
+        });
+      }
+    );
+  }
+  getAllModule() {
+    Object.values(this.metadata).forEach(
+      (value, index) => {
+        const data = value;
+        console.log(`${index}. ${data.name}`);
+      }
+    );
+  }
+  //   async call(arguments: ({
+  //     kind: "Input";
+  //     index: number;
+  //     type?: "object" | "pure" | undefined;
+  //     value?: any;
+  // } | {
+  //     kind: "GasCoin";
+  // } | {
+  //     kind: "Result";
+  //     index: number;
+  // } | {
+  //     kind: "NestedResult";
+  //     index: number;
+  //     resultIndex: number;
+  // })[], derivePathParams?: DerivePathParams) {
+  //     const tx = new TransactionBlock();
+  //     tx.moveCall({
+  //       target: `${this.packageId}::${}::${}`,
+  //       arguments,
+  //     })
+  //     return ;
+  //   }
+};
+
+// src/utils/index.ts
+function normalizeHexAddress(input) {
+  const hexRegex = /^(0x)?[0-9a-fA-F]{64}$/;
+  if (hexRegex.test(input)) {
+    if (input.startsWith("0x")) {
+      return input;
+    } else {
+      return "0x" + input;
+    }
+  } else {
+    return null;
+  }
+}
+function numberToAddressHex(num) {
+  const hex = num.toString(16);
+  const paddedHex = "0x" + hex.padStart(64, "0");
+  return paddedHex;
+}
+
+// src/obelisk.ts
+var import_keccak256 = __toESM(require("keccak256"));
+var import_bcs = require("@mysten/bcs");
+function isUndefined(value) {
+  return value === void 0;
+}
+function withMeta(meta, creator) {
+  creator.meta = meta;
+  return creator;
+}
+function createQuery(meta, fn) {
+  return withMeta(
+    meta,
+    async (tx, params, isRaw) => {
+      const result = await fn(tx, params, isRaw);
+      return result;
+    }
+  );
+}
+function createTx(meta, fn) {
+  return withMeta(
+    meta,
+    async (tx, params, isRaw) => {
+      const result = await fn(tx, params, isRaw);
+      return result;
+    }
+  );
+}
+var _query, _tx, _exec, _read;
+var Obelisk = class {
+  /**
+   * Support the following ways to init the ObeliskClient:
+   * 1. mnemonics
+   * 2. secretKey (base64 or hex)
+   * 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 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
+   */
+  constructor({
+    mnemonics,
+    secretKey,
+    networkType,
+    fullnodeUrls,
+    packageId,
+    metadata
+  } = {}) {
+    __privateAdd(this, _query, {});
+    __privateAdd(this, _tx, {});
+    __privateAdd(this, _exec, async (meta, tx, params, isRaw) => {
+      tx.moveCall({
+        target: `${this.contractFactory.packageId}::${meta.moudleName}::${meta.funcName}`,
+        arguments: params
+      });
+      if (isRaw === true) {
+        return tx;
+      }
+      return await this.signAndSendTxn(tx);
+    });
+    __privateAdd(this, _read, async (meta, tx, params, isRaw) => {
+      tx.moveCall({
+        target: `${this.contractFactory.packageId}::${meta.moudleName}::${meta.funcName}`,
+        arguments: params
+      });
+      if (isRaw === true) {
+        return tx;
+      }
+      return await this.inspectTxn(tx);
+    });
+    this.accountManager = new SuiAccountManager({ mnemonics, secretKey });
+    fullnodeUrls = fullnodeUrls || [getDefaultConnection(networkType).fullnode];
+    this.suiInteractor = new SuiInteractor(fullnodeUrls, networkType);
+    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.moudleName = 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, isRaw) => __privateGet(this, _read).call(this, meta, tx, p, 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, isRaw) => __privateGet(this, _exec).call(this, meta, tx, p, isRaw)
+            );
+          }
+        });
+      });
+    }
+    this.contractFactory = new SuiContractFactory({
+      packageId,
+      metadata
+    });
+  }
+  get query() {
+    return __privateGet(this, _query);
+  }
+  get tx() {
+    return __privateGet(this, _tx);
+  }
+  /**
+   * if derivePathParams is not provided or mnemonics is empty, it will return the currentSigner.
+   * else:
+   * it will generate signer from the mnemonic with the given derivePathParams.
+   * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
+   */
+  getSigner(derivePathParams) {
+    const keyPair = this.accountManager.getKeyPair(derivePathParams);
+    return new import_sui9.RawSigner(keyPair, this.suiInteractor.currentProvider);
+  }
+  /**
+   * @description Switch the current account with the given derivePathParams
+   * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
+   */
+  switchAccount(derivePathParams) {
+    this.accountManager.switchAccount(derivePathParams);
+  }
+  /**
+   * @description Get the address of the account for the given derivePathParams
+   * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
+   */
+  getAddress(derivePathParams) {
+    return this.accountManager.getAddress(derivePathParams);
+  }
+  currentAddress() {
+    return this.accountManager.currentAddress;
+  }
+  provider() {
+    return this.suiInteractor.currentProvider;
+  }
+  getPackageId() {
+    return this.contractFactory.packageId;
+  }
+  getMetadata() {
+    return this.contractFactory.metadata;
+  }
+  /**
+   * Request some SUI from faucet
+   * @Returns {Promise<boolean>}, true if the request is successful, false otherwise.
+   */
+  async requestFaucet(address, network) {
+    return this.suiInteractor.requestFaucet(address, network);
+  }
+  async getBalance(coinType, derivePathParams) {
+    const owner = this.accountManager.getAddress(derivePathParams);
+    return this.suiInteractor.currentProvider.getBalance({ owner, coinType });
+  }
+  async getObject(objectId) {
+    return this.suiInteractor.getObject(objectId);
+  }
+  async getObjects(objectIds) {
+    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 });
+  }
+  async signAndSendTxn(tx, derivePathParams) {
+    const { transactionBlockBytes, signature } = await this.signTxn(
+      tx,
+      derivePathParams
+    );
+    return this.suiInteractor.sendTx(transactionBlockBytes, signature);
+  }
+  /**
+   * Transfer the given amount of SUI to the recipient
+   * @param recipient
+   * @param amount
+   * @param derivePathParams
+   */
+  async transferSui(recipient, amount, derivePathParams) {
+    const tx = new SuiTxBlock();
+    tx.transferSui(recipient, amount);
+    return this.signAndSendTxn(tx, derivePathParams);
+  }
+  /**
+   * Transfer to mutliple recipients
+   * @param recipients the recipients addresses
+   * @param amounts the amounts of SUI to transfer to each recipient, the length of amounts should be the same as the length of recipients
+   * @param derivePathParams
+   */
+  async transferSuiToMany(recipients, amounts, derivePathParams) {
+    const tx = new SuiTxBlock();
+    tx.transferSuiToMany(recipients, amounts);
+    return this.signAndSendTxn(tx, derivePathParams);
+  }
+  /**
+   * Transfer the given amounts of coin to multiple recipients
+   * @param recipients the list of recipient address
+   * @param amounts the amounts to transfer for each recipient
+   * @param coinType any custom coin type but not SUI
+   * @param derivePathParams the derive path params for the current signer
+   */
+  async transferCoinToMany(recipients, amounts, coinType, derivePathParams) {
+    const tx = new SuiTxBlock();
+    const owner = this.accountManager.getAddress(derivePathParams);
+    const totalAmount = amounts.reduce((a, b) => a + b, 0);
+    const coins = await this.suiInteractor.selectCoins(
+      owner,
+      totalAmount,
+      coinType
+    );
+    tx.transferCoinToMany(
+      coins.map((c) => c.objectId),
+      owner,
+      recipients,
+      amounts
+    );
+    return this.signAndSendTxn(tx, derivePathParams);
+  }
+  async transferCoin(recipient, amount, coinType, derivePathParams) {
+    return this.transferCoinToMany(
+      [recipient],
+      [amount],
+      coinType,
+      derivePathParams
+    );
+  }
+  async transferObjects(objects, recipient, derivePathParams) {
+    const tx = new SuiTxBlock();
+    tx.transferObjects(objects, recipient);
+    return this.signAndSendTxn(tx, derivePathParams);
+  }
+  async moveCall(callParams) {
+    const {
+      target,
+      arguments: args = [],
+      typeArguments = [],
+      derivePathParams
+    } = callParams;
+    const tx = new SuiTxBlock();
+    tx.moveCall(target, args, typeArguments);
+    return this.signAndSendTxn(tx, derivePathParams);
+  }
+  /**
+   * Select coins with the given amount and coin type, the total amount is greater than or equal to the given amount
+   * @param amount
+   * @param coinType
+   * @param owner
+   */
+  async selectCoinsWithAmount(amount, coinType, owner) {
+    owner = owner || this.accountManager.currentAddress;
+    const coins = await this.suiInteractor.selectCoins(owner, amount, coinType);
+    return coins.map((c) => c.objectId);
+  }
+  /**
+   * stake the given amount of SUI to the validator
+   * @param amount the amount of SUI to stake
+   * @param validatorAddr the validator address
+   * @param derivePathParams the derive path params for the current signer
+   */
+  async stakeSui(amount, validatorAddr, derivePathParams) {
+    const tx = new SuiTxBlock();
+    tx.stakeSui(amount, validatorAddr);
+    return this.signAndSendTxn(tx, derivePathParams);
+  }
+  /**
+   * Execute the transaction with on-chain data but without really submitting. Useful for querying the effects of a transaction.
+   * Since the transaction is not submitted, its gas cost is not charged.
+   * @param tx the transaction to execute
+   * @param derivePathParams the derive path params
+   * @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,
+      sender: this.getAddress(derivePathParams)
+    });
+  }
+  async getWorld(worldObjectId) {
+    return this.suiInteractor.getObject(worldObjectId);
+  }
+  async listSchemaNames(worldId) {
+    const worldObject = await this.getObject(worldId);
+    const newObjectContent = worldObject.objectFields;
+    return newObjectContent["schemaNames"];
+  }
+  async getEntity(worldId, schemaName, entityId) {
+    const schemaMoudleName = `${schemaName}_schema`;
+    const tx = new import_sui9.TransactionBlock();
+    const params = [tx.pure(worldId)];
+    if (entityId !== void 0) {
+      params.push(tx.pure(entityId));
+    }
+    const getResult = await this.query[schemaMoudleName].get(
+      tx,
+      params
+    );
+    const returnValue = [];
+    if (getResult.effects.status.status === "success") {
+      const resultList = getResult.results[0].returnValues;
+      for (const res of resultList) {
+        const bcs = new import_bcs.BCS((0, import_bcs.getSuiMoveConfig)());
+        const value = Uint8Array.from(res[0]);
+        const data = bcs.de(res[1], value);
+        returnValue.push(data);
+      }
+      return returnValue;
+    } else {
+      return void 0;
+    }
+  }
+  async containEntity(worldId, schemaName, entityId) {
+    const schemaMoudleName = `${schemaName}_schema`;
+    const tx = new import_sui9.TransactionBlock();
+    const params = [tx.pure(worldId)];
+    if (entityId !== void 0) {
+      params.push(tx.pure(entityId));
+    }
+    const getResult = await this.query[schemaMoudleName].contains(
+      tx,
+      params
+    );
+    if (getResult.effects.status.status === "success") {
+      const res = getResult.results[0].returnValues[0];
+      const bcs = new import_bcs.BCS((0, import_bcs.getSuiMoveConfig)());
+      const value = Uint8Array.from(res[0]);
+      return bcs.de(res[1], value);
+    } else {
+      return void 0;
+    }
+  }
+  // async getEntities(
+  //   worldId: string,
+  //   schemaName: string,
+  //   cursor?: string,
+  //   limit?: number
+  // ) {
+  //   let schemaMoudleName = `${schemaName}_schema`;
+  //   const tx = new TransactionBlock();
+  //   let params = [tx.pure(worldId)] as SuiTxArgument[];
+  //   const tableResult = (await this.query[schemaonentMoudleName].entities(
+  //     tx,
+  //     params
+  //   )) as DevInspectResults;
+  //   const entities = tableResult.results as SuiReturnValues;
+  //   const bcs = new BCS(getSuiMoveConfig());
+  //   let value = Uint8Array.from(entities[0].returnValues[0][0]);
+  //   let tableId = '0x' + bcs.de('address', value);
+  //   let dynamicFields = await this.suiInteractor.getDynamicFields(
+  //     tableId,
+  //     cursor,
+  //     limit
+  //   );
+  //   let objectIds = dynamicFields.data.map((field) => field.objectId);
+  //   let objectDatas = await this.suiInteractor.getEntitiesObjects(objectIds);
+  //   return {
+  //     data: objectDatas,
+  //     nextCursor: dynamicFields.nextCursor,
+  //     hasNextPage: dynamicFields.hasNextPage,
+  //   };
+  // }
+  async getOwnedObjects(owner, cursor, limit) {
+    const ownedObjects = await this.suiInteractor.getOwnedObjects(
+      owner,
+      cursor,
+      limit
+    );
+    const ownedObjectsRes = [];
+    for (const object of ownedObjects.data) {
+      const objectDetail = await this.getObject(object.data.objectId);
+      if (objectDetail.objectType.split("::")[0] === this.contractFactory.packageId) {
+        ownedObjectsRes.push(objectDetail);
+      }
+    }
+    return ownedObjectsRes;
+  }
+  async entity_key_from_object(objectId) {
+    const checkObjectId = normalizeHexAddress(objectId);
+    if (checkObjectId !== null) {
+      objectId = checkObjectId;
+      return objectId;
+    } else {
+      return void 0;
+    }
+  }
+  async entity_key_from_bytes(bytes) {
+    const hashBytes = (0, import_keccak256.default)(bytes);
+    const hashU8Array = Array.from(hashBytes);
+    const bcs = new import_bcs.BCS((0, import_bcs.getSuiMoveConfig)());
+    const value = Uint8Array.from(hashU8Array);
+    const data = bcs.de("address", value);
+    return "0x" + data;
+  }
+  async entity_key_from_u256(x) {
+    return numberToAddressHex(x);
+  }
+  async formatData(type, value) {
+    const bcs = new import_bcs.BCS((0, import_bcs.getSuiMoveConfig)());
+    const u8Value = Uint8Array.from(value);
+    return bcs.de(type, u8Value);
+  }
+};
+_query = new WeakMap();
+_tx = new WeakMap();
+_exec = new WeakMap();
+_read = new WeakMap();
+
+// src/metadata/index.ts
+async function getMetadata(networkType, packageId) {
+  const fullnodeUrls = [getDefaultConnection(networkType).fullnode];
+  const suiInteractor = new SuiInteractor(fullnodeUrls);
+  if (packageId !== void 0) {
+    const jsonData = await suiInteractor.getNormalizedMoveModulesByPackage(packageId);
+    return jsonData;
+  } else {
+    console.error("please set your package id.");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Ed25519Keypair,
+  Obelisk,
+  SuiAccountManager,
+  SuiContractFactory,
+  SuiTxBlock,
+  getMetadata,
+  ...require("@mysten/sui.js"),
+  ...require("@mysten/bcs")
+});
+//# sourceMappingURL=index.js.map