wowok 1.8.2 → 2.1.9

package/dist/cjs/jsonRpc/http-transport.d.ts

@@ -0,0 +1,42 @@
+import type { WebsocketClientOptions } from "./rpc-websocket-client.js";
+/**
+ * An object defining headers to be passed to the RPC server
+ */
+export type HttpHeaders = {
+    [header: string]: string;
+};
+export interface JsonRpcHTTPTransportOptions {
+    fetch?: typeof fetch;
+    WebSocketConstructor?: typeof WebSocket;
+    url: string;
+    rpc?: {
+        headers?: HttpHeaders;
+        url?: string;
+    };
+    websocket?: WebsocketClientOptions & {
+        url?: string;
+    };
+}
+export interface JsonRpcTransportRequestOptions {
+    method: string;
+    params: unknown[];
+    signal?: AbortSignal;
+}
+export interface JsonRpcTransportSubscribeOptions<T> {
+    method: string;
+    unsubscribe: string;
+    params: unknown[];
+    onMessage: (event: T) => void;
+    signal?: AbortSignal;
+}
+export interface JsonRpcTransport {
+    request<T = unknown>(input: JsonRpcTransportRequestOptions): Promise<T>;
+    subscribe<T = unknown>(input: JsonRpcTransportSubscribeOptions<T>): Promise<() => Promise<boolean>>;
+}
+export declare class JsonRpcHTTPTransport implements JsonRpcTransport {
+    #private;
+    constructor(options: JsonRpcHTTPTransportOptions);
+    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+    request<T>(input: JsonRpcTransportRequestOptions): Promise<T>;
+    subscribe<T>(input: JsonRpcTransportSubscribeOptions<T>): Promise<() => Promise<boolean>>;
+}

package/dist/cjs/jsonRpc/http-transport.js

@@ -0,0 +1,121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var http_transport_exports = {};
+__export(http_transport_exports, {
+  JsonRpcHTTPTransport: () => JsonRpcHTTPTransport
+});
+module.exports = __toCommonJS(http_transport_exports);
+var import_version = require("../version.js");
+var import_errors = require("./errors.js");
+var import_rpc_websocket_client = require("./rpc-websocket-client.js");
+var _requestId, _options, _websocketClient, _JsonRpcHTTPTransport_instances, getWebsocketClient_fn;
+class JsonRpcHTTPTransport {
+  constructor(options) {
+    __privateAdd(this, _JsonRpcHTTPTransport_instances);
+    __privateAdd(this, _requestId, 0);
+    __privateAdd(this, _options);
+    __privateAdd(this, _websocketClient);
+    __privateSet(this, _options, options);
+  }
+  fetch(input, init) {
+    const fetchFn = __privateGet(this, _options).fetch ?? fetch;
+    if (!fetchFn) {
+      throw new Error(
+        "The current environment does not support fetch, you can provide a fetch implementation in the options for SuiHTTPTransport."
+      );
+    }
+    return fetchFn(input, init);
+  }
+  async request(input) {
+    __privateSet(this, _requestId, __privateGet(this, _requestId) + 1);
+    const res = await this.fetch(
+      __privateGet(this, _options).rpc?.url ?? __privateGet(this, _options).url,
+      {
+        method: "POST",
+        signal: input.signal,
+        headers: {
+          "Content-Type": "application/json",
+          "Client-Sdk-Type": "typescript",
+          "Client-Sdk-Version": import_version.PACKAGE_VERSION,
+          "Client-Target-Api-Version": import_version.TARGETED_RPC_VERSION,
+          "Client-Request-Method": input.method,
+          ...__privateGet(this, _options).rpc?.headers
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: __privateGet(this, _requestId),
+          method: input.method,
+          params: input.params
+        })
+      }
+    );
+    if (!res.ok) {
+      throw new import_errors.SuiHTTPStatusError(
+        `Unexpected status code: ${res.status}`,
+        res.status,
+        res.statusText
+      );
+    }
+    const data = await res.json();
+    if ("error" in data && data.error != null) {
+      throw new import_errors.JsonRpcError(data.error.message, data.error.code);
+    }
+    return data.result;
+  }
+  async subscribe(input) {
+    const unsubscribe = await __privateMethod(this, _JsonRpcHTTPTransport_instances, getWebsocketClient_fn).call(this).subscribe(input);
+    if (input.signal) {
+      input.signal.throwIfAborted();
+      input.signal.addEventListener("abort", () => {
+        unsubscribe();
+      });
+    }
+    return async () => !!await unsubscribe();
+  }
+}
+_requestId = new WeakMap();
+_options = new WeakMap();
+_websocketClient = new WeakMap();
+_JsonRpcHTTPTransport_instances = new WeakSet();
+getWebsocketClient_fn = function() {
+  if (!__privateGet(this, _websocketClient)) {
+    const WebSocketConstructor = __privateGet(this, _options).WebSocketConstructor ?? WebSocket;
+    if (!WebSocketConstructor) {
+      throw new Error(
+        "The current environment does not support WebSocket, you can provide a WebSocketConstructor in the options for SuiHTTPTransport."
+      );
+    }
+    __privateSet(this, _websocketClient, new import_rpc_websocket_client.WebsocketClient(
+      __privateGet(this, _options).websocket?.url ?? __privateGet(this, _options).url,
+      {
+        WebSocketConstructor,
+        ...__privateGet(this, _options).websocket
+      }
+    ));
+  }
+  return __privateGet(this, _websocketClient);
+};

