wowok 1.8.2 → 2.1.9

package/dist/cjs/jsonRpc/client.js

@@ -0,0 +1,747 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var client_exports = {};
+__export(client_exports, {
+  SuiJsonRpcClient: () => SuiJsonRpcClient,
+  isSuiJsonRpcClient: () => isSuiJsonRpcClient
+});
+module.exports = __toCommonJS(client_exports);
+var import_bcs = require("@mysten/bcs");
+var import_client = require("../experimental/client.js");
+var import_Transaction = require("../transactions/Transaction.js");
+var import_sui_types = require("../utils/sui-types.js");
+var import_http_transport = require("./http-transport.js");
+var import_core = require("./core.js");
+const SUI_CLIENT_BRAND = /* @__PURE__ */ Symbol.for("@mysten/SuiClient");
+function isSuiJsonRpcClient(client) {
+  return typeof client === "object" && client !== null && client[SUI_CLIENT_BRAND] === true;
+}
+class SuiJsonRpcClient extends import_client.Experimental_BaseClient {
+  /**
+   * Establish a connection to a Sui RPC endpoint
+   *
+   * @param options configuration options for the API Client
+   */
+  constructor(options) {
+    super({ network: options.network ?? "unknown" });
+    __publicField(this, "core");
+    __publicField(this, "jsonRpc", this);
+    __publicField(this, "transport");
+    this.transport = options.transport ?? new import_http_transport.JsonRpcHTTPTransport({ url: options.url });
+    this.core = new import_core.JSONRpcCoreClient({
+      jsonRpcClient: this
+    });
+  }
+  get [SUI_CLIENT_BRAND]() {
+    return true;
+  }
+  async getRpcApiVersion({ signal } = {}) {
+    const resp = await this.transport.request({
+      method: "rpc.discover",
+      params: [],
+      signal
+    });
+    return resp.info.version;
+  }
+  /**
+   * Get all Coin<`coin_type`> objects owned by an address.
+   */
+  async getCoins({
+    coinType,
+    owner,
+    cursor,
+    limit,
+    signal
+  }) {
+    if (!owner || !(0, import_sui_types.isValidWowAddress)((0, import_sui_types.normalizeWowAddress)(owner))) {
+      throw new Error("Invalid Wow address");
+    }
+    return await this.transport.request({
+      method: "wx_getCoins",
+      params: [owner, coinType, cursor, limit],
+      signal
+    });
+  }
+  /**
+   * Get all Coin objects owned by an address.
+   */
+  async getAllCoins(input) {
+    if (!input.owner || !(0, import_sui_types.isValidWowAddress)((0, import_sui_types.normalizeWowAddress)(input.owner))) {
+      throw new Error("Invalid Wow address");
+    }
+    return await this.transport.request({
+      method: "wx_getAllCoins",
+      params: [input.owner, input.cursor, input.limit],
+      signal: input.signal
+    });
+  }
+  /**
+   * Get the total coin balance for one coin type, owned by the address owner.
+   */
+  async getBalance({
+    owner,
+    coinType,
+    signal
+  }) {
+    if (!owner || !(0, import_sui_types.isValidWowAddress)((0, import_sui_types.normalizeWowAddress)(owner))) {
+      throw new Error("Invalid Wow address");
+    }
+    return await this.transport.request({
+      method: "wx_getBalance",
+      params: [owner, coinType],
+      signal
+    });
+  }
+  /**
+   * Get the total coin balance for all coin types, owned by the address owner.
+   */
+  async getAllBalances(input) {
+    if (!input.owner || !(0, import_sui_types.isValidWowAddress)((0, import_sui_types.normalizeWowAddress)(input.owner))) {
+      throw new Error("Invalid Wow address");
+    }
+    return await this.transport.request({
+      method: "wx_getAllBalances",
+      params: [input.owner],
+      signal: input.signal
+    });
+  }
+  /**
+   * Fetch CoinMetadata for a given coin type
+   */
+  async getCoinMetadata({
+    coinType,
+    signal
+  }) {
+    return await this.transport.request({
+      method: "wx_getCoinMetadata",
+      params: [coinType],
+      signal
+    });
+  }
+  /**
+   *  Fetch total supply for a coin
+   */
+  async getTotalSupply({
+    coinType,
+    signal
+  }) {
+    return await this.transport.request({
+      method: "wx_getTotalSupply",
+      params: [coinType],
+      signal
+    });
+  }
+  /**
+   * Invoke any RPC method
+   * @param method the method to be invoked
+   * @param args the arguments to be passed to the RPC request
+   */
+  async call(method, params, { signal } = {}) {
+    return await this.transport.request({ method, params, signal });
+  }
+  /**
+   * Get Move function argument types like read, write and full access
+   */
+  async getMoveFunctionArgTypes({
+    package: pkg,
+    module: module2,
+    function: fn,
+    signal
+  }) {
+    return await this.transport.request({
+      method: "w_getMoveFunctionArgTypes",
+      params: [pkg, module2, fn],
+      signal
+    });
+  }
+  /**
+   * Get a map from module name to
+   * structured representations of Move modules
+   */
+  async getNormalizedMoveModulesByPackage({
+    package: pkg,
+    signal
+  }) {
+    return await this.transport.request({
+      method: "w_getNormalizedMoveModulesByPackage",
+      params: [pkg],
+      signal
+    });
+  }
+  /**
+   * Get a structured representation of Move module
+   */
+  async getNormalizedMoveModule({
+    package: pkg,
+    module: module2,
+    signal
+  }) {
+    return await this.transport.request({
+      method: "w_getNormalizedMoveModule",
+      params: [pkg, module2],
+      signal
+    });
+  }
+  /**
+   * Get a structured representation of Move function
+   */
+  async getNormalizedMoveFunction({
+    package: pkg,
+    module: module2,
+    function: fn,
+    signal
+  }) {
+    return await this.transport.request({
+      method: "w_getNormalizedMoveFunction",
+      params: [pkg, module2, fn],
+      signal
+    });
+  }
+  /**
+   * Get a structured representation of Move struct
+   */
+  /**
+   * Get the normalized Move struct from a package
+   */
+  async getNormalizedMoveStruct({
+    package: pkg,
+    module: module2,
+    struct,
+    signal
+  }) {
+    return await this.transport.request({
+      method: "w_getNormalizedMoveStruct",
+      params: [pkg, module2, struct],
+      signal
+    });
+  }
+  /**
+   * Get all objects owned by an address
+   */
+  async getOwnedObjects(input) {
+    if (!input.owner || !(0, import_sui_types.isValidWowAddress)((0, import_sui_types.normalizeWowAddress)(input.owner))) {
+      throw new Error("Invalid Wow address");
+    }
+    return await this.transport.request({
+      method: "wx_getOwnedObjects",
+      params: [
+        input.owner,
+        {
+          filter: input.filter,
+          options: input.options
+        },
+        input.cursor,
+        input.limit
+      ],
+      signal: input.signal
+    });
+  }
+  /**
+   * Get details about an object
+   */
+  async getObject(input) {
+    if (!input.id || !(0, import_sui_types.isValidWowObjectId)((0, import_sui_types.normalizeWowObjectId)(input.id))) {
+      throw new Error("Invalid object ID");
+    }
+    return await this.transport.request({
+      method: "w_getObject",
+      params: [input.id, input.options],
+      signal: input.signal
+    });
+  }
+  async tryGetPastObject(input) {
+    return await this.transport.request({
+      method: "w_tryGetPastObject",
+      params: [input.id, input.version, input.options],
+      signal: input.signal
+    });
+  }
+  async multiGetObjects(input) {
+    input.ids.forEach((id) => {
+      if (!id || !(0, import_sui_types.isValidWowObjectId)((0, import_sui_types.normalizeWowObjectId)(id))) {
+        throw new Error(`Invalid object ID ${id}`);
+      }
+    });
+    const hasDuplicates = input.ids.length !== new Set(input.ids).size;
+    if (hasDuplicates) {
+      throw new Error(`Duplicate object ids in batch call ${input.ids}`);
+    }
+    return await this.transport.request({
+      method: "w_multiGetObjects",
+      params: [input.ids, input.options],
+      signal: input.signal
+    });
+  }
+  /**
+   * Get transaction blocks for a given query criteria
+   */
+  async queryTransactionBlocks({
+    filter,
+    options,
+    cursor,
+    limit,
+    order,
+    signal
+  }) {
+    return await this.transport.request({
+      method: "wx_queryTransactionBlocks",
+      params: [
+        {
+          filter,
+          options
+        },
+        cursor,
+        limit,
+        (order || "descending") === "descending"
+      ],
+      signal
+    });
+  }
+  async getTransactionBlock(input) {
+    if (!(0, import_sui_types.isValidTransactionDigest)(input.digest)) {
+      throw new Error("Invalid Transaction digest");
+    }
+    return await this.transport.request({
+      method: "w_getTransactionBlock",
+      params: [input.digest, input.options],
+      signal: input.signal
+    });
+  }
+  async multiGetTransactionBlocks(input) {
+    input.digests.forEach((d) => {
+      if (!(0, import_sui_types.isValidTransactionDigest)(d)) {
+        throw new Error(`Invalid Transaction digest ${d}`);
+      }
+    });
+    const hasDuplicates = input.digests.length !== new Set(input.digests).size;
+    if (hasDuplicates) {
+      throw new Error(`Duplicate digests in batch call ${input.digests}`);
+    }
+    return await this.transport.request({
+      method: "w_multiGetTransactionBlocks",
+      params: [input.digests, input.options],
+      signal: input.signal
+    });
+  }
+  async executeTransactionBlock({
+    transactionBlock,
+    signature,
+    options,
+    requestType,
+    signal
+  }) {
+    const result = await this.transport.request({
+      method: "w_executeTransactionBlock",
+      params: [
+        typeof transactionBlock === "string" ? transactionBlock : (0, import_bcs.toBase64)(transactionBlock),
+        Array.isArray(signature) ? signature : [signature],
+        options
+      ],
+      signal
+    });
+    if (requestType === "WaitForLocalExecution") {
+      try {
+        await this.waitForTransaction({
+          digest: result.digest,
+          signal
+        });
+      } catch (e) {
+      }
+    }
+    return result;
+  }
+  async signAndExecuteTransaction({
+    transaction,
+    signer,
+    ...input
+  }) {
+    let transactionBytes;
+    if (transaction instanceof Uint8Array) {
+      transactionBytes = transaction;
+    } else {
+      transaction.setSenderIfNotSet(signer.toWAddress());
+      transactionBytes = await transaction.build({ client: this });
+    }
+    const { signature, bytes } = await signer.signTransaction(transactionBytes);
+    return this.executeTransactionBlock({
+      transactionBlock: bytes,
+      signature,
+      ...input
+    });
+  }
+  /**
+   * Get total number of transactions
+   */
+  async getTotalTransactionBlocks({
+    signal
+  } = {}) {
+    const resp = await this.transport.request({
+      method: "w_getTotalTransactionBlocks",
+      params: [],
+      signal
+    });
+    return BigInt(resp);
+  }
+  /**
+   * Getting the reference gas price for the network
+   */
+  async getReferenceGasPrice({
+    signal
+  } = {}) {
+    const resp = await this.transport.request({
+      method: "wx_getReferenceGasPrice",
+      params: [],
+      signal
+    });
+    return BigInt(resp);
+  }
+  /**
+   * Return the delegated stakes for an address
+   */
+  async getStakes(input) {
+    if (!input.owner || !(0, import_sui_types.isValidWowAddress)((0, import_sui_types.normalizeWowAddress)(input.owner))) {
+      throw new Error("Invalid Wow address");
+    }
+    return await this.transport.request({
+      method: "wx_getStakes",
+      params: [input.owner],
+      signal: input.signal
+    });
+  }
+  /**
+   * Return the delegated stakes queried by id.
+   */
+  async getStakesByIds(input) {
+    input.stakedSuiIds.forEach((id) => {
+      if (!id || !(0, import_sui_types.isValidWowObjectId)((0, import_sui_types.normalizeWowObjectId)(id))) {
+        throw new Error(`Invalid Wow Stake id ${id}`);
+      }
+    });
+    return await this.transport.request({
+      method: "wx_getStakesByIds",
+      params: [input.stakedSuiIds],
+      signal: input.signal
+    });
+  }
+  /**
+   * Return the latest system state content.
+   */
+  async getLatestSuiSystemState({
+    signal
+  } = {}) {
+    return await this.transport.request({
+      method: "wx_getLatestSuiSystemState",
+      params: [],
+      signal
+    });
+  }
+  /**
+   * Get events for a given query criteria
+   */
+  async queryEvents({
+    query,
+    cursor,
+    limit,
+    order,
+    signal
+  }) {
+    return await this.transport.request({
+      method: "wx_queryEvents",
+      params: [
+        query,
+        cursor,
+        limit,
+        (order || "descending") === "descending"
+      ],
+      signal
+    });
+  }
+  /**
+   * Subscribe to get notifications whenever an event matching the filter occurs
+   *
+   * @deprecated
+   */
+  async subscribeEvent(input) {
+    return this.transport.subscribe({
+      method: "wx_subscribeEvent",
+      unsubscribe: "wx_unsubscribeEvent",
+      params: [input.filter],
+      onMessage: input.onMessage,
+      signal: input.signal
+    });
+  }
+  /**
+   * @deprecated
+   */
+  async subscribeTransaction(input) {
+    return this.transport.subscribe({
+      method: "wx_subscribeTransaction",
+      unsubscribe: "wx_unsubscribeTransaction",
+      params: [input.filter],
+      onMessage: input.onMessage,
+      signal: input.signal
+    });
+  }
+  /**
+   * Runs the transaction block in dev-inspect mode. Which allows for nearly any
+   * transaction (or Move call) with any arguments. Detailed results are
+   * provided, including both the transaction effects and any return values.
+   */
+  async devInspectTransactionBlock(input) {
+    let devInspectTxBytes;
+    if ((0, import_Transaction.isTransaction)(input.transactionBlock)) {
+      input.transactionBlock.setSenderIfNotSet(input.sender);
+      devInspectTxBytes = (0, import_bcs.toBase64)(
+        await input.transactionBlock.build({
+          client: this,
+          onlyTransactionKind: true
+        })
+      );
+    } else if (typeof input.transactionBlock === "string") {
+      devInspectTxBytes = input.transactionBlock;
+    } else if (input.transactionBlock instanceof Uint8Array) {
+      devInspectTxBytes = (0, import_bcs.toBase64)(input.transactionBlock);
+    } else {
+      throw new Error("Unknown transaction block format.");
+    }
+    input.signal?.throwIfAborted();
+    return await this.transport.request({
+      method: "w_devInspectTransactionBlock",
+      params: [
+        input.sender,
+        devInspectTxBytes,
+        input.gasPrice?.toString(),
+        input.epoch
+      ],
+      signal: input.signal
+    });
+  }
+  /**
+   * Dry run a transaction block and return the result.
+   */
+  async dryRunTransactionBlock(input) {
+    return await this.transport.request({
+      method: "w_dryRunTransactionBlock",
+      params: [
+        typeof input.transactionBlock === "string" ? input.transactionBlock : (0, import_bcs.toBase64)(input.transactionBlock)
+      ]
+    });
+  }
+  /**
+   * Return the list of dynamic field objects owned by an object
+   */
+  async getDynamicFields(input) {
+    if (!input.parentId || !(0, import_sui_types.isValidWowObjectId)((0, import_sui_types.normalizeWowObjectId)(input.parentId))) {
+      throw new Error("Invalid Sui Object id");
+    }
+    return await this.transport.request({
+      method: "wx_getDynamicFields",
+      params: [input.parentId, input.cursor, input.limit],
+      signal: input.signal
+    });
+  }
+  /**
+   * Return the dynamic field object information for a specified object
+   */
+  async getDynamicFieldObject(input) {
+    return await this.transport.request({
+      method: "wx_getDynamicFieldObject",
+      params: [input.parentId, input.name],
+      signal: input.signal
+    });
+  }
+  /**
+   * Get the sequence number of the latest checkpoint that has been executed
+   */
+  async getLatestCheckpointSequenceNumber({
+    signal
+  } = {}) {
+    const resp = await this.transport.request({
+      method: "w_getLatestCheckpointSequenceNumber",
+      params: [],
+      signal
+    });
+    return String(resp);
+  }
+  /**
+   * Returns information about a given checkpoint
+   */
+  async getCheckpoint(input) {
+    return await this.transport.request({
+      method: "w_getCheckpoint",
+      params: [input.id],
+      signal: input.signal
+    });
+  }
+  /**
+   * Returns historical checkpoints paginated
+   */
+  /**
+   * Return the committee information for the asked epoch
+   */
+  async getCheckpoints(input) {
+    return await this.transport.request({
+      method: "w_getCheckpoints",
+      params: [input.cursor, input?.limit, input.descendingOrder],
+      signal: input.signal
+    });
+  }
+  /**
+   * Return the committee information for the asked epoch
+   */
+  async getCommitteeInfo(input) {
+    return await this.transport.request({
+      method: "wx_getCommitteeInfo",
+      params: [input?.epoch],
+      signal: input?.signal
+    });
+  }
+  async getNetworkMetrics({
+    signal
+  } = {}) {
+    return await this.transport.request({
+      method: "wx_getNetworkMetrics",
+      params: [],
+      signal
+    });
+  }
+  async getAddressMetrics({
+    signal
+  } = {}) {
+    return await this.transport.request({
+      method: "wx_getLatestAddressMetrics",
+      params: [],
+      signal
+    });
+  }
+  async getEpochMetrics(input) {
+    return await this.transport.request({
+      method: "wx_getEpochMetrics",
+      params: [input?.cursor, input?.limit, input?.descendingOrder],
+      signal: input?.signal
+    });
+  }
+  async getAllEpochAddressMetrics(input) {
+    return await this.transport.request({
+      method: "wx_getAllEpochAddressMetrics",
+      params: [input?.descendingOrder],
+      signal: input?.signal
+    });
+  }
+  /**
+   * Return the committee information for the asked epoch
+   */
+  async getEpochs(input) {
+    return await this.transport.request({
+      method: "wx_getEpochs",
+      params: [input?.cursor, input?.limit, input?.descendingOrder],
+      signal: input?.signal
+    });
+  }
+  /**
+   * Returns list of top move calls by usage
+   */
+  async getMoveCallMetrics({
+    signal
+  } = {}) {
+    return await this.transport.request({
+      method: "wx_getMoveCallMetrics",
+      params: [],
+      signal
+    });
+  }
+  /**
+   * Return the committee information for the asked epoch
+   */
+  async getCurrentEpoch({
+    signal
+  } = {}) {
+    return await this.transport.request({
+      method: "wx_getCurrentEpoch",
+      params: [],
+      signal
+    });
+  }
+  /**
+   * Return the Validators APYs
+   */
+  async getValidatorsApy({
+    signal
+  } = {}) {
+    return await this.transport.request({
+      method: "wx_getValidatorsApy",
+      params: [],
+      signal
+    });
+  }
+  // TODO: Migrate this to `sui_getChainIdentifier` once it is widely available.
+  async getChainIdentifier({
+    signal
+  } = {}) {
+    const checkpoint = await this.getCheckpoint({ id: "0", signal });
+    const bytes = (0, import_bcs.fromBase58)(checkpoint.digest);
+    return (0, import_bcs.toHex)(bytes.slice(0, 4));
+  }
+  async getProtocolConfig(input) {
+    return await this.transport.request({
+      method: "w_getProtocolConfig",
+      params: [input?.version],
+      signal: input?.signal
+    });
+  }
+  /**
+   * Wait for a transaction block result to be available over the API.
+   * This can be used in conjunction with `executeTransactionBlock` to wait for the transaction to
+   * be available via the API.
+   * This currently polls the `getTransactionBlock` API to check for the transaction.
+   */
+  async waitForTransaction({
+    signal,
+    timeout = 60 * 1e3,
+    pollInterval = 2 * 1e3,
+    ...input
+  }) {
+    const timeoutSignal = AbortSignal.timeout(timeout);
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutSignal.addEventListener(
+        "abort",
+        () => reject(timeoutSignal.reason)
+      );
+    });
+    timeoutPromise.catch(() => {
+    });
+    while (!timeoutSignal.aborted) {
+      signal?.throwIfAborted();
+      try {
+        return await this.getTransactionBlock(input);
+      } catch {
+        await Promise.race([
+          new Promise((resolve) => setTimeout(resolve, pollInterval)),
+          timeoutPromise
+        ]);
+      }
+    }
+    timeoutSignal.throwIfAborted();
+    throw new Error(
+      "Unexpected error while waiting for transaction block."
+    );
+  }
+}