@haneullabs/haneul 0.1.0 → 2.5.0

package/src/transactions/executor/parallel.ts

@@ -1,53 +1,59 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { toBase64 } from '@haneullabs/bcs';
 import { promiseWithResolvers } from '@haneullabs/utils';
-import { bcs } from '../../bcs/index.js';
 import type { HaneulObjectRef } from '../../bcs/types.js';
-import type {
-	HaneulClient,
-	HaneulTransactionBlockResponse,
-	HaneulTransactionBlockResponseOptions,
-} from '../../client/index.js';
+import type { ClientWithCoreApi } from '../../client/core.js';
+import { coreClientResolveTransactionPlugin } from '../../client/core-resolver.js';
+import type { HaneulClientTypes } from '../../client/types.js';
 import type { Signer } from '../../cryptography/index.js';
 import type { ObjectCacheOptions } from '../ObjectCache.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: 200_000_000n,
 	minimumCoinBalance: 50_000_000n,
 	maxPoolSize: 50,
-	epochBoundaryWindow: 1_000,
-} satisfies Omit<ParallelTransactionExecutorOptions, 'signer' | 'client'>;
-export interface ParallelTransactionExecutorOptions extends Omit<ObjectCacheOptions, 'address'> {
-	client: HaneulClient;
+} satisfies Partial<ParallelTransactionExecutorCoinOptions>;
+
+const EPOCH_BOUNDARY_WINDOW = 60_000;
+
+interface ParallelTransactionExecutorBaseOptions extends Omit<ObjectCacheOptions, 'address'> {
+	client: ClientWithCoreApi;
 	signer: Signer;
+	/** The gasBudget to use if the transaction has not defined it's own gasBudget, defaults to `minimumCoinBalance` */
+	defaultGasBudget?: bigint;
+	/** 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;
+}
+
+export interface ParallelTransactionExecutorCoinOptions extends ParallelTransactionExecutorBaseOptions {
+	/** Gas mode - use owned coins for gas payments (default) */
+	gasMode?: 'coins';
 	/** 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 */
+	/** An initial list of coins used to fund the gas pool, uses all owned HANEUL coins by default */
 	sourceCoins?: string[];
 }
 