package/dist/cjs/jsonRpc/index.d.ts

@@ -0,0 +1,4 @@
+export { type JsonRpcTransport, type JsonRpcTransportRequestOptions, type JsonRpcTransportSubscribeOptions, type HttpHeaders, type JsonRpcHTTPTransportOptions, JsonRpcHTTPTransport, } from "./http-transport.js";
+export type * from "./types/index.js";
+export { type SuiJsonRpcClientOptions, type PaginationArguments, type OrderArguments, isSuiJsonRpcClient, SuiJsonRpcClient, } from "./client.js";
+export { SuiHTTPStatusError, SuiHTTPTransportError, JsonRpcError, } from "./errors.js";

package/dist/cjs/jsonRpc/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsonRpc_exports = {};
+__export(jsonRpc_exports, {
+  JsonRpcError: () => import_errors.JsonRpcError,
+  JsonRpcHTTPTransport: () => import_http_transport.JsonRpcHTTPTransport,
+  SuiHTTPStatusError: () => import_errors.SuiHTTPStatusError,
+  SuiHTTPTransportError: () => import_errors.SuiHTTPTransportError,
+  SuiJsonRpcClient: () => import_client.SuiJsonRpcClient,
+  isSuiJsonRpcClient: () => import_client.isSuiJsonRpcClient
+});
+module.exports = __toCommonJS(jsonRpc_exports);
+var import_http_transport = require("./http-transport.js");
+var import_client = require("./client.js");
+var import_errors = require("./errors.js");

package/dist/cjs/jsonRpc/json-rpc-resolver.d.ts

@@ -0,0 +1,4 @@
+import type { TransactionDataBuilder } from "../transactions/TransactionData.js";
+import type { BuildTransactionOptions } from "../transactions/index.js";
+import type { SuiJsonRpcClient } from "./client.js";
+export declare function jsonRpcClientResolveTransactionPlugin(client: SuiJsonRpcClient): (transactionData: TransactionDataBuilder, options: BuildTransactionOptions, next: () => Promise<void>) => Promise<void>;

package/dist/cjs/jsonRpc/json-rpc-resolver.js

