@haneullabs/haneul 0.1.0

package/dist/esm/transactions/data/v2.d.ts

@@ -0,0 +1,153 @@
+import type { EnumInputShape } from '@haneullabs/bcs';
+import type { GenericSchema, InferOutput } from 'valibot';
+export declare const SerializedTransactionDataV2Schema: import("valibot").ObjectSchema<{
+    readonly version: import("valibot").LiteralSchema<2, undefined>;
+    readonly sender: import("valibot").NullishSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TransformAction<string, string>, import("valibot").CheckAction<string, undefined>]>, undefined>;
+    readonly expiration: import("valibot").NullishSchema<GenericSchema<EnumInputShape<{
+        None: true;
+        Epoch: string | number;
+    }>>, undefined>;
+    readonly gasData: import("valibot").ObjectSchema<{
+        readonly budget: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>], undefined>, import("valibot").CheckAction<string | number, "Invalid u64">]>, undefined>;
+        readonly price: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>], undefined>, import("valibot").CheckAction<string | number, "Invalid u64">]>, undefined>;
+        readonly owner: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TransformAction<string, string>, import("valibot").CheckAction<string, undefined>]>, undefined>;
+        readonly payment: import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly objectId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TransformAction<string, string>, import("valibot").CheckAction<string, undefined>]>;
+            readonly version: import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>], undefined>, import("valibot").CheckAction<string | number, "Invalid u64">]>;
+            readonly digest: import("valibot").StringSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
+    }, undefined>;
+    readonly inputs: import("valibot").ArraySchema<GenericSchema<EnumInputShape<{
+        Object: EnumInputShape<{
+            ImmOrOwnedObject: {
+                objectId: string;
+                version: string | number;
+                digest: string;
+            };
+            SharedObject: {
+                objectId: string;
+                initialSharedVersion: string | number;
+                mutable: boolean;
+            };
+            Receiving: {
+                objectId: string;
+                version: string | number;
+                digest: string;
+            };
+        }>;
+        Pure: {
+            bytes: string;
+        };
+        UnresolvedPure: {
+            value: unknown;
+        };
+        UnresolvedObject: {
+            objectId: string;
+            version?: string | number | null | undefined;
+            digest?: string | null | undefined;
+            initialSharedVersion?: string | number | null | undefined;
+            mutable?: boolean | null | undefined;
+        };
+    }>>, undefined>;
+    readonly commands: import("valibot").ArraySchema<GenericSchema<EnumInputShape<{
+        MoveCall: {
+            package: string;
+            module: string;
+            function: string;
+            typeArguments: string[];
+            arguments: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>[];
+        };
+        TransferObjects: {
+            objects: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>[];
+            address: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>;
+        };
+        SplitCoins: {
+            coin: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>;
+            amounts: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>[];
+        };
+        MergeCoins: {
+            destination: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>;
+            sources: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>[];
+        };
+        Publish: {
+            modules: string[];
+            dependencies: string[];
+        };
+        MakeMoveVec: {
+            type: string | null;
+            elements: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>[];
+        };
+        Upgrade: {
+            modules: string[];
+            dependencies: string[];
+            package: string;
+            ticket: EnumInputShape<{
+                GasCoin: true;
+                Input: number;
+                Result: number;
+                NestedResult: [number, number];
+            }>;
+        };
+        $Intent: {
+            name: string;
+            inputs: {
+                [x: string]: EnumInputShape<{
+                    GasCoin: true;
+                    Input: number;
+                    Result: number;
+                    NestedResult: [number, number];
+                }> | EnumInputShape<{
+                    GasCoin: true;
+                    Input: number;
+                    Result: number;
+                    NestedResult: [number, number];
+                }>[];
+            };
+            data: {
+                [x: string]: unknown;
+            };
+        };
+    }>>, undefined>;
+    readonly digest: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+export type SerializedTransactionDataV2 = InferOutput<typeof SerializedTransactionDataV2Schema>;

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

