@0xobelisk/client 0.3.2 → 0.3.3

package/dist/index.mjs

@@ -1,1263 +0,0 @@
-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
-export * from "@mysten/sui.js";
-import { Ed25519Keypair as Ed25519Keypair3 } from "@mysten/sui.js/keypairs/ed25519";
-export * from "@mysten/bcs";
-
-// src/obelisk.ts
-import {
-  RawSigner,
-  TransactionBlock as TransactionBlock3
-} from "@mysten/sui.js";
-
-// src/libs/suiAccountManager/index.ts
-import { Ed25519Keypair as Ed25519Keypair2 } from "@mysten/sui.js";
-
-// src/libs/suiAccountManager/keypair.ts
-import { Ed25519Keypair } from "@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 Ed25519Keypair.deriveKeypair(mnemonics, derivePath);
-};
-
-// src/libs/suiAccountManager/util.ts
-import { fromB64 as fromB642 } from "@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 fromB642(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
-import { generateMnemonic as genMnemonic } from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english";
-var generateMnemonic = (numberOfWords = 24) => {
-  const strength = numberOfWords === 12 ? 128 : 256;
-  return genMnemonic(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 ? Ed25519Keypair2.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
-import {
-  TransactionBlock as TransactionBlock2,
-  SUI_SYSTEM_STATE_OBJECT_ID
-} from "@mysten/sui.js";
-
-// src/libs/suiTxBuilder/util.ts
-import {
-  normalizeSuiObjectId
-} from "@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(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(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 TransactionBlock2(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(SUI_SYSTEM_STATE_OBJECT_ID),
-        stakeCoin,
-        tx.pure(validatorAddr)
-      ]
-    });
-    return tx;
-  }
-};
-
-// src/libs/suiInteractor/suiInteractor.ts
-import {
-  JsonRpcProvider as JsonRpcProvider2,
-  Connection,
-  getObjectDisplay,
-  getObjectFields,
-  getObjectId,
-  getObjectType,
-  getObjectVersion,
-  getSharedObjectInitialVersion
-} from "@mysten/sui.js";
-import { requestSuiFromFaucetV0, getFaucetHost } from "@mysten/sui.js/faucet";
-
-// src/libs/suiModel/suiOwnedObject.ts
-import {
-  getObjectChanges
-} from "@mysten/sui.js";
-var SuiOwnedObject = class {
-  constructor(param) {
-    this.objectId = param.objectId;
-    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 = 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 JsonRpcProvider2(new 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 = getObjectId(object);
-          const objectType = getObjectType(object);
-          const objectVersion = getObjectVersion(object);
-          const objectDigest = object.data ? object.data.digest : void 0;
-          const initialSharedVersion = getSharedObjectInitialVersion(object);
-          const objectFields = getObjectFields(object);
-          const objectDisplay = getObjectDisplay(object);
-          return {
-            objectId,
-            objectType,
-            objectVersion,
-            objectDigest,
-            objectFields,
-            objectDisplay,
-            initialSharedVersion
-          };
-        });
-        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 = getObjectId(object);
-          const objectFields = 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 requestSuiFromFaucetV0({
-      host: getFaucetHost(network),
-      recipient: address
-    });
-  }
-};
-
-// src/libs/suiInteractor/defaultConfig.ts
-import {
-  localnetConnection,
-  devnetConnection,
-  testnetConnection,
-  mainnetConnection
-} from "@mysten/sui.js";
-var defaultGasBudget = 10 ** 8;
-var getDefaultConnection = (networkType = "devnet") => {
-  switch (networkType) {
-    case "localnet":
-      return localnetConnection;
-    case "devnet":
-      return devnetConnection;
-    case "testnet":
-      return testnetConnection;
-    case "mainnet":
-      return mainnetConnection;
-    default:
-      return devnetConnection;
-  }
-};
-
-// src/libs/suiContractFactory/index.ts
-var SuiContractFactory = class {
-  // readonly #query: MapMessageQuery<ApiTypes> = {};
-  // 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
-import keccak256 from "keccak256";
-import { BCS, getSuiMoveConfig } from "@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 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 TransactionBlock3();
-    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 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 TransactionBlock3();
-    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 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 = keccak256(bytes);
-    const hashU8Array = Array.from(hashBytes);
-    const bcs = new 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 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.");
-  }
-}
-export {
-  Ed25519Keypair3 as Ed25519Keypair,
-  Obelisk,
-  SuiAccountManager,
-  SuiContractFactory,
-  SuiTxBlock,
-  getMetadata
-};
-//# sourceMappingURL=index.mjs.map