@@ -0,0 +1,321 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var json_rpc_resolver_exports = {};
+__export(json_rpc_resolver_exports, {
+  jsonRpcClientResolveTransactionPlugin: () => jsonRpcClientResolveTransactionPlugin
+});
+module.exports = __toCommonJS(json_rpc_resolver_exports);
+var import_valibot = require("valibot");
+var import_utils = require("../utils/index.js");
+var import_internal = require("../transactions/data/internal.js");
+var import_Inputs = require("../transactions/Inputs.js");
+var import_serializer = require("../transactions/serializer.js");
+var import_utils2 = require("@mysten/utils");
+const MAX_OBJECTS_PER_FETCH = 50;
+const GAS_SAFE_OVERHEAD = 1000n;
+const MAX_GAS = 5e10;
+function jsonRpcClientResolveTransactionPlugin(client) {
+  return async function resolveTransactionData(transactionData, options, next) {
+    await normalizeInputs(transactionData, client);
+    await resolveObjectReferences(transactionData, client);
+    if (!options.onlyTransactionKind) {
+      await setGasPrice(transactionData, client);
+      await setGasBudget(transactionData, client);
+      await setGasPayment(transactionData, client);
+    }
+    return await next();
+  };
+}
+async function setGasPrice(transactionData, client) {
+  if (!transactionData.gasConfig.price) {
+    transactionData.gasConfig.price = String(
+      await client.getReferenceGasPrice()
+    );
+  }
+}
+async function setGasBudget(transactionData, client) {
+  if (transactionData.gasConfig.budget) {
+    return;
+  }
+  const dryRunResult = await client.dryRunTransactionBlock({
+    transactionBlock: transactionData.build({
+      overrides: {
+        gasData: {
+          budget: String(MAX_GAS),
+          payment: []
+        }
+      }
+    })
+  });
+  if (dryRunResult.effects.status.status !== "success") {
+    const error = new Error(
+      `Dry run failed, could not automatically determine a budget: ${dryRunResult.effects.status.error}`
+    );
+    error.cause = dryRunResult;
+    throw error;
+  }
+  const safeOverhead = GAS_SAFE_OVERHEAD * BigInt(transactionData.gasConfig.price || 1n);
+  const baseComputationCostWithOverhead = BigInt(dryRunResult.effects.gasUsed.computationCost) + safeOverhead;
+  const gasBudget = baseComputationCostWithOverhead + BigInt(dryRunResult.effects.gasUsed.storageCost) - BigInt(dryRunResult.effects.gasUsed.storageRebate);
+  transactionData.gasConfig.budget = String(
+    gasBudget > baseComputationCostWithOverhead ? gasBudget : baseComputationCostWithOverhead
+  );
+}
+async function setGasPayment(transactionData, client) {
+  if (!transactionData.gasConfig.payment) {
+    const coins = await client.getCoins({
+      owner: transactionData.gasConfig.owner || transactionData.sender,
+      coinType: import_utils.WOW_TYPE_ARG
+    });
+    const paymentCoins = coins.data.filter((coin) => {
+      const matchingInput = transactionData.inputs.find((input) => {
+        if (input.Object?.ImmOrOwnedObject) {
+          return coin.coinObjectId === input.Object.ImmOrOwnedObject.objectId;
+        }
+        return false;
+      });
+      return !matchingInput;
+    }).map((coin) => ({
+      objectId: coin.coinObjectId,
+      digest: coin.digest,
+      version: coin.version
+    }));
+    if (!paymentCoins.length) {
+      throw new Error("No valid gas coins found for the transaction.");
+    }
+    transactionData.gasConfig.payment = paymentCoins.map(
+      (payment) => (0, import_valibot.parse)(import_internal.ObjectRefSchema, payment)
+    );
+  }
+}
+async function resolveObjectReferences(transactionData, client) {
+  const objectsToResolve = transactionData.inputs.filter((input) => {
+    return input.UnresolvedObject && !(input.UnresolvedObject.version || input.UnresolvedObject?.initialSharedVersion);
+  });
+  const dedupedIds = [
+    ...new Set(
+      objectsToResolve.map(
+        (input) => (0, import_utils.normalizeWowObjectId)(input.UnresolvedObject.objectId)
+      )
+    )
+  ];
+  const objectChunks = dedupedIds.length ? (0, import_utils2.chunk)(dedupedIds, MAX_OBJECTS_PER_FETCH) : [];
+  const resolved = (await Promise.all(
+    objectChunks.map(
+      (chunk2) => client.multiGetObjects({
+        ids: chunk2,
+        options: { showOwner: true }
+      })
+    )
+  )).flat();
+  const responsesById = new Map(
+    dedupedIds.map((id, index) => {
+      return [id, resolved[index]];
+    })
+  );
+  const invalidObjects = Array.from(responsesById).filter(([_, obj]) => obj.error).map(([_, obj]) => JSON.stringify(obj.error));
+  if (invalidObjects.length) {
+    throw new Error(
+      `The following input objects are invalid: ${invalidObjects.join(", ")}`
+    );
+  }
+  const objects = resolved.map((object) => {
+    if (object.error || !object.data) {
+      throw new Error(`Failed to fetch object: ${object.error}`);
+    }
+    const owner = object.data.owner;
+    const initialSharedVersion = owner && typeof owner === "object" ? "Shared" in owner ? owner.Shared.initial_shared_version : "ConsensusAddressOwner" in owner ? owner.ConsensusAddressOwner.start_version : null : null;
+    return {
+      objectId: object.data.objectId,
+      digest: object.data.digest,
+      version: object.data.version,
+      initialSharedVersion
+    };
+  });
+  const objectsById = new Map(
+    dedupedIds.map((id, index) => {
+      return [id, objects[index]];
+    })
+  );
+  for (const [index, input] of transactionData.inputs.entries()) {
+    if (!input.UnresolvedObject) {
+      continue;
+    }
+    let updated;
+    const id = (0, import_utils.normalizeWowAddress)(input.UnresolvedObject.objectId);
+    const object = objectsById.get(id);
+    if (input.UnresolvedObject.initialSharedVersion ?? object?.initialSharedVersion) {
+      updated = import_Inputs.Inputs.SharedObjectRef({
+        objectId: id,
+        initialSharedVersion: input.UnresolvedObject.initialSharedVersion || object?.initialSharedVersion,
+        mutable: input.UnresolvedObject.mutable || isUsedAsMutable(transactionData, index)
+      });
+    } else if (isUsedAsReceiving(transactionData, index)) {
+      updated = import_Inputs.Inputs.ReceivingRef(
+        {
+          objectId: id,
+          digest: input.UnresolvedObject.digest ?? object?.digest,
+          version: input.UnresolvedObject.version ?? object?.version
+        }
+      );
+    }
+    transactionData.inputs[transactionData.inputs.indexOf(input)] = updated ?? import_Inputs.Inputs.ObjectRef({
+      objectId: id,
+      digest: input.UnresolvedObject.digest ?? object?.digest,
+      version: input.UnresolvedObject.version ?? object?.version
+    });
+  }
+}
+async function normalizeInputs(transactionData, client) {
+  const { inputs, commands } = transactionData;
+  const moveCallsToResolve = [];
+  const moveFunctionsToResolve = /* @__PURE__ */ new Set();
+  commands.forEach((command) => {
+    if (command.MoveCall) {
+      if (command.MoveCall._argumentTypes) {
+        return;
+      }
+      const inputs2 = command.MoveCall.arguments.map((arg) => {
+        if (arg.$kind === "Input") {
+          return transactionData.inputs[arg.Input];
+        }
+        return null;
+      });
+      const needsResolution = inputs2.some(
+        (input) => input?.UnresolvedPure || input?.UnresolvedObject && typeof input?.UnresolvedObject.mutable !== "boolean"
+      );
+      if (needsResolution) {
+        const functionName = `${command.MoveCall.package}::${command.MoveCall.module}::${command.MoveCall.function}`;
+        moveFunctionsToResolve.add(functionName);
+        moveCallsToResolve.push(command.MoveCall);
+      }
+    }
+  });
+  const moveFunctionParameters = /* @__PURE__ */ new Map();
+  if (moveFunctionsToResolve.size > 0) {
+    await Promise.all(
+      [...moveFunctionsToResolve].map(async (functionName) => {
+        const [packageId, moduleId, functionId] = functionName.split("::");
+        const def = await client.getNormalizedMoveFunction({
+          package: packageId,
+          module: moduleId,
+          function: functionId
+        });
+        moveFunctionParameters.set(
+          functionName,
+          def.parameters.map(
+            (param) => (0, import_serializer.normalizedTypeToMoveTypeSignature)(param)
+          )
+        );
+      })
+    );
+  }
+  if (moveCallsToResolve.length) {
+    await Promise.all(
+      moveCallsToResolve.map(async (moveCall) => {
+        const parameters = moveFunctionParameters.get(
+          `${moveCall.package}::${moveCall.module}::${moveCall.function}`
+        );
+        if (!parameters) {
+          return;
+        }
+        const hasTxContext = parameters.length > 0 && (0, import_serializer.isTxContext)(parameters[parameters.length - 1]);
+        const params = hasTxContext ? parameters.slice(0, parameters.length - 1) : parameters;
+        moveCall._argumentTypes = params;
+      })
+    );
+  }
+  commands.forEach((command) => {
+    if (!command.MoveCall) {
+      return;
+    }
+    const moveCall = command.MoveCall;
+    const fnName = `${moveCall.package}::${moveCall.module}::${moveCall.function}`;
+    const params = moveCall._argumentTypes;
+    if (!params) {
+      return;
+    }
+    if (params.length !== command.MoveCall.arguments.length) {
+      throw new Error(`Incorrect number of arguments for ${fnName}`);
+    }
+    params.forEach((param, i) => {
+      const arg = moveCall.arguments[i];
+      if (arg.$kind !== "Input") return;
+      const input = inputs[arg.Input];
+      if (!input.UnresolvedPure && !input.UnresolvedObject) {
+        return;
+      }
+      const inputValue = input.UnresolvedPure?.value ?? input.UnresolvedObject?.objectId;
+      const schema = (0, import_serializer.getPureBcsSchema)(param.body);
+      if (schema) {
+        arg.type = "pure";
+        inputs[inputs.indexOf(input)] = import_Inputs.Inputs.Pure(
+          schema.serialize(inputValue)
+        );
+        return;
+      }
+      if (typeof inputValue !== "string") {
+        throw new Error(
+          `Expect the argument to be an object id string, got ${JSON.stringify(
+            inputValue,
+            null,
+            2
+          )}`
+        );
+      }
+      arg.type = "object";
+      const unresolvedObject = input.UnresolvedPure ? {
+        $kind: "UnresolvedObject",
+        UnresolvedObject: {
+          objectId: inputValue
+        }
+      } : input;
+      inputs[arg.Input] = unresolvedObject;
+    });
+  });
+}
+function isUsedAsMutable(transactionData, index) {
+  let usedAsMutable = false;
+  transactionData.getInputUses(index, (arg, tx) => {
+    if (tx.MoveCall && tx.MoveCall._argumentTypes) {
+      const argIndex = tx.MoveCall.arguments.indexOf(arg);
+      usedAsMutable = tx.MoveCall._argumentTypes[argIndex].ref !== "&" || usedAsMutable;
+    }
+    if (tx.$kind === "MakeMoveVec" || tx.$kind === "MergeCoins" || tx.$kind === "SplitCoins" || tx.$kind === "TransferObjects") {
+      usedAsMutable = true;
+    }
+  });
+  return usedAsMutable;
+}
+function isUsedAsReceiving(transactionData, index) {
+  let usedAsReceiving = false;
+  transactionData.getInputUses(index, (arg, tx) => {
+    if (tx.MoveCall && tx.MoveCall._argumentTypes) {
+      const argIndex = tx.MoveCall.arguments.indexOf(arg);
+      usedAsReceiving = isReceivingType(tx.MoveCall._argumentTypes[argIndex]) || usedAsReceiving;
+    }
+  });
+  return usedAsReceiving;
+}
+function isReceivingType(type) {
+  if (typeof type.body !== "object" || !("datatype" in type.body)) {
+    return false;
+  }
+  return type.body.datatype.package === "0x2" && type.body.datatype.module === "transfer" && type.body.datatype.type === "Receiving";
+}

