wowok 1.8.2 → 2.1.9

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

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

package/dist/esm/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/esm/transactions/executor/caching.js

@@ -0,0 +1,99 @@
+var __defProp = Object.defineProperty;
+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 __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 _client, _lastDigest;
+import { bcs } from "../../bcs/index.js";
+import { ObjectCache } from "../ObjectCache.js";
+import { isTransaction } from "../Transaction.js";
+class CachingTransactionExecutor {
+  constructor({
+    client,
+    ...options
+  }) {
+    __privateAdd(this, _client);
+    __privateAdd(this, _lastDigest, null);
+    __publicField(this, "cache");
+    __privateSet(this, _client, client);
+    this.cache = new 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 = 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 = 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();
+export {
+  CachingTransactionExecutor
+};

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

package/dist/esm/transactions/executor/parallel.js

@@ -0,0 +1,375 @@
+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 __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _signer, _client, _coinBatchSize, _initialCoinBalance, _minimumCoinBalance, _epochBoundaryWindow, _defaultGasBudget, _maxPoolSize, _sourceCoins, _coinPool, _cache, _objectIdQueues, _buildQueue, _executeQueue, _lastDigest, _cacheLock, _pendingTransactions, _gasPrice, _ParallelTransactionExecutor_instances, getUsedObjects_fn, execute_fn, updateCache_fn, waitForLastDigest_fn, getGasCoin_fn, getGasPrice_fn, refillCoinPool_fn;
+import { toBase64 } from "@mysten/bcs";
+import { promiseWithResolvers } from "@mysten/utils";
+import { bcs } from "../../bcs/index.js";
+import { Transaction } from "../Transaction.js";
+import { TransactionDataBuilder } from "../TransactionData.js";
+import { CachingTransactionExecutor } from "./caching.js";
+import { ParallelQueue, SerialQueue } from "./queue.js";
+import { getGasCoinFromEffects } from "./serial.js";
+const PARALLEL_EXECUTOR_DEFAULTS = {
+  coinBatchSize: 20,
+  initialCoinBalance: 200000000n,
+  minimumCoinBalance: 50000000n,
+  maxPoolSize: 50,
+  epochBoundaryWindow: 1e3
+};
+class ParallelTransactionExecutor {
+  constructor(options) {
+    __privateAdd(this, _ParallelTransactionExecutor_instances);
+    __privateAdd(this, _signer);
+    __privateAdd(this, _client);
+    __privateAdd(this, _coinBatchSize);
+    __privateAdd(this, _initialCoinBalance);
+    __privateAdd(this, _minimumCoinBalance);
+    __privateAdd(this, _epochBoundaryWindow);
+    __privateAdd(this, _defaultGasBudget);
+    __privateAdd(this, _maxPoolSize);
+    __privateAdd(this, _sourceCoins);
+    __privateAdd(this, _coinPool, []);
+    __privateAdd(this, _cache);
+    __privateAdd(this, _objectIdQueues, /* @__PURE__ */ new Map());
+    __privateAdd(this, _buildQueue, new SerialQueue());
+    __privateAdd(this, _executeQueue);
+    __privateAdd(this, _lastDigest, null);
+    __privateAdd(this, _cacheLock, null);
+    __privateAdd(this, _pendingTransactions, 0);
+    __privateAdd(this, _gasPrice, null);
+    __privateSet(this, _signer, options.signer);
+    __privateSet(this, _client, options.client);
+    __privateSet(this, _coinBatchSize, options.coinBatchSize ?? PARALLEL_EXECUTOR_DEFAULTS.coinBatchSize);
+    __privateSet(this, _initialCoinBalance, options.initialCoinBalance ?? PARALLEL_EXECUTOR_DEFAULTS.initialCoinBalance);
+    __privateSet(this, _minimumCoinBalance, options.minimumCoinBalance ?? PARALLEL_EXECUTOR_DEFAULTS.minimumCoinBalance);
+    __privateSet(this, _defaultGasBudget, options.defaultGasBudget ?? __privateGet(this, _minimumCoinBalance));
+    __privateSet(this, _epochBoundaryWindow, options.epochBoundaryWindow ?? PARALLEL_EXECUTOR_DEFAULTS.epochBoundaryWindow);
+    __privateSet(this, _maxPoolSize, options.maxPoolSize ?? PARALLEL_EXECUTOR_DEFAULTS.maxPoolSize);
+    __privateSet(this, _cache, new CachingTransactionExecutor({
+      client: options.client,
+      cache: options.cache
+    }));
+    __privateSet(this, _executeQueue, new ParallelQueue(__privateGet(this, _maxPoolSize)));
+    __privateSet(this, _sourceCoins, options.sourceCoins ? new Map(options.sourceCoins.map((id) => [id, null])) : null);
+  }
+  resetCache() {
+    __privateSet(this, _gasPrice, null);
+    return __privateMethod(this, _ParallelTransactionExecutor_instances, updateCache_fn).call(this, () => __privateGet(this, _cache).reset());
+  }
+  async waitForLastTransaction() {
+    await __privateMethod(this, _ParallelTransactionExecutor_instances, updateCache_fn).call(this, () => __privateMethod(this, _ParallelTransactionExecutor_instances, waitForLastDigest_fn).call(this));
+  }
+  async executeTransaction(transaction, options, additionalSignatures = []) {
+    const { promise, resolve, reject } = promiseWithResolvers();
+    const usedObjects = await __privateMethod(this, _ParallelTransactionExecutor_instances, getUsedObjects_fn).call(this, transaction);
+    const execute = () => {
+      __privateGet(this, _executeQueue).runTask(() => {
+        const promise2 = __privateMethod(this, _ParallelTransactionExecutor_instances, execute_fn).call(this, transaction, usedObjects, options, additionalSignatures);
+        return promise2.then(resolve, reject);
+      });
+    };
+    const conflicts = /* @__PURE__ */ new Set();
+    usedObjects.forEach((objectId) => {
+      const queue = __privateGet(this, _objectIdQueues).get(objectId);
+      if (queue) {
+        conflicts.add(objectId);
+        __privateGet(this, _objectIdQueues).get(objectId).push(() => {
+          conflicts.delete(objectId);
+          if (conflicts.size === 0) {
+            execute();
+          }
+        });
+      } else {
+        __privateGet(this, _objectIdQueues).set(objectId, []);
+      }
+    });
+    if (conflicts.size === 0) {
+      execute();
+    }
+    return promise;
+  }
+}
+_signer = new WeakMap();
+_client = new WeakMap();
+_coinBatchSize = new WeakMap();
+_initialCoinBalance = new WeakMap();
+_minimumCoinBalance = new WeakMap();
+_epochBoundaryWindow = new WeakMap();
+_defaultGasBudget = new WeakMap();
+_maxPoolSize = new WeakMap();
+_sourceCoins = new WeakMap();
+_coinPool = new WeakMap();
+_cache = new WeakMap();
+_objectIdQueues = new WeakMap();
+_buildQueue = new WeakMap();
+_executeQueue = new WeakMap();
+_lastDigest = new WeakMap();
+_cacheLock = new WeakMap();
+_pendingTransactions = new WeakMap();
+_gasPrice = new WeakMap();
+_ParallelTransactionExecutor_instances = new WeakSet();
+getUsedObjects_fn = async function(transaction) {
+  const usedObjects = /* @__PURE__ */ new Set();
+  let serialized = false;
+  transaction.addSerializationPlugin(
+    async (blockData, _options, next) => {
+      await next();
+      if (serialized) {
+        return;
+      }
+      serialized = true;
+      blockData.inputs.forEach((input) => {
+        if (input.Object?.ImmOrOwnedObject?.objectId) {
+          usedObjects.add(input.Object.ImmOrOwnedObject.objectId);
+        } else if (input.Object?.Receiving?.objectId) {
+          usedObjects.add(input.Object.Receiving.objectId);
+        } else if (input.UnresolvedObject?.objectId && !input.UnresolvedObject.initialSharedVersion) {
+          usedObjects.add(input.UnresolvedObject.objectId);
+        }
+      });
+    }
+  );
+  await transaction.prepareForSerialization({ client: __privateGet(this, _client) });
+  return usedObjects;
+};
+execute_fn = async function(transaction, usedObjects, options, additionalSignatures = []) {
+  let gasCoin;
+  try {
+    transaction.setSenderIfNotSet(__privateGet(this, _signer).toWAddress());
+    await __privateGet(this, _buildQueue).runTask(async () => {
+      const data = transaction.getData();
+      if (!data.gasData.price) {
+        transaction.setGasPrice(await __privateMethod(this, _ParallelTransactionExecutor_instances, getGasPrice_fn).call(this));
+      }
+      transaction.setGasBudgetIfNotSet(__privateGet(this, _defaultGasBudget));
+      await __privateMethod(this, _ParallelTransactionExecutor_instances, updateCache_fn).call(this);
+      gasCoin = await __privateMethod(this, _ParallelTransactionExecutor_instances, getGasCoin_fn).call(this);
+      __privateWrapper(this, _pendingTransactions)._++;
+      transaction.setGasPayment([
+        {
+          objectId: gasCoin.id,
+          version: gasCoin.version,
+          digest: gasCoin.digest
+        }
+      ]);
+      await __privateGet(this, _cache).buildTransaction({
+        transaction,
+        onlyTransactionKind: true
+      });
+    });
+    const bytes = await transaction.build({ client: __privateGet(this, _client) });
+    const { signature } = await __privateGet(this, _signer).signTransaction(bytes);
+    const results = await __privateGet(this, _cache).executeTransaction({
+      transaction: bytes,
+      signature: [signature, ...additionalSignatures],
+      options: {
+        ...options,
+        showEffects: true
+      }
+    });
+    const effectsBytes = Uint8Array.from(results.rawEffects);
+    const effects = bcs.TransactionEffects.parse(effectsBytes);
+    const gasResult = getGasCoinFromEffects(effects);
+    const gasUsed = effects.V2?.gasUsed;
+    if (gasCoin && gasUsed && gasResult.owner === __privateGet(this, _signer).toWAddress()) {
+      const totalUsed = BigInt(gasUsed.computationCost) + BigInt(gasUsed.storageCost) + BigInt(gasUsed.storageCost) - BigInt(gasUsed.storageRebate);
+      const remainingBalance = gasCoin.balance - totalUsed;
+      let usesGasCoin = false;
+      new TransactionDataBuilder(transaction.getData()).mapArguments(
+        (arg) => {
+          if (arg.$kind === "GasCoin") {
+            usesGasCoin = true;
+          }
+          return arg;
+        }
+      );
+      if (!usesGasCoin && remainingBalance >= __privateGet(this, _minimumCoinBalance)) {
+        __privateGet(this, _coinPool).push({
+          id: gasResult.ref.objectId,
+          version: gasResult.ref.version,
+          digest: gasResult.ref.digest,
+          balance: remainingBalance
+        });
+      } else {
+        if (!__privateGet(this, _sourceCoins)) {
+          __privateSet(this, _sourceCoins, /* @__PURE__ */ new Map());
+        }
+        __privateGet(this, _sourceCoins).set(
+          gasResult.ref.objectId,
+          gasResult.ref
+        );
+      }
+    }
+    __privateSet(this, _lastDigest, results.digest);
+    return {
+      digest: results.digest,
+      effects: toBase64(effectsBytes),
+      data: results
+    };
+  } catch (error) {
+    if (gasCoin) {
+      if (!__privateGet(this, _sourceCoins)) {
+        __privateSet(this, _sourceCoins, /* @__PURE__ */ new Map());
+      }
+      __privateGet(this, _sourceCoins).set(gasCoin.id, null);
+    }
+    await __privateMethod(this, _ParallelTransactionExecutor_instances, updateCache_fn).call(this, async () => {
+      await Promise.all([
+        __privateGet(this, _cache).cache.deleteObjects([...usedObjects]),
+        __privateMethod(this, _ParallelTransactionExecutor_instances, waitForLastDigest_fn).call(this)
+      ]);
+    });
+    throw error;
+  } finally {
+    usedObjects.forEach((objectId) => {
+      const queue = __privateGet(this, _objectIdQueues).get(objectId);
+      if (queue && queue.length > 0) {
+        queue.shift()();
+      } else if (queue) {
+        __privateGet(this, _objectIdQueues).delete(objectId);
+      }
+    });
+    __privateWrapper(this, _pendingTransactions)._--;
+  }
+};
+updateCache_fn = async function(fn) {
+  if (__privateGet(this, _cacheLock)) {
+    await __privateGet(this, _cacheLock);
+  }
+  __privateSet(this, _cacheLock, fn?.().then(
+    () => {
+      __privateSet(this, _cacheLock, null);
+    },
+    () => {
+    }
+  ) ?? null);
+};
+waitForLastDigest_fn = async function() {
+  const digest = __privateGet(this, _lastDigest);
+  if (digest) {
+    __privateSet(this, _lastDigest, null);
+    await __privateGet(this, _client).waitForTransaction({ digest });
+  }
+};
+getGasCoin_fn = async function() {
+  if (__privateGet(this, _coinPool).length === 0 && __privateGet(this, _pendingTransactions) <= __privateGet(this, _maxPoolSize)) {
+    await __privateMethod(this, _ParallelTransactionExecutor_instances, refillCoinPool_fn).call(this);
+  }
+  if (__privateGet(this, _coinPool).length === 0) {
+    throw new Error("No coins available");
+  }
+  const coin = __privateGet(this, _coinPool).shift();
+  return coin;
+};
+getGasPrice_fn = async function() {
+  const remaining = __privateGet(this, _gasPrice) ? __privateGet(this, _gasPrice).expiration - __privateGet(this, _epochBoundaryWindow) - Date.now() : 0;
+  if (remaining > 0) {
+    return __privateGet(this, _gasPrice).price;
+  }
+  if (__privateGet(this, _gasPrice)) {
+    const timeToNextEpoch = Math.max(
+      __privateGet(this, _gasPrice).expiration + __privateGet(this, _epochBoundaryWindow) - Date.now(),
+      1e3
+    );
+    await new Promise(
+      (resolve) => setTimeout(resolve, timeToNextEpoch)
+    );
+  }
+  const state = await __privateGet(this, _client).getLatestSuiSystemState();
+  __privateSet(this, _gasPrice, {
+    price: BigInt(state.referenceGasPrice),
+    expiration: Number.parseInt(state.epochStartTimestampMs, 10) + Number.parseInt(state.epochDurationMs, 10)
+  });
+  return __privateMethod(this, _ParallelTransactionExecutor_instances, getGasPrice_fn).call(this);
+};
+refillCoinPool_fn = async function() {
+  const batchSize = Math.min(
+    __privateGet(this, _coinBatchSize),
+    __privateGet(this, _maxPoolSize) - (__privateGet(this, _coinPool).length + __privateGet(this, _pendingTransactions)) + 1
+  );
+  if (batchSize === 0) {
+    return;
+  }
+  const txb = new Transaction();
+  const address = __privateGet(this, _signer).toWAddress();
+  txb.setSender(address);
+  if (__privateGet(this, _sourceCoins)) {
+    const refs = [];
+    const ids = [];
+    for (const [id, ref] of __privateGet(this, _sourceCoins)) {
+      if (ref) {
+        refs.push(ref);
+      } else {
+        ids.push(id);
+      }
+    }
+    if (ids.length > 0) {
+      const coins = await __privateGet(this, _client).multiGetObjects({
+        ids
+      });
+      refs.push(
+        ...coins.filter(
+          (coin) => coin.data !== null
+        ).map(({ data }) => ({
+          objectId: data.objectId,
+          version: data.version,
+          digest: data.digest
+        }))
+      );
+    }
+    txb.setGasPayment(refs);
+    __privateSet(this, _sourceCoins, /* @__PURE__ */ new Map());
+  }
+  const amounts = new Array(batchSize).fill(__privateGet(this, _initialCoinBalance));
+  const results = txb.splitCoins(txb.gas, amounts);
+  const coinResults = [];
+  for (let i = 0; i < amounts.length; i++) {
+    coinResults.push(results[i]);
+  }
+  txb.transferObjects(coinResults, address);
+  await this.waitForLastTransaction();
+  const result = await __privateGet(this, _client).signAndExecuteTransaction({
+    transaction: txb,
+    signer: __privateGet(this, _signer),
+    options: {
+      showRawEffects: true
+    }
+  });
+  const effects = bcs.TransactionEffects.parse(
+    Uint8Array.from(result.rawEffects)
+  );
+  effects.V2?.changedObjects.forEach(([id, { outputState }], i) => {
+    if (i === effects.V2?.gasObjectIndex || !outputState.ObjectWrite) {
+      return;
+    }
+    __privateGet(this, _coinPool).push({
+      id,
+      version: effects.V2.lamportVersion,
+      digest: outputState.ObjectWrite[0],
+      balance: BigInt(__privateGet(this, _initialCoinBalance))
+    });
+  });
+  if (!__privateGet(this, _sourceCoins)) {
+    __privateSet(this, _sourceCoins, /* @__PURE__ */ new Map());
+  }
+  const gasObject = getGasCoinFromEffects(effects).ref;
+  __privateGet(this, _sourceCoins).set(gasObject.objectId, gasObject);
+  await __privateGet(this, _client).waitForTransaction({ digest: result.digest });
+};
+export {
+  ParallelTransactionExecutor
+};

package/dist/esm/transactions/executor/queue.d.ts

@@ -0,0 +1,11 @@
+export declare class SerialQueue {
+    #private;
+    runTask<T>(task: () => Promise<T>): Promise<T>;
+}
+export declare class ParallelQueue {
+    #private;
+    activeTasks: number;
+    maxTasks: number;
+    constructor(maxTasks: number);
+    runTask<T>(task: () => Promise<T>): Promise<T>;
+}