@@ -0,0 +1,121 @@
+import {
+  array,
+  boolean,
+  integer,
+  literal,
+  nullable,
+  nullish,
+  number,
+  object,
+  optional,
+  pipe,
+  record,
+  string,
+  tuple,
+  union,
+  unknown
+} from "valibot";
+import { BCSBytes, JsonU64, ObjectID, ObjectRefSchema, HaneulAddress } 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(HaneulAddress),
+  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(HaneulAddress),
+  expiration: nullish(TransactionExpiration),
+  gasData: GasData,
+  inputs: array(CallArg),
+  commands: array(Command),
+  digest: optional(nullable(string()))
+});
+export {
+  SerializedTransactionDataV2Schema
+};
+//# sourceMappingURL=v2.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/transactions/data/v2.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { EnumInputShape } from '@haneullabs/bcs';\nimport type { GenericSchema, InferInput, InferOutput } from 'valibot';\nimport {\n\tarray,\n\tboolean,\n\tinteger,\n\tliteral,\n\tnullable,\n\tnullish,\n\tnumber,\n\tobject,\n\toptional,\n\tpipe,\n\trecord,\n\tstring,\n\ttuple,\n\tunion,\n\tunknown,\n} from 'valibot';\n\nimport { BCSBytes, JsonU64, ObjectID, ObjectRefSchema, HaneulAddress } from './internal.js';\nimport type { Simplify } from '@haneullabs/utils';\n\nfunction enumUnion<T extends Record<string, GenericSchema<any>>>(options: T) {\n\treturn union(\n\t\tObject.entries(options).map(([key, value]) => object({ [key]: value })),\n\t) as GenericSchema<\n\t\tEnumInputShape<\n\t\t\tSimplify<{\n\t\t\t\t[K in keyof T]: InferInput<T[K]>;\n\t\t\t}>\n\t\t>\n\t>;\n}\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L690-L702\nconst Argument = enumUnion({\n\tGasCoin: literal(true),\n\tInput: pipe(number(), integer()),\n\tResult: pipe(number(), integer()),\n\tNestedResult: tuple([pipe(number(), integer()), pipe(number(), integer())]),\n});\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L1387-L1392\nconst GasData = object({\n\tbudget: nullable(JsonU64),\n\tprice: nullable(JsonU64),\n\towner: nullable(HaneulAddress),\n\tpayment: nullable(array(ObjectRefSchema)),\n});\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L707-L718\nconst ProgrammableMoveCall = object({\n\tpackage: ObjectID,\n\tmodule: string(),\n\tfunction: string(),\n\t// snake case in rust\n\ttypeArguments: array(string()),\n\targuments: array(Argument),\n});\n\nconst $Intent = object({\n\tname: string(),\n\tinputs: record(string(), union([Argument, array(Argument)])),\n\tdata: record(string(), unknown()),\n});\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L657-L685\nconst Command = enumUnion({\n\tMoveCall: ProgrammableMoveCall,\n\tTransferObjects: object({\n\t\tobjects: array(Argument),\n\t\taddress: Argument,\n\t}),\n\tSplitCoins: object({\n\t\tcoin: Argument,\n\t\tamounts: array(Argument),\n\t}),\n\tMergeCoins: object({\n\t\tdestination: Argument,\n\t\tsources: array(Argument),\n\t}),\n\tPublish: object({\n\t\tmodules: array(BCSBytes),\n\t\tdependencies: array(ObjectID),\n\t}),\n\tMakeMoveVec: object({\n\t\ttype: nullable(string()),\n\t\telements: array(Argument),\n\t}),\n\tUpgrade: object({\n\t\tmodules: array(BCSBytes),\n\t\tdependencies: array(ObjectID),\n\t\tpackage: ObjectID,\n\t\tticket: Argument,\n\t}),\n\t$Intent,\n});\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L102-L114\nconst ObjectArg = enumUnion({\n\tImmOrOwnedObject: ObjectRefSchema,\n\tSharedObject: object({\n\t\tobjectId: ObjectID,\n\t\t// snake case in rust\n\t\tinitialSharedVersion: JsonU64,\n\t\tmutable: boolean(),\n\t}),\n\tReceiving: ObjectRefSchema,\n});\n\n// https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L75-L80\nconst CallArg = enumUnion({\n\tObject: ObjectArg,\n\tPure: object({\n\t\tbytes: BCSBytes,\n\t}),\n\tUnresolvedPure: object({\n\t\tvalue: unknown(),\n\t}),\n\tUnresolvedObject: object({\n\t\tobjectId: ObjectID,\n\t\tversion: optional(nullable(JsonU64)),\n\t\tdigest: optional(nullable(string())),\n\t\tinitialSharedVersion: optional(nullable(JsonU64)),\n\t\tmutable: optional(nullable(boolean())),\n\t}),\n});\n\nconst TransactionExpiration = enumUnion({\n\tNone: literal(true),\n\tEpoch: JsonU64,\n});\n\nexport const SerializedTransactionDataV2Schema = object({\n\tversion: literal(2),\n\tsender: nullish(HaneulAddress),\n\texpiration: nullish(TransactionExpiration),\n\tgasData: GasData,\n\tinputs: array(CallArg),\n\tcommands: array(Command),\n\tdigest: optional(nullable(string())),\n});\n\nexport type SerializedTransactionDataV2 = InferOutput<typeof SerializedTransactionDataV2Schema>;\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,31 @@
+import { bcs } from '../../bcs/index.js';
+import type { ExecuteTransactionBlockParams, HaneulClient } 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: HaneulClient;
+    });
+    /**
+     * 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").HaneulTransactionBlockResponse>;
+    signAndExecuteTransaction({ options, transaction, ...input }: {
+        transaction: Transaction;
+        signer: Signer;
+    } & Omit<ExecuteTransactionBlockParams, 'transactionBlock' | 'signature'>): Promise<import("../../client/index.js").HaneulTransactionBlockResponse>;
+    applyEffects(effects: typeof bcs.TransactionEffects.$inferType): Promise<void>;
+    waitForLastTransaction(): Promise<void>;
+}

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

@@ -0,0 +1,94 @@
+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 _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);
+    __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.toHaneulAddress());
+    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
+};
+//# sourceMappingURL=caching.js.map

package/dist/esm/transactions/executor/caching.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/transactions/executor/caching.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bcs } from '../../bcs/index.js';\nimport type { ExecuteTransactionBlockParams, HaneulClient } from '../../client/index.js';\nimport type { Signer } from '../../cryptography/keypair.js';\nimport type { BuildTransactionOptions } from '../resolve.js';\nimport type { ObjectCacheOptions } from '../ObjectCache.js';\nimport { ObjectCache } from '../ObjectCache.js';\nimport type { Transaction } from '../Transaction.js';\nimport { isTransaction } from '../Transaction.js';\n\nexport class CachingTransactionExecutor {\n\t#client: HaneulClient;\n\t#lastDigest: string | null = null;\n\tcache: ObjectCache;\n\n\tconstructor({\n\t\tclient,\n\t\t...options\n\t}: ObjectCacheOptions & {\n\t\tclient: HaneulClient;\n\t}) {\n\t\tthis.#client = client;\n\t\tthis.cache = new ObjectCache(options);\n\t}\n\n\t/**\n\t * Clears all Owned objects\n\t * Immutable objects, Shared objects, and Move function definitions will be preserved\n\t */\n\tasync reset() {\n\t\tawait Promise.all([\n\t\t\tthis.cache.clearOwnedObjects(),\n\t\t\tthis.cache.clearCustom(),\n\t\t\tthis.waitForLastTransaction(),\n\t\t]);\n\t}\n\n\tasync buildTransaction({\n\t\ttransaction,\n\t\t...options\n\t}: { transaction: Transaction } & BuildTransactionOptions) {\n\t\ttransaction.addBuildPlugin(this.cache.asPlugin());\n\t\treturn transaction.build({\n\t\t\tclient: this.#client,\n\t\t\t...options,\n\t\t});\n\t}\n\n\tasync executeTransaction({\n\t\ttransaction,\n\t\toptions,\n\t\t...input\n\t}: {\n\t\ttransaction: Transaction | Uint8Array;\n\t} & Omit<ExecuteTransactionBlockParams, 'transactionBlock'>) {\n\t\tconst bytes = isTransaction(transaction)\n\t\t\t? await this.buildTransaction({ transaction })\n\t\t\t: transaction;\n\n\t\tconst results = await this.#client.executeTransactionBlock({\n\t\t\t...input,\n\t\t\ttransactionBlock: bytes,\n\t\t\toptions: {\n\t\t\t\t...options,\n\t\t\t\tshowRawEffects: true,\n\t\t\t},\n\t\t});\n\n\t\tif (results.rawEffects) {\n\t\t\tconst effects = bcs.TransactionEffects.parse(Uint8Array.from(results.rawEffects));\n\t\t\tawait this.applyEffects(effects);\n\t\t}\n\n\t\treturn results;\n\t}\n\n\tasync signAndExecuteTransaction({\n\t\toptions,\n\t\ttransaction,\n\t\t...input\n\t}: {\n\t\ttransaction: Transaction;\n\n\t\tsigner: Signer;\n\t} & Omit<ExecuteTransactionBlockParams, 'transactionBlock' | 'signature'>) {\n\t\ttransaction.setSenderIfNotSet(input.signer.toHaneulAddress());\n\t\tconst bytes = await this.buildTransaction({ transaction });\n\t\tconst { signature } = await input.signer.signTransaction(bytes);\n\t\tconst results = await this.executeTransaction({\n\t\t\ttransaction: bytes,\n\t\t\tsignature,\n\t\t\toptions,\n\t\t});\n\n\t\treturn results;\n\t}\n\n\tasync applyEffects(effects: typeof bcs.TransactionEffects.$inferType) {\n\t\tthis.#lastDigest = effects.V2?.transactionDigest ?? null;\n\t\tawait this.cache.applyEffects(effects);\n\t}\n\n\tasync waitForLastTransaction() {\n\t\tif (this.#lastDigest) {\n\t\t\tawait this.#client.waitForTransaction({ digest: this.#lastDigest });\n\t\t\tthis.#lastDigest = null;\n\t\t}\n\t}\n}\n"],
+  "mappings": ";;;;;;;AAAA;AAGA,SAAS,WAAW;AAKpB,SAAS,mBAAmB;AAE5B,SAAS,qBAAqB;AAEvB,MAAM,2BAA2B;AAAA,EAKvC,YAAY;AAAA,IACX;AAAA,IACA,GAAG;AAAA,EACJ,GAEG;AATH;AACA,oCAA6B;AAS5B,uBAAK,SAAU;AACf,SAAK,QAAQ,IAAI,YAAY,OAAO;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,QAAQ;AACb,UAAM,QAAQ,IAAI;AAAA,MACjB,KAAK,MAAM,kBAAkB;AAAA,MAC7B,KAAK,MAAM,YAAY;AAAA,MACvB,KAAK,uBAAuB;AAAA,IAC7B,CAAC;AAAA,EACF;AAAA,EAEA,MAAM,iBAAiB;AAAA,IACtB;AAAA,IACA,GAAG;AAAA,EACJ,GAA2D;AAC1D,gBAAY,eAAe,KAAK,MAAM,SAAS,CAAC;AAChD,WAAO,YAAY,MAAM;AAAA,MACxB,QAAQ,mBAAK;AAAA,MACb,GAAG;AAAA,IACJ,CAAC;AAAA,EACF;AAAA,EAEA,MAAM,mBAAmB;AAAA,IACxB;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACJ,GAE6D;AAC5D,UAAM,QAAQ,cAAc,WAAW,IACpC,MAAM,KAAK,iBAAiB,EAAE,YAAY,CAAC,IAC3C;AAEH,UAAM,UAAU,MAAM,mBAAK,SAAQ,wBAAwB;AAAA,MAC1D,GAAG;AAAA,MACH,kBAAkB;AAAA,MAClB,SAAS;AAAA,QACR,GAAG;AAAA,QACH,gBAAgB;AAAA,MACjB;AAAA,IACD,CAAC;AAED,QAAI,QAAQ,YAAY;AACvB,YAAM,UAAU,IAAI,mBAAmB,MAAM,WAAW,KAAK,QAAQ,UAAU,CAAC;AAChF,YAAM,KAAK,aAAa,OAAO;AAAA,IAChC;AAEA,WAAO;AAAA,EACR;AAAA,EAEA,MAAM,0BAA0B;AAAA,IAC/B;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACJ,GAI2E;AAC1E,gBAAY,kBAAkB,MAAM,OAAO,gBAAgB,CAAC;AAC5D,UAAM,QAAQ,MAAM,KAAK,iBAAiB,EAAE,YAAY,CAAC;AACzD,UAAM,EAAE,UAAU,IAAI,MAAM,MAAM,OAAO,gBAAgB,KAAK;AAC9D,UAAM,UAAU,MAAM,KAAK,mBAAmB;AAAA,MAC7C,aAAa;AAAA,MACb;AAAA,MACA;AAAA,IACD,CAAC;AAED,WAAO;AAAA,EACR;AAAA,EAEA,MAAM,aAAa,SAAmD;AACrE,uBAAK,aAAc,QAAQ,IAAI,qBAAqB;AACpD,UAAM,KAAK,MAAM,aAAa,OAAO;AAAA,EACtC;AAAA,EAEA,MAAM,yBAAyB;AAC9B,QAAI,mBAAK,cAAa;AACrB,YAAM,mBAAK,SAAQ,mBAAmB,EAAE,QAAQ,mBAAK,aAAY,CAAC;AAClE,yBAAK,aAAc;AAAA,IACpB;AAAA,EACD;AACD;AAjGC;AACA;",
+  "names": []
+}

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

@@ -0,0 +1,37 @@
+import type { HaneulClient, HaneulTransactionBlockResponse, HaneulTransactionBlockResponseOptions } 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: HaneulClient;
+    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?: HaneulTransactionBlockResponseOptions, additionalSignatures?: string[]): Promise<{
+        digest: string;
+        effects: string;
+        data: HaneulTransactionBlockResponse;
+    }>;
+}