wowok 1.8.2 → 2.1.9

package/dist/cjs/transactions/data/v2.js

@@ -0,0 +1,124 @@
+"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 v2_exports = {};
+__export(v2_exports, {
+  SerializedTransactionDataV2Schema: () => SerializedTransactionDataV2Schema
+});
+module.exports = __toCommonJS(v2_exports);
+var import_valibot = require("valibot");
+var import_internal = require("./internal.js");
+function enumUnion(options) {
+  return (0, import_valibot.union)(
+    Object.entries(options).map(([key, value]) => (0, import_valibot.object)({ [key]: value }))
+  );
+}
+const Argument = enumUnion({
+  GasCoin: (0, import_valibot.literal)(true),
+  Input: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()),
+  Result: (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()),
+  NestedResult: (0, import_valibot.tuple)([(0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)()), (0, import_valibot.pipe)((0, import_valibot.number)(), (0, import_valibot.integer)())])
+});
+const GasData = (0, import_valibot.object)({
+  budget: (0, import_valibot.nullable)(import_internal.JsonU64),
+  price: (0, import_valibot.nullable)(import_internal.JsonU64),
+  owner: (0, import_valibot.nullable)(import_internal.SuiAddress),
+  payment: (0, import_valibot.nullable)((0, import_valibot.array)(import_internal.ObjectRefSchema))
+});
+const ProgrammableMoveCall = (0, import_valibot.object)({
+  package: import_internal.ObjectID,
+  module: (0, import_valibot.string)(),
+  function: (0, import_valibot.string)(),
+  // snake case in rust
+  typeArguments: (0, import_valibot.array)((0, import_valibot.string)()),
+  arguments: (0, import_valibot.array)(Argument)
+});
+const $Intent = (0, import_valibot.object)({
+  name: (0, import_valibot.string)(),
+  inputs: (0, import_valibot.record)((0, import_valibot.string)(), (0, import_valibot.union)([Argument, (0, import_valibot.array)(Argument)])),
+  data: (0, import_valibot.record)((0, import_valibot.string)(), (0, import_valibot.unknown)())
+});
+const Command = enumUnion({
+  MoveCall: ProgrammableMoveCall,
+  TransferObjects: (0, import_valibot.object)({
+    objects: (0, import_valibot.array)(Argument),
+    address: Argument
+  }),
+  SplitCoins: (0, import_valibot.object)({
+    coin: Argument,
+    amounts: (0, import_valibot.array)(Argument)
+  }),
+  MergeCoins: (0, import_valibot.object)({
+    destination: Argument,
+    sources: (0, import_valibot.array)(Argument)
+  }),
+  Publish: (0, import_valibot.object)({
+    modules: (0, import_valibot.array)(import_internal.BCSBytes),
+    dependencies: (0, import_valibot.array)(import_internal.ObjectID)
+  }),
+  MakeMoveVec: (0, import_valibot.object)({
+    type: (0, import_valibot.nullable)((0, import_valibot.string)()),
+    elements: (0, import_valibot.array)(Argument)
+  }),
+  Upgrade: (0, import_valibot.object)({
+    modules: (0, import_valibot.array)(import_internal.BCSBytes),
+    dependencies: (0, import_valibot.array)(import_internal.ObjectID),
+    package: import_internal.ObjectID,
+    ticket: Argument
+  }),
+  $Intent
+});
+const ObjectArg = enumUnion({
+  ImmOrOwnedObject: import_internal.ObjectRefSchema,
+  SharedObject: (0, import_valibot.object)({
+    objectId: import_internal.ObjectID,
+    // snake case in rust
+    initialSharedVersion: import_internal.JsonU64,
+    mutable: (0, import_valibot.boolean)()
+  }),
+  Receiving: import_internal.ObjectRefSchema
+});
+const CallArg = enumUnion({
+  Object: ObjectArg,
+  Pure: (0, import_valibot.object)({
+    bytes: import_internal.BCSBytes
+  }),
+  UnresolvedPure: (0, import_valibot.object)({
+    value: (0, import_valibot.unknown)()
+  }),
+  UnresolvedObject: (0, import_valibot.object)({
+    objectId: import_internal.ObjectID,
+    version: (0, import_valibot.optional)((0, import_valibot.nullable)(import_internal.JsonU64)),
+    digest: (0, import_valibot.optional)((0, import_valibot.nullable)((0, import_valibot.string)())),
+    initialSharedVersion: (0, import_valibot.optional)((0, import_valibot.nullable)(import_internal.JsonU64)),
+    mutable: (0, import_valibot.optional)((0, import_valibot.nullable)((0, import_valibot.boolean)()))
+  })
+});
+const TransactionExpiration = enumUnion({
+  None: (0, import_valibot.literal)(true),
+  Epoch: import_internal.JsonU64
+});
+const SerializedTransactionDataV2Schema = (0, import_valibot.object)({
+  version: (0, import_valibot.literal)(2),
+  sender: (0, import_valibot.nullish)(import_internal.SuiAddress),
+  expiration: (0, import_valibot.nullish)(TransactionExpiration),
+  gasData: GasData,
+  inputs: (0, import_valibot.array)(CallArg),
+  commands: (0, import_valibot.array)(Command),
+  digest: (0, import_valibot.optional)((0, import_valibot.nullable)((0, import_valibot.string)()))
+});

