wowok 2.1.9 → 2.1.12

package/dist/esm/jsonRpc/client.js

@@ -1,734 +1,653 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
 import { fromBase58, toBase64, toHex } from "@mysten/bcs";
 import { Experimental_BaseClient } from "../experimental/client.js";
 import { isTransaction } from "../transactions/Transaction.js";
-import {
-  isValidWowAddress,
-  isValidWowObjectId,
-  isValidTransactionDigest,
-  normalizeWowAddress,
-  normalizeWowObjectId
-} from "../utils/sui-types.js";
+import { isValidWowAddress, isValidWowObjectId, isValidTransactionDigest, normalizeWowAddress, normalizeWowObjectId, } from "../utils/sui-types.js";
 import { JsonRpcHTTPTransport } from "./http-transport.js";
 import { JSONRpcCoreClient } from "./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;
+const SUI_CLIENT_BRAND = Symbol.for("@mysten/SuiClient");
+export function isSuiJsonRpcClient(client) {
+    return (typeof client === "object" &&
+        client !== null &&
+        client[SUI_CLIENT_BRAND] === true);
 }
-class SuiJsonRpcClient extends 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 JsonRpcHTTPTransport({ url: options.url });
-    this.core = new 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 || !isValidWowAddress(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 || !isValidWowAddress(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 || !isValidWowAddress(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 || !isValidWowAddress(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,
-    function: fn,
-    signal
-  }) {
-    return await this.transport.request({
-      method: "w_getMoveFunctionArgTypes",
-      params: [pkg, module, 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,
-    signal
-  }) {
-    return await this.transport.request({
-      method: "w_getNormalizedMoveModule",
-      params: [pkg, module],
-      signal
-    });
-  }
-  /**
-   * Get a structured representation of Move function
-   */
-  async getNormalizedMoveFunction({
-    package: pkg,
-    module,
-    function: fn,
-    signal
-  }) {
-    return await this.transport.request({
-      method: "w_getNormalizedMoveFunction",
-      params: [pkg, module, fn],
-      signal
-    });
-  }
-  /**
-   * Get a structured representation of Move struct
-   */
-  /**
-   * Get the normalized Move struct from a package
-   */
-  async getNormalizedMoveStruct({
-    package: pkg,
-    module,
-    struct,
-    signal
-  }) {
-    return await this.transport.request({
-      method: "w_getNormalizedMoveStruct",
-      params: [pkg, module, struct],
-      signal
-    });
-  }
-  /**
-   * Get all objects owned by an address
-   */
-  async getOwnedObjects(input) {
-    if (!input.owner || !isValidWowAddress(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 || !isValidWowObjectId(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 || !isValidWowObjectId(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 (!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 (!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 : 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 || !isValidWowAddress(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 || !isValidWowObjectId(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 (isTransaction(input.transactionBlock)) {
-      input.transactionBlock.setSenderIfNotSet(input.sender);
-      devInspectTxBytes = 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 = 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 : toBase64(input.transactionBlock)
-      ]
-    });
-  }
-  /**
-   * Return the list of dynamic field objects owned by an object
-   */
-  async getDynamicFields(input) {
-    if (!input.parentId || !isValidWowObjectId(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 = fromBase58(checkpoint.digest);
-    return 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."
-    );
-  }
+export class SuiJsonRpcClient extends Experimental_BaseClient {
+    core;
+    jsonRpc = this;
+    transport;
+    get [SUI_CLIENT_BRAND]() {
+        return true;
+    }
+    /**
+     * Establish a connection to a Sui RPC endpoint
+     *
+     * @param options configuration options for the API Client
+     */
+    constructor(options) {
+        super({ network: options.network ?? "unknown" });
+        this.transport =
+            options.transport ?? new JsonRpcHTTPTransport({ url: options.url });
+        this.core = new JSONRpcCoreClient({
+            jsonRpcClient: this,
+        });
+    }
+    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 || !isValidWowAddress(normalizeWowAddress(owner))) {
+            throw new Error("Invalid Wow address");
+        }
+        return await this.transport.request({
+            method: "wx_getCoins",
+            params: [owner, coinType, cursor, limit],
+            signal: signal,
+        });
+    }
+    /**
+     * Get all Coin objects owned by an address.
+     */
+    async getAllCoins(input) {
+        if (!input.owner ||
+            !isValidWowAddress(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 || !isValidWowAddress(normalizeWowAddress(owner))) {
+            throw new Error("Invalid Wow address");
+        }
+        return await this.transport.request({
+            method: "wx_getBalance",
+            params: [owner, coinType],
+            signal: signal,
+        });
+    }
+    /**
+     * Get the total coin balance for all coin types, owned by the address owner.
+     */
+    async getAllBalances(input) {
+        if (!input.owner ||
+            !isValidWowAddress(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: signal,
+        });
+    }
+    /**
+     *  Fetch total supply for a coin
+     */
+    async getTotalSupply({ coinType, signal, }) {
+        return await this.transport.request({
+            method: "wx_getTotalSupply",
+            params: [coinType],
+            signal: 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, function: fn, signal, }) {
+        return await this.transport.request({
+            method: "w_getMoveFunctionArgTypes",
+            params: [pkg, module, fn],
+            signal: 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: signal,
+        });
+    }
+    /**
+     * Get a structured representation of Move module
+     */
+    async getNormalizedMoveModule({ package: pkg, module, signal, }) {
+        return await this.transport.request({
+            method: "w_getNormalizedMoveModule",
+            params: [pkg, module],
+            signal: signal,
+        });
+    }
+    /**
+     * Get a structured representation of Move function
+     */
+    async getNormalizedMoveFunction({ package: pkg, module, function: fn, signal, }) {
+        return await this.transport.request({
+            method: "w_getNormalizedMoveFunction",
+            params: [pkg, module, fn],
+            signal: signal,
+        });
+    }
+    /**
+     * Get a structured representation of Move struct
+     */
+    /**
+     * Get the normalized Move struct from a package
+     */
+    async getNormalizedMoveStruct({ package: pkg, module, struct, signal, }) {
+        return await this.transport.request({
+            method: "w_getNormalizedMoveStruct",
+            params: [pkg, module, struct],
+            signal: signal,
+        });
+    }
+    /**
+     * Get all objects owned by an address
+     */
+    async getOwnedObjects(input) {
+        if (!input.owner ||
+            !isValidWowAddress(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 || !isValidWowObjectId(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 || !isValidWowObjectId(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 (!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 (!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
+                    : toBase64(transactionBlock),
+                Array.isArray(signature) ? signature : [signature],
+                options,
+            ],
+            signal,
+        });
+        if (requestType === "WaitForLocalExecution") {
+            try {
+                await this.waitForTransaction({
+                    digest: result.digest,
+                    signal,
+                });
+            }
+            catch (e) {
+                // continue regardless of outcome
+            }
+        }
+        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 ||
+            !isValidWowAddress(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 || !isValidWowObjectId(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 (isTransaction(input.transactionBlock)) {
+            input.transactionBlock.setSenderIfNotSet(input.sender);
+            devInspectTxBytes = 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 = 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
+                    : toBase64(input.transactionBlock),
+            ],
+        });
+    }
+    /**
+     * Return the list of dynamic field objects owned by an object
+     */
+    async getDynamicFields(input) {
+        if (!input.parentId ||
+            !isValidWowObjectId(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 = fromBase58(checkpoint.digest);
+        return 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 * 1000, pollInterval = 2 * 1000, ...input }) {
+        const timeoutSignal = AbortSignal.timeout(timeout);
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutSignal.addEventListener("abort", () => reject(timeoutSignal.reason));
+        });
+        timeoutPromise.catch(() => {
+            // Swallow unhandled rejections that might be thrown after early return
+        });
+        while (!timeoutSignal.aborted) {
+            signal?.throwIfAborted();
+            try {
+                return await this.getTransactionBlock(input);
+            }
+            catch {
+                // Wait for either the next poll interval, or the timeout.
+                await Promise.race([
+                    new Promise((resolve) => setTimeout(resolve, pollInterval)),
+                    timeoutPromise,
+                ]);
+            }
+        }
+        timeoutSignal.throwIfAborted();
+        // This should never happen, because the above case should always throw, but just adding it in the event that something goes horribly wrong.
+        throw new Error("Unexpected error while waiting for transaction block.");
+    }
 }
-export {
-  SuiJsonRpcClient,
-  isSuiJsonRpcClient
-};
+//# sourceMappingURL=client.js.map