+export interface ParallelTransactionExecutorAddressBalanceOptions extends ParallelTransactionExecutorBaseOptions {
+	/** Gas mode - use address balance for gas payments instead of owned coins */
+	gasMode: 'addressBalance';
+}
+
+/** Options for ParallelTransactionExecutor - discriminated union based on gasMode */
+export type ParallelTransactionExecutorOptions =
+	| ParallelTransactionExecutorCoinOptions
+	| ParallelTransactionExecutorAddressBalanceOptions;
+
 interface CoinWithBalance {
 	id: string;
 	version: string;
@@ -56,11 +62,11 @@ interface CoinWithBalance {
 }
 export class ParallelTransactionExecutor {
 	#signer: Signer;
-	#client: HaneulClient;
+	#client: ClientWithCoreApi;
+	#gasMode: 'coins' | 'addressBalance';
 	#coinBatchSize: number;
 	#initialCoinBalance: bigint;
 	#minimumCoinBalance: bigint;
-	#epochBoundaryWindow: number;
 	#defaultGasBudget: bigint;
 	#maxPoolSize: number;
 	#sourceCoins: Map<string, HaneulObjectRef | null> | null;
@@ -72,35 +78,47 @@ export class ParallelTransactionExecutor {
 	#lastDigest: string | null = null;
 	#cacheLock: Promise<void> | null = null;
 	#pendingTransactions = 0;
-	#gasPrice: null | {
+	#epochInfo: null | {
+		epoch: string;
 		price: bigint;
 		expiration: number;
+		chainIdentifier: string;
 	} = null;
+	#epochInfoPromise: Promise<void> | null = null;
 
 	constructor(options: ParallelTransactionExecutorOptions) {
 		this.#signer = options.signer;
 		this.#client = options.client;
-		this.#coinBatchSize = options.coinBatchSize ?? PARALLEL_EXECUTOR_DEFAULTS.coinBatchSize;
-		this.#initialCoinBalance =
-			options.initialCoinBalance ?? PARALLEL_EXECUTOR_DEFAULTS.initialCoinBalance;
-		this.#minimumCoinBalance =
-			options.minimumCoinBalance ?? PARALLEL_EXECUTOR_DEFAULTS.minimumCoinBalance;
+		this.#gasMode = options.gasMode ?? 'coins';
+
+		if (this.#gasMode === 'coins') {
+			const coinOptions = options as ParallelTransactionExecutorCoinOptions;
+			this.#coinBatchSize = coinOptions.coinBatchSize ?? PARALLEL_EXECUTOR_DEFAULTS.coinBatchSize;
+			this.#initialCoinBalance =
+				coinOptions.initialCoinBalance ?? PARALLEL_EXECUTOR_DEFAULTS.initialCoinBalance;
+			this.#minimumCoinBalance =
+				coinOptions.minimumCoinBalance ?? PARALLEL_EXECUTOR_DEFAULTS.minimumCoinBalance;
+			this.#sourceCoins = coinOptions.sourceCoins
+				? new Map(coinOptions.sourceCoins.map((id) => [id, null]))
+				: null;
+		} else {
+			this.#coinBatchSize = 0;
+			this.#initialCoinBalance = 0n;
+			this.#minimumCoinBalance = PARALLEL_EXECUTOR_DEFAULTS.minimumCoinBalance;
+			this.#sourceCoins = null;
+		}
+
 		this.#defaultGasBudget = options.defaultGasBudget ?? this.#minimumCoinBalance;
-		this.#epochBoundaryWindow =
-			options.epochBoundaryWindow ?? PARALLEL_EXECUTOR_DEFAULTS.epochBoundaryWindow;
 		this.#maxPoolSize = options.maxPoolSize ?? PARALLEL_EXECUTOR_DEFAULTS.maxPoolSize;
 		this.#cache = new CachingTransactionExecutor({
 			client: options.client,
 			cache: options.cache,
 		});
 		this.#executeQueue = new ParallelQueue(this.#maxPoolSize);
-		this.#sourceCoins = options.sourceCoins
-			? new Map(options.sourceCoins.map((id) => [id, null]))
-			: null;
 	}
 
 	resetCache() {
-		this.#gasPrice = null;
+		this.#epochInfo = null;
 		return this.#updateCache(() => this.#cache.reset());
 	}
 
@@ -108,21 +126,18 @@ export class ParallelTransactionExecutor {
 		await this.#updateCache(() => this.#waitForLastDigest());
 	}
 