package/dist/cjs/transactions/executor/caching.d.ts

@@ -0,0 +1,31 @@
+import { bcs } from "../../bcs/index.js";
+import type { ExecuteTransactionBlockParams, SuiClient } from "../../client/index.js";
+import type { Signer } from "../../cryptography/keypair.js";
+import type { BuildTransactionOptions } from "../resolve.js";
+import type { ObjectCacheOptions } from "../ObjectCache.js";
+import { ObjectCache } from "../ObjectCache.js";
+import type { Transaction } from "../Transaction.js";
+export declare class CachingTransactionExecutor {
+    #private;
+    cache: ObjectCache;
+    constructor({ client, ...options }: ObjectCacheOptions & {
+        client: SuiClient;
+    });
+    /**
+     * Clears all Owned objects
+     * Immutable objects, Shared objects, and Move function definitions will be preserved
+     */
+    reset(): Promise<void>;
+    buildTransaction({ transaction, ...options }: {
+        transaction: Transaction;
+    } & BuildTransactionOptions): Promise<Uint8Array<ArrayBuffer>>;
+    executeTransaction({ transaction, options, ...input }: {
+        transaction: Transaction | Uint8Array;
+    } & Omit<ExecuteTransactionBlockParams, "transactionBlock">): Promise<import("../../client/index.js").SuiTransactionBlockResponse>;
+    signAndExecuteTransaction({ options, transaction, ...input }: {
+        transaction: Transaction;
+        signer: Signer;
+    } & Omit<ExecuteTransactionBlockParams, "transactionBlock" | "signature">): Promise<import("../../client/index.js").SuiTransactionBlockResponse>;
+    applyEffects(effects: typeof bcs.TransactionEffects.$inferType): Promise<void>;
+    waitForLastTransaction(): Promise<void>;
+}

package/dist/cjs/transactions/executor/caching.js

