@haneullabs/haneul 0.1.0

package/dist/cjs/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/cjs/transactions/data/v2.js

@@ -0,0 +1,125 @@
+"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.HaneulAddress),
+  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.HaneulAddress),
+  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)()))
+});
+//# sourceMappingURL=v2.js.map

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

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

package/dist/cjs/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;AAAA;AAAA;AAAA;AAAA;AAGA,iBAAoB;AAKpB,yBAA4B;AAE5B,yBAA8B;AAV9B;AAYO,MAAM,2BAA2B;AAAA,EAKvC,YAAY;AAAA,IACX;AAAA,IACA,GAAG;AAAA,EACJ,GAEG;AATH;AACA,oCAA6B;AAS5B,uBAAK,SAAU;AACf,SAAK,QAAQ,IAAI,+BAAY,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,YAAQ,kCAAc,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,eAAI,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/cjs/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;
+    }>;
+}