@mysten/sui 1.1.2 → 1.2.0

package/src/transactions/executor/parallel.ts

@@ -18,14 +18,28 @@ const PARALLEL_EXECUTOR_DEFAULTS = {
 	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: 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[];
 }
 
@@ -41,6 +55,8 @@ export class ParallelTransactionExecutor {
 	#coinBatchSize: number;
 	#initialCoinBalance: bigint;
 	#minimumCoinBalance: bigint;
+	#epochBoundaryWindow: number;
+	#defaultGasBudget: bigint;
 	#maxPoolSize: number;
 	#sourceCoins: Map<string, SuiObjectRef | null> | null;
 	#coinPool: CoinWithBalance[] = [];
@@ -48,6 +64,13 @@ export class ParallelTransactionExecutor {
 	#objectIdQueues = new Map<string, (() => void)[]>();
 	#buildQueue = new SerialQueue();
 	#executeQueue: ParallelQueue;
+	#lastDigest: string | null = null;
+	#cacheLock: Promise<void> | null = null;
+	#pendingTransactions = 0;
+	#gasPrice: null | {
+		price: bigint;
+		expiration: number;
+	} = null;
 
 	constructor(options: ParallelTransactionExecutorOptions) {
 		this.#signer = options.signer;
@@ -57,6 +80,9 @@ export class ParallelTransactionExecutor {
 			options.initialCoinBalance ?? PARALLEL_EXECUTOR_DEFAULTS.initialCoinBalance;
 		this.#minimumCoinBalance =
 			options.minimumCoinBalance ?? PARALLEL_EXECUTOR_DEFAULTS.minimumCoinBalance;
+		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,
@@ -69,7 +95,8 @@ export class ParallelTransactionExecutor {
 	}
 
 	resetCache() {
-		return this.#cache.reset();
+		this.#gasPrice = null;
+		return this.#updateCache(() => this.#cache.reset());
 	}
 
 	async executeTransaction(transaction: Transaction) {
@@ -145,8 +172,22 @@ export class ParallelTransactionExecutor {
 	async #execute(transaction: Transaction, usedObjects: Set<string>) {
 		let gasCoin!: CoinWithBalance;
 		try {
-			const bytes = await this.#buildQueue.runTask(async () => {
+			transaction.setSenderIfNotSet(this.#signer.toSuiAddress());
+
+			await this.#buildQueue.runTask(async () => {
+				const data = transaction.getData();
+
+				if (!data.gasData.price) {
+					transaction.setGasPrice(await this.#getGasPrice());
+				}
+
+				if (!data.gasData.budget) {
+					transaction.setGasBudget(this.#defaultGasBudget);
+				}
+
+				await this.#updateCache();
 				gasCoin = await this.#getGasCoin();
+				this.#pendingTransactions++;
 				transaction.setGasPayment([
 					{
 						objectId: gasCoin.id,
@@ -154,11 +195,13 @@ export class ParallelTransactionExecutor {
 						digest: gasCoin.digest,
 					},
 				]);
-				transaction.setSenderIfNotSet(this.#signer.toSuiAddress());
 
-				return this.#cache.buildTransaction({ transaction: transaction });
+				// Resolve cached references
+				await this.#cache.buildTransaction({ transaction, onlyTransactionKind: true });
 			});
 
+			const bytes = await transaction.build({ client: this.#client });
+
 			const { signature } = await this.#signer.signTransaction(bytes);
 
 			const results = await this.#cache.executeTransaction({
@@ -197,6 +240,8 @@ export class ParallelTransactionExecutor {
 				}
 			}
 
+			this.#lastDigest = results.digest;
+
 			return {
 				digest: results.digest,
 				effects: toB64(effectsBytes),
@@ -210,7 +255,13 @@ export class ParallelTransactionExecutor {
 				this.#sourceCoins.set(gasCoin.id, null);
 			}
 
-			await this.#cache.cache.deleteObjects([...usedObjects]);
+			await this.#updateCache(async () => {
+				await Promise.all([
+					this.#cache.cache.deleteObjects([...usedObjects]),
+					this.#waitForLastDigest(),
+				]);
+			});
+
 			throw error;
 		} finally {
 			usedObjects.forEach((objectId) => {
@@ -221,11 +272,35 @@ export class ParallelTransactionExecutor {
 					this.#objectIdQueues.delete(objectId);
 				}
 			});
+			this.#pendingTransactions--;
+		}
+	}
+
+	/** Helper for synchronizing cache updates, by ensuring only one update happens at a time.  This can also be used to wait for any pending cache updates  */
+	async #updateCache(fn?: () => Promise<void>) {
+		if (this.#cacheLock) {
+			await this.#cacheLock;
+		}
+
+		this.#cacheLock =
+			fn?.().then(
+				() => {
+					this.#cacheLock = null;
+				},
+				() => {},
+			) ?? null;
+	}
+
+	async #waitForLastDigest() {
+		const digest = this.#lastDigest;
+		if (digest) {
+			this.#lastDigest = null;
+			await this.#client.waitForTransaction({ digest });
 		}
 	}
 
 	async #getGasCoin() {
-		if (this.#coinPool.length === 0 && this.#executeQueue.activeTasks <= this.#maxPoolSize) {
+		if (this.#coinPool.length === 0 && this.#pendingTransactions <= this.#maxPoolSize) {
 			await this.#refillCoinPool();
 		}
 
@@ -237,10 +312,40 @@ export class ParallelTransactionExecutor {
 		return coin;
 	}
 
+	async #getGasPrice(): Promise<bigint> {
+		const remaining = this.#gasPrice
+			? this.#gasPrice.expiration - this.#epochBoundaryWindow - Date.now()
+			: 0;
+
+		if (remaining > 0) {
+			return this.#gasPrice!.price;
+		}
+
+		if (this.#gasPrice) {
+			const timeToNextEpoch = Math.max(
+				this.#gasPrice.expiration + this.#epochBoundaryWindow - Date.now(),
+				1_000,
+			);
+
+			await new Promise((resolve) => setTimeout(resolve, timeToNextEpoch));
+		}
+
+		const state = await this.#client.getLatestSuiSystemState();
+
+		this.#gasPrice = {
+			price: BigInt(state.referenceGasPrice),
+			expiration:
+				Number.parseInt(state.epochStartTimestampMs, 10) +
+				Number.parseInt(state.epochDurationMs, 10),
+		};
+
+		return this.#getGasPrice();
+	}
+
 	async #refillCoinPool() {
 		const batchSize = Math.min(
 			this.#coinBatchSize,
-			this.#maxPoolSize - (this.#coinPool.length + this.#executeQueue.activeTasks) + 1,
+			this.#maxPoolSize - (this.#coinPool.length + this.#pendingTransactions) + 1,
 		);
 
 		if (batchSize === 0) {
@@ -289,6 +394,8 @@ export class ParallelTransactionExecutor {
 		}
 		txb.transferObjects(coinResults, address);
 
+		await this.#updateCache(() => this.#waitForLastDigest());
+
 		const result = await this.#client.signAndExecuteTransaction({
 			transaction: txb,
 			signer: this.#signer,

package/src/transactions/executor/serial.ts

@@ -15,6 +15,8 @@ export class SerialTransactionExecutor {
 	#queue = new SerialQueue();
 	#signer: Signer;
 	#cache: CachingTransactionExecutor;
+	#client: SuiClient;
+	#lastDigest: string | null = null;
 
 	constructor({
 		signer,
@@ -24,6 +26,7 @@ export class SerialTransactionExecutor {
 		signer: Signer;
 	}) {
 		this.#signer = signer;
+		this.#client = options.client;
 		this.#cache = new CachingTransactionExecutor({
 			client: options.client,
 			cache: options.cache,
@@ -69,7 +72,14 @@ export class SerialTransactionExecutor {
 	};
 
 	resetCache() {
-		return this.#cache.reset();
+		return Promise.all([this.#cache.reset(), this.#waitForLastTransaction()]);
+	}
+
+	async #waitForLastTransaction() {
+		if (this.#lastDigest) {
+			await this.#client.waitForTransaction({ digest: this.#lastDigest });
+			this.#lastDigest = null;
+		}
 	}
 
 	executeTransaction(transaction: Transaction | Uint8Array) {
@@ -92,6 +102,7 @@ export class SerialTransactionExecutor {
 			const effectsBytes = Uint8Array.from(results.rawEffects!);
 			const effects = bcs.TransactionEffects.parse(effectsBytes);
 			await this.applyEffects(effects);
+			this.#lastDigest = results.digest;
 
 			return {
 				digest: results.digest,

package/src/transactions/json-rpc-resolver.ts

@@ -148,8 +148,8 @@ async function resolveObjectReferences(
 	// We keep the input by-reference to avoid needing to re-resolve it:
 	const objectsToResolve = transactionData.inputs.filter((input) => {
 		return (
-			(input.UnresolvedObject && !input.UnresolvedObject.version) ||
-			input.UnresolvedObject?.initialSharedVersion
+			input.UnresolvedObject &&
+			!(input.UnresolvedObject.version || input.UnresolvedObject?.initialSharedVersion)
 		);
 	}) as Extract<CallArg, { UnresolvedObject: unknown }>[];
 
@@ -179,7 +179,7 @@ async function resolveObjectReferences(
 
 	const invalidObjects = Array.from(responsesById)
 		.filter(([_, obj]) => obj.error)
-		.map(([id, _obj]) => id);
+		.map(([_, obj]) => JSON.stringify(obj.error));
 
 	if (invalidObjects.length) {
 		throw new Error(`The following input objects are invalid: ${invalidObjects.join(', ')}`);
@@ -218,10 +218,11 @@ async function resolveObjectReferences(
 		const id = normalizeSuiAddress(input.UnresolvedObject.objectId);
 		const object = objectsById.get(id);
 
-		if (object?.initialSharedVersion) {
+		if (input.UnresolvedObject.initialSharedVersion ?? object?.initialSharedVersion) {
 			updated = Inputs.SharedObjectRef({
 				objectId: id,
-				initialSharedVersion: object.initialSharedVersion,
+				initialSharedVersion:
+					input.UnresolvedObject.initialSharedVersion || object?.initialSharedVersion!,
 				mutable: isUsedAsMutable(transactionData, index),
 			});
 		} else if (isUsedAsReceiving(transactionData, index)) {

package/src/version.ts

@@ -3,5 +3,5 @@
 
 // This file is generated by genversion.mjs. Do not edit it directly.
 
-export const PACKAGE_VERSION = '1.1.2';
-export const TARGETED_RPC_VERSION = '1.28.0';
+export const PACKAGE_VERSION = '1.2.0';
+export const TARGETED_RPC_VERSION = '1.29.0';