@@ -0,0 +1,118 @@
+"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 __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 __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 caching_exports = {};
+__export(caching_exports, {
+  CachingTransactionExecutor: () => CachingTransactionExecutor
+});
+module.exports = __toCommonJS(caching_exports);
+var import_bcs = require("../../bcs/index.js");
+var import_ObjectCache = require("../ObjectCache.js");
+var import_Transaction = require("../Transaction.js");
+var _client, _lastDigest;
+class CachingTransactionExecutor {
+  constructor({
+    client,
+    ...options
+  }) {
+    __privateAdd(this, _client);
+    __privateAdd(this, _lastDigest, null);
+    __publicField(this, "cache");
+    __privateSet(this, _client, client);
+    this.cache = new import_ObjectCache.ObjectCache(options);
+  }
+  /**
+   * Clears all Owned objects
+   * Immutable objects, Shared objects, and Move function definitions will be preserved
+   */
+  async reset() {
+    await Promise.all([
+      this.cache.clearOwnedObjects(),
+      this.cache.clearCustom(),
+      this.waitForLastTransaction()
+    ]);
+  }
+  async buildTransaction({
+    transaction,
+    ...options
+  }) {
+    transaction.addBuildPlugin(this.cache.asPlugin());
+    return transaction.build({
+      client: __privateGet(this, _client),
+      ...options
+    });
+  }
+  async executeTransaction({
+    transaction,
+    options,
+    ...input
+  }) {
+    const bytes = (0, import_Transaction.isTransaction)(transaction) ? await this.buildTransaction({ transaction }) : transaction;
+    const results = await __privateGet(this, _client).executeTransactionBlock({
+      ...input,
+      transactionBlock: bytes,
+      options: {
+        ...options,
+        showRawEffects: true
+      }
+    });
+    if (results.rawEffects) {
+      const effects = import_bcs.bcs.TransactionEffects.parse(
+        Uint8Array.from(results.rawEffects)
+      );
+      await this.applyEffects(effects);
+    }
+    return results;
+  }
+  async signAndExecuteTransaction({
+    options,
+    transaction,
+    ...input
+  }) {
+    transaction.setSenderIfNotSet(input.signer.toWAddress());
+    const bytes = await this.buildTransaction({ transaction });
+    const { signature } = await input.signer.signTransaction(bytes);
+    const results = await this.executeTransaction({
+      transaction: bytes,
+      signature,
+      options
+    });
+    return results;
+  }
+  async applyEffects(effects) {
+    __privateSet(this, _lastDigest, effects.V2?.transactionDigest ?? null);
+    await this.cache.applyEffects(effects);
+  }
+  async waitForLastTransaction() {
+    if (__privateGet(this, _lastDigest)) {
+      await __privateGet(this, _client).waitForTransaction({ digest: __privateGet(this, _lastDigest) });
+      __privateSet(this, _lastDigest, null);
+    }
+  }
+}
+_client = new WeakMap();
+_lastDigest = new WeakMap();

package/dist/cjs/transactions/executor/parallel.d.ts

@@ -0,0 +1,37 @@
+import type { SuiClient, SuiTransactionBlockResponse, SuiTransactionBlockResponseOptions } from "../../client/index.js";
+import type { Signer } from "../../cryptography/index.js";
+import type { ObjectCacheOptions } from "../ObjectCache.js";
+import { Transaction } from "../Transaction.js";
+export interface ParallelTransactionExecutorOptions extends Omit<ObjectCacheOptions, "address"> {
+    client: SuiClient;
+    signer: Signer;
+    /** The number of coins to create in a batch when refilling the gas pool */
+    coinBatchSize?: number;
+    /** The initial balance of each coin created for the gas pool */
+    initialCoinBalance?: bigint;
+    /** The minimum balance of a coin that can be reused for future transactions.  If the gasCoin is below this value, it will be used when refilling the gasPool */
+    minimumCoinBalance?: bigint;
+    /** The gasBudget to use if the transaction has not defined it's own gasBudget, defaults to `minimumCoinBalance` */
+    defaultGasBudget?: bigint;
+    /**
+     * Time to wait before/after the expected epoch boundary before re-fetching the gas pool (in milliseconds).
+     * Building transactions will be paused for up to 2x this duration around each epoch boundary to ensure the
+     * gas price is up-to-date for the next epoch.
+     * */
+    epochBoundaryWindow?: number;
+    /** The maximum number of transactions that can be execute in parallel, this also determines the maximum number of gas coins that will be created */
+    maxPoolSize?: number;
+    /** An initial list of coins used to fund the gas pool, uses all owned SUI coins by default */
+    sourceCoins?: string[];
+}
+export declare class ParallelTransactionExecutor {
+    #private;
+    constructor(options: ParallelTransactionExecutorOptions);
+    resetCache(): Promise<void>;
+    waitForLastTransaction(): Promise<void>;
+    executeTransaction(transaction: Transaction, options?: SuiTransactionBlockResponseOptions, additionalSignatures?: string[]): Promise<{
+        digest: string;
+        effects: string;
+        data: SuiTransactionBlockResponse;
+    }>;
+}