-	async executeTransaction(
+	async executeTransaction<Include extends HaneulClientTypes.TransactionInclude = {}>(
 		transaction: Transaction,
-		options?: HaneulTransactionBlockResponseOptions,
+		include?: Include,
 		additionalSignatures: string[] = [],
-	) {
-		const { promise, resolve, reject } = promiseWithResolvers<{
-			digest: string;
-			effects: string;
-			data: HaneulTransactionBlockResponse;
-		}>();
+	): Promise<HaneulClientTypes.TransactionResult<Include & { effects: true }>> {
+		const { promise, resolve, reject } =
+			promiseWithResolvers<HaneulClientTypes.TransactionResult<Include & { effects: true }>>();
 		const usedObjects = await this.#getUsedObjects(transaction);
 
 		const execute = () => {
 			this.#executeQueue.runTask(() => {
-				const promise = this.#execute(transaction, usedObjects, options, additionalSignatures);
+				const promise = this.#execute(transaction, usedObjects, include, additionalSignatures);
 
 				return promise.then(resolve, reject);
 			});
@@ -183,13 +198,13 @@ export class ParallelTransactionExecutor {
 		return usedObjects;
 	}
 
-	async #execute(
+	async #execute<Include extends HaneulClientTypes.TransactionInclude = {}>(
 		transaction: Transaction,
 		usedObjects: Set<string>,
-		options?: HaneulTransactionBlockResponseOptions,
+		include?: Include,
 		additionalSignatures: string[] = [],
-	) {
-		let gasCoin!: CoinWithBalance;
+	): Promise<HaneulClientTypes.TransactionResult<Include & { effects: true }>> {
+		let gasCoin: CoinWithBalance | null = null;
 		try {
 			transaction.setSenderIfNotSet(this.#signer.toHaneulAddress());
 
@@ -203,15 +218,23 @@ export class ParallelTransactionExecutor {
 				transaction.setGasBudgetIfNotSet(this.#defaultGasBudget);
 
 				await this.#updateCache();
-				gasCoin = await this.#getGasCoin();
 				this.#pendingTransactions++;
-				transaction.setGasPayment([
-					{
-						objectId: gasCoin.id,
-						version: gasCoin.version,
-						digest: gasCoin.digest,
-					},
-				]);
+
+				if (this.#gasMode === 'addressBalance') {
+					// Address balance mode: use empty gas payment with ValidDuring expiration
+					transaction.setGasPayment([]);
+					transaction.setExpiration(await this.#getValidDuringExpiration());
+				} else {
+					// Coin mode: use gas coin from pool
+					gasCoin = await this.#getGasCoin();
+					transaction.setGasPayment([
+						{
+							objectId: gasCoin.id,
+							version: gasCoin.version,
+							digest: gasCoin.digest,
+						},
+					]);
+				}
 
 				// Resolve cached references
 				await this.#cache.buildTransaction({ transaction, onlyTransactionKind: true });
@@ -223,65 +246,68 @@ export class ParallelTransactionExecutor {
 
 			const results = await this.#cache.executeTransaction({
 				transaction: bytes,
-				signature: [signature, ...additionalSignatures],
-				options: {
-					...options,
-					showEffects: true,
-				},
+				signatures: [signature, ...additionalSignatures],
+				include,
 			});
 
-			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 === this.#signer.toHaneulAddress()) {
-				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 >= this.#minimumCoinBalance) {
-					this.#coinPool.push({
-						id: gasResult.ref.objectId,
-						version: gasResult.ref.version,
-						digest: gasResult.ref.digest,
-						balance: remainingBalance,
+			const tx = results.$kind === 'Transaction' ? results.Transaction : results.FailedTransaction;
+			const effects = tx.effects!;
+			const gasObject = effects.gasObject;
+			const gasUsed = effects.gasUsed;
+
+			if (gasCoin && gasUsed && gasObject) {
+				const coin = gasCoin as CoinWithBalance;
+				const gasOwner = gasObject.outputOwner?.AddressOwner ?? gasObject.outputOwner?.ObjectOwner;
+
+				if (gasOwner === this.#signer.toHaneulAddress()) {
+					const totalUsed =
+						BigInt(gasUsed.computationCost) +
+						BigInt(gasUsed.storageCost) +
+						BigInt(gasUsed.storageCost) -
+						BigInt(gasUsed.storageRebate);
+					const remainingBalance = coin.balance - totalUsed;
+
+					let usesGasCoin = false;
+					new TransactionDataBuilder(transaction.getData()).mapArguments((arg) => {
+						if (arg.$kind === 'GasCoin') {
+							usesGasCoin = true;
+						}
+
+						return arg;
 					});
-				} else {
-					if (!this.#sourceCoins) {
-						this.#sourceCoins = new Map();
+
+					const gasRef = {
+						objectId: gasObject.objectId,
+						version: gasObject.outputVersion!,
+						digest: gasObject.outputDigest!,
+					};
+
+					if (!usesGasCoin && remainingBalance >= this.#minimumCoinBalance) {
+						this.#coinPool.push({
+							id: gasRef.objectId,
+							version: gasRef.version,
+							digest: gasRef.digest,
+							balance: remainingBalance,
+						});
+					} else {
+						if (!this.#sourceCoins) {
+							this.#sourceCoins = new Map();
+						}
+						this.#sourceCoins.set(gasRef.objectId, gasRef);
 					}
-					this.#sourceCoins.set(gasResult.ref.objectId, gasResult.ref);
 				}
 			}
 
-			this.#lastDigest = results.digest;
+			this.#lastDigest = tx.digest;
 
-			return {
-				digest: results.digest,
-				effects: toBase64(effectsBytes),
-				data: results,
-			};
+			return results as HaneulClientTypes.TransactionResult<Include & { effects: true }>;
 		} catch (error) {
 			if (gasCoin) {
 				if (!this.#sourceCoins) {
 					this.#sourceCoins = new Map();
 				}
 
-				this.#sourceCoins.set(gasCoin.id, null);
+				this.#sourceCoins.set((gasCoin as CoinWithBalance).id, null);
 			}
 
 			await this.#updateCache(async () => {
@@ -324,7 +350,7 @@ export class ParallelTransactionExecutor {
 		const digest = this.#lastDigest;
 		if (digest) {
 			this.#lastDigest = null;
-			await this.#client.waitForTransaction({ digest });
+			await this.#client.core.waitForTransaction({ digest });
 		}
 	}
 
@@ -342,33 +368,56 @@ export class ParallelTransactionExecutor {
 	}
 
 	async #getGasPrice(): Promise<bigint> {
-		const remaining = this.#gasPrice
-			? this.#gasPrice.expiration - this.#epochBoundaryWindow - Date.now()
-			: 0;
+		await this.#ensureEpochInfo();
+		return this.#epochInfo!.price;
+	}
+
+	async #getValidDuringExpiration() {
+		await this.#ensureEpochInfo();
+		const currentEpoch = BigInt(this.#epochInfo!.epoch);
+		return {
+			ValidDuring: {
+				minEpoch: String(currentEpoch),
+				maxEpoch: String(currentEpoch + 1n),
+				minTimestamp: null,
+				maxTimestamp: null,
+				chain: this.#epochInfo!.chainIdentifier,
+				nonce: (Math.random() * 0x100000000) >>> 0,
+			},
+		};
+	}
 
-		if (remaining > 0) {
-			return this.#gasPrice!.price;
+	async #ensureEpochInfo(): Promise<void> {
+		if (this.#epochInfo && this.#epochInfo.expiration - EPOCH_BOUNDARY_WINDOW - Date.now() > 0) {
+			return;
 		}
 
-		if (this.#gasPrice) {
-			const timeToNextEpoch = Math.max(
-				this.#gasPrice.expiration + this.#epochBoundaryWindow - Date.now(),
-				1_000,
-			);
+		if (this.#epochInfoPromise) {
+			await this.#epochInfoPromise;
+			return;
+		}
 
-			await new Promise((resolve) => setTimeout(resolve, timeToNextEpoch));
+		this.#epochInfoPromise = this.#fetchEpochInfo();
+		try {
+			await this.#epochInfoPromise;
+		} finally {
+			this.#epochInfoPromise = null;
 		}
+	}
 
-		const state = await this.#client.getLatestHaneulSystemState();
+	async #fetchEpochInfo(): Promise<void> {
+		const [{ systemState }, { chainIdentifier }] = await Promise.all([
+			this.#client.core.getCurrentSystemState(),
+			this.#client.core.getChainIdentifier(),
+		]);
 
-		this.#gasPrice = {
-			price: BigInt(state.referenceGasPrice),
+		this.#epochInfo = {
+			epoch: systemState.epoch,
+			price: BigInt(systemState.referenceGasPrice),
 			expiration:
-				Number.parseInt(state.epochStartTimestampMs, 10) +
-				Number.parseInt(state.epochDurationMs, 10),
+				Number(systemState.epochStartTimestampMs) + Number(systemState.parameters.epochDurationMs),
+			chainIdentifier,
 		};
-
-		return this.#getGasPrice();
 	}
 
 	async #refillCoinPool() {
@@ -397,16 +446,16 @@ export class ParallelTransactionExecutor {
 			}
 
 			if (ids.length > 0) {
-				const coins = await this.#client.multiGetObjects({
-					ids,
+				const { objects } = await this.#client.core.getObjects({
+					objectIds: ids,
 				});
 				refs.push(
-					...coins
-						.filter((coin): coin is typeof coin & { data: object } => coin.data !== null)
-						.map(({ data }) => ({
-							objectId: data.objectId,
-							version: data.version,
-							digest: data.digest,
+					...objects
+						.filter((obj): obj is HaneulClientTypes.Object => !(obj instanceof Error))
+						.map((obj) => ({
+							objectId: obj.objectId,
+							version: obj.version,
+							digest: obj.digest,
 						})),
 				);
 			}
@@ -416,33 +465,40 @@ export class ParallelTransactionExecutor {
 		}
 
 		const amounts = new Array(batchSize).fill(this.#initialCoinBalance);
-		const results = txb.splitCoins(txb.gas, amounts);
+		const splitResults = txb.splitCoins(txb.gas, amounts);
 		const coinResults = [];
 		for (let i = 0; i < amounts.length; i++) {
-			coinResults.push(results[i]);
+			coinResults.push(splitResults[i]);
 		}
 		txb.transferObjects(coinResults, address);
 
 		await this.waitForLastTransaction();
 
-		const result = await this.#client.signAndExecuteTransaction({
-			transaction: txb,
-			signer: this.#signer,
-			options: {
-				showRawEffects: true,
-			},
+		txb.addBuildPlugin(coreClientResolveTransactionPlugin);
+		const bytes = await txb.build({ client: this.#client });
+		const { signature } = await this.#signer.signTransaction(bytes);
+
+		const result = await this.#client.core.executeTransaction({
+			transaction: bytes,
+			signatures: [signature],
+			include: { effects: true },
 		});
 
-		const effects = bcs.TransactionEffects.parse(Uint8Array.from(result.rawEffects!));
-		effects.V2?.changedObjects.forEach(([id, { outputState }], i) => {
-			if (i === effects.V2?.gasObjectIndex || !outputState.ObjectWrite) {
+		const tx = result.$kind === 'Transaction' ? result.Transaction : result.FailedTransaction;
+		const effects = tx.effects!;
+
+		effects.changedObjects.forEach((changedObj) => {
+			if (
+				changedObj.objectId === effects.gasObject?.objectId ||
+				changedObj.outputState !== 'ObjectWrite'
+			) {
 				return;
 			}
 
 			this.#coinPool.push({
-				id,
-				version: effects.V2!.lamportVersion,
-				digest: outputState.ObjectWrite[0],
+				id: changedObj.objectId,
+				version: changedObj.outputVersion!,
+				digest: changedObj.outputDigest!,
 				balance: BigInt(this.#initialCoinBalance),
 			});
 		});
@@ -451,9 +507,13 @@ export class ParallelTransactionExecutor {
 			this.#sourceCoins = new Map();
 		}
 
-		const gasObject = getGasCoinFromEffects(effects).ref;
-		this.#sourceCoins!.set(gasObject.objectId, gasObject);
+		const gasObject = effects.gasObject!;
+		this.#sourceCoins!.set(gasObject.objectId, {
+			objectId: gasObject.objectId,
+			version: gasObject.outputVersion!,
+			digest: gasObject.outputDigest!,
+		});
 
-		await this.#client.waitForTransaction({ digest: result.digest });
+		await this.#client.core.waitForTransaction({ digest: tx.digest });
 	}
 }