wowok 1.8.2 → 2.1.9

package/dist/esm/jsonRpc/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class SuiHTTPTransportError extends Error {
+}
+export declare class JsonRpcError extends SuiHTTPTransportError {
+    code: number;
+    type: string;
+    constructor(message: string, code: number);
+}
+export declare class SuiHTTPStatusError extends SuiHTTPTransportError {
+    status: number;
+    statusText: string;
+    constructor(message: string, status: number, statusText: string);
+}

package/dist/esm/jsonRpc/errors.js

@@ -0,0 +1,46 @@
+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);
+const CODE_TO_ERROR_TYPE = {
+  "-32700": "ParseError",
+  "-32701": "OversizedRequest",
+  "-32702": "OversizedResponse",
+  "-32600": "InvalidRequest",
+  "-32601": "MethodNotFound",
+  "-32602": "InvalidParams",
+  "-32603": "InternalError",
+  "-32604": "ServerBusy",
+  "-32000": "CallExecutionFailed",
+  "-32001": "UnknownError",
+  "-32003": "SubscriptionClosed",
+  "-32004": "SubscriptionClosedWithError",
+  "-32005": "BatchesNotSupported",
+  "-32006": "TooManySubscriptions",
+  "-32050": "TransientError",
+  "-32002": "TransactionExecutionClientError"
+};
+class SuiHTTPTransportError extends Error {
+}
+class JsonRpcError extends SuiHTTPTransportError {
+  constructor(message, code) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "type");
+    this.code = code;
+    this.type = CODE_TO_ERROR_TYPE[code] ?? "ServerError";
+  }
+}
+class SuiHTTPStatusError extends SuiHTTPTransportError {
+  constructor(message, status, statusText) {
+    super(message);
+    __publicField(this, "status");
+    __publicField(this, "statusText");
+    this.status = status;
+    this.statusText = statusText;
+  }
+}
+export {
+  JsonRpcError,
+  SuiHTTPStatusError,
+  SuiHTTPTransportError
+};

package/dist/esm/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/esm/jsonRpc/http-transport.js

@@ -0,0 +1,101 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 _requestId, _options, _websocketClient, _JsonRpcHTTPTransport_instances, getWebsocketClient_fn;
+import { PACKAGE_VERSION, TARGETED_RPC_VERSION } from "../version.js";
+import { JsonRpcError, SuiHTTPStatusError } from "./errors.js";
+import { WebsocketClient } from "./rpc-websocket-client.js";
+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": PACKAGE_VERSION,
+          "Client-Target-Api-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 SuiHTTPStatusError(
+        `Unexpected status code: ${res.status}`,
+        res.status,
+        res.statusText
+      );
+    }
+    const data = await res.json();
+    if ("error" in data && data.error != null) {
+      throw new 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 WebsocketClient(
+      __privateGet(this, _options).websocket?.url ?? __privateGet(this, _options).url,
+      {
+        WebSocketConstructor,
+        ...__privateGet(this, _options).websocket
+      }
+    ));
+  }
+  return __privateGet(this, _websocketClient);
+};
+export {
+  JsonRpcHTTPTransport
+};

package/dist/esm/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/esm/jsonRpc/index.js

@@ -0,0 +1,20 @@
+import {
+  JsonRpcHTTPTransport
+} from "./http-transport.js";
+import {
+  isSuiJsonRpcClient,
+  SuiJsonRpcClient
+} from "./client.js";
+import {
+  SuiHTTPStatusError,
+  SuiHTTPTransportError,
+  JsonRpcError
+} from "./errors.js";
+export {
+  JsonRpcError,
+  JsonRpcHTTPTransport,
+  SuiHTTPStatusError,
+  SuiHTTPTransportError,
+  SuiJsonRpcClient,
+  isSuiJsonRpcClient
+};

package/dist/esm/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/esm/jsonRpc/json-rpc-resolver.js

@@ -0,0 +1,309 @@
+import { parse } from "valibot";
+import {
+  normalizeWowAddress,
+  normalizeWowObjectId,
+  WOW_TYPE_ARG
+} from "../utils/index.js";
+import { ObjectRefSchema } from "../transactions/data/internal.js";
+import { Inputs } from "../transactions/Inputs.js";
+import {
+  getPureBcsSchema,
+  isTxContext,
+  normalizedTypeToMoveTypeSignature
+} from "../transactions/serializer.js";
+import { chunk } from "@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: 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) => parse(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) => normalizeWowObjectId(input.UnresolvedObject.objectId)
+      )
+    )
+  ];
+  const objectChunks = dedupedIds.length ? 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 = normalizeWowAddress(input.UnresolvedObject.objectId);
+    const object = objectsById.get(id);
+    if (input.UnresolvedObject.initialSharedVersion ?? object?.initialSharedVersion) {
+      updated = Inputs.SharedObjectRef({
+        objectId: id,
+        initialSharedVersion: input.UnresolvedObject.initialSharedVersion || object?.initialSharedVersion,
+        mutable: input.UnresolvedObject.mutable || isUsedAsMutable(transactionData, index)
+      });
+    } else if (isUsedAsReceiving(transactionData, index)) {
+      updated = Inputs.ReceivingRef(
+        {
+          objectId: id,
+          digest: input.UnresolvedObject.digest ?? object?.digest,
+          version: input.UnresolvedObject.version ?? object?.version
+        }
+      );
+    }
+    transactionData.inputs[transactionData.inputs.indexOf(input)] = updated ?? 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) => 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 && 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 = getPureBcsSchema(param.body);
+      if (schema) {
+        arg.type = "pure";
+        inputs[inputs.indexOf(input)] = 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";
+}
+export {
+  jsonRpcClientResolveTransactionPlugin
+};

package/dist/esm/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 {};