package/dist/cjs/jsonRpc/rpc-websocket-client.d.ts

@@ -0,0 +1,43 @@
+type SubscriptionRequest<T = any> = {
+    method: string;
+    unsubscribe: string;
+    params: any[];
+    onMessage: (event: T) => void;
+    signal?: AbortSignal;
+};
+/**
+ * Configuration options for the websocket connection
+ */
+export type WebsocketClientOptions = {
+    /**
+     * Custom WebSocket class to use. Defaults to the global WebSocket class, if available.
+     */
+    WebSocketConstructor?: typeof WebSocket;
+    /**
+     * Milliseconds before timing out while calling an RPC method
+     */
+    callTimeout?: number;
+    /**
+     * Milliseconds between attempts to connect
+     */
+    reconnectTimeout?: number;
+    /**
+     * Maximum number of times to try connecting before giving up
+     */
+    maxReconnects?: number;
+};
+export declare const DEFAULT_CLIENT_OPTIONS: {
+    WebSocketConstructor: typeof WebSocket;
+    callTimeout: number;
+    reconnectTimeout: number;
+    maxReconnects: number;
+};
+export declare class WebsocketClient {
+    #private;
+    endpoint: string;
+    options: Required<WebsocketClientOptions>;
+    constructor(endpoint: string, options?: WebsocketClientOptions);
+    makeRequest<T>(method: string, params: any[], signal?: AbortSignal): Promise<T>;
+    subscribe<T>(input: SubscriptionRequest<T>): Promise<() => Promise<unknown>>;
+}
+export {};