@haneullabs/haneul 0.1.0 → 2.5.0

package/src/transactions/executor/serial.ts

@@ -1,37 +1,58 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { toBase64 } from '@haneullabs/bcs';
-
 import type { bcs } from '../../bcs/index.js';
-import type { HaneulClient, HaneulTransactionBlockResponseOptions } from '../../client/index.js';
+import type { ClientWithCoreApi } from '../../client/core.js';
+import type { HaneulClientTypes } from '../../client/types.js';
 import type { Signer } from '../../cryptography/keypair.js';
 import type { ObjectCacheOptions } from '../ObjectCache.js';
 import { isTransaction, Transaction } from '../Transaction.js';
 import { CachingTransactionExecutor } from './caching.js';
 import { SerialQueue } from './queue.js';
 
+const EPOCH_BOUNDARY_WINDOW = 60_000;
+
+interface SerialTransactionExecutorBaseOptions extends Omit<ObjectCacheOptions, 'address'> {
+	client: ClientWithCoreApi;
+	signer: Signer;
+	defaultGasBudget?: bigint;
+}
+
+export interface SerialTransactionExecutorCoinOptions extends SerialTransactionExecutorBaseOptions {
+	gasMode?: 'coins';
+}
+
+export interface SerialTransactionExecutorAddressBalanceOptions extends SerialTransactionExecutorBaseOptions {
+	gasMode: 'addressBalance';
+}
+
+export type SerialTransactionExecutorOptions =
+	| SerialTransactionExecutorCoinOptions
+	| SerialTransactionExecutorAddressBalanceOptions;
+
 export class SerialTransactionExecutor {
 	#queue = new SerialQueue();
 	#signer: Signer;
+	#client: ClientWithCoreApi;
 	#cache: CachingTransactionExecutor;
 	#defaultGasBudget: bigint;
-
-	constructor({
-		signer,
-		defaultGasBudget = 50_000_000n,
-		...options
-	}: Omit<ObjectCacheOptions, 'address'> & {
-		client: HaneulClient;
-		signer: Signer;
-		/** The gasBudget to use if the transaction has not defined it's own gasBudget, defaults to `50_000_000n` */
-		defaultGasBudget?: bigint;
-	}) {
+	#gasMode: 'coins' | 'addressBalance';
+	#epochInfo: null | {
+		epoch: string;
+		expiration: number;
+		chainIdentifier: string;
+	} = null;
+	#epochInfoPromise: Promise<void> | null = null;
+
+	constructor(options: SerialTransactionExecutorOptions) {
+		const { signer, defaultGasBudget = 50_000_000n, client, cache } = options;
 		this.#signer = signer;
+		this.#client = client;
 		this.#defaultGasBudget = defaultGasBudget;
+		this.#gasMode = options.gasMode ?? 'coins';
 		this.#cache = new CachingTransactionExecutor({
-			client: options.client,
-			cache: options.cache,
+			client,
+			cache,
 			onEffects: (effects) => this.#cacheGasCoin(effects),
 		});
 	}
@@ -41,7 +62,7 @@ export class SerialTransactionExecutor {
 	}
 
 	#cacheGasCoin = async (effects: typeof bcs.TransactionEffects.$inferType) => {
-		if (!effects.V2) {
+		if (this.#gasMode === 'addressBalance' || !effects.V2) {
 			return;
 		}
 
@@ -58,15 +79,26 @@ export class SerialTransactionExecutor {
 	}
 
 	#buildTransaction = async (transaction: Transaction) => {
-		const gasCoin = await this.#cache.cache.getCustom<{
-			objectId: string;
-			version: string;
-			digest: string;
-		}>('gasCoin');
-
+		await transaction.prepareForSerialization({
+			client: this.#client,
+			supportedIntents: ['CoinWithBalance'],
+		});
 		const copy = Transaction.from(transaction);
-		if (gasCoin) {
-			copy.setGasPayment([gasCoin]);
+
+		if (this.#gasMode === 'addressBalance') {
+			copy.setGasPayment([]);
+			copy.setExpiration(await this.#getValidDuringExpiration());
+		} else {
+			// Coin mode: use cached gas coin if available
+			const gasCoin = await this.#cache.cache.getCustom<{
+				objectId: string;
+				version: string;
+				digest: string;
+			}>('gasCoin');
+
+			if (gasCoin) {
+				copy.setGasPayment([gasCoin]);
+			}
 		}
 
 		copy.setGasBudgetIfNotSet(this.#defaultGasBudget);
@@ -75,6 +107,53 @@ export class SerialTransactionExecutor {
 		return this.#cache.buildTransaction({ transaction: copy });
 	};
 
+	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,
+			},
+		};
+	}
+
+	async #ensureEpochInfo(): Promise<void> {
+		if (this.#epochInfo && this.#epochInfo.expiration - EPOCH_BOUNDARY_WINDOW - Date.now() > 0) {
+			return;
+		}
+
+		if (this.#epochInfoPromise) {
+			await this.#epochInfoPromise;
+			return;
+		}
+
+		this.#epochInfoPromise = this.#fetchEpochInfo();
+		try {
+			await this.#epochInfoPromise;
+		} finally {
+			this.#epochInfoPromise = null;
+		}
+	}
+
+	async #fetchEpochInfo(): Promise<void> {
+		const [{ systemState }, { chainIdentifier }] = await Promise.all([
+			this.#client.core.getCurrentSystemState(),
+			this.#client.core.getChainIdentifier(),
+		]);
+
+		this.#epochInfo = {
+			epoch: systemState.epoch,
+			expiration:
+				Number(systemState.epochStartTimestampMs) + Number(systemState.parameters.epochDurationMs),
+			chainIdentifier,
+		};
+	}
+
 	resetCache() {
 		return this.#cache.reset();
 	}
@@ -83,34 +162,27 @@ export class SerialTransactionExecutor {
 		return this.#cache.waitForLastTransaction();
 	}
 
-	executeTransaction(
+	executeTransaction<Include extends HaneulClientTypes.TransactionInclude = {}>(
 		transaction: Transaction | Uint8Array,
-		options?: HaneulTransactionBlockResponseOptions,
+		include?: Include,
 		additionalSignatures: string[] = [],
-	) {
+	): Promise<HaneulClientTypes.TransactionResult<Include & { effects: true }>> {
 		return this.#queue.runTask(async () => {
 			const bytes = isTransaction(transaction)
 				? await this.#buildTransaction(transaction)
 				: transaction;
 
 			const { signature } = await this.#signer.signTransaction(bytes);
-			const results = await this.#cache
+			return this.#cache
 				.executeTransaction({
-					signature: [signature, ...additionalSignatures],
+					signatures: [signature, ...additionalSignatures],
 					transaction: bytes,
-					options,
+					include,
 				})
 				.catch(async (error) => {
 					await this.resetCache();
 					throw error;
 				});
-
-			const effectsBytes = Uint8Array.from(results.rawEffects!);
-			return {
-				digest: results.digest,
-				effects: toBase64(effectsBytes),
-				data: results,
-			};
 		});
 	}
 }

package/src/transactions/hash.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { blake2b } from '@noble/hashes/blake2b';
+import { blake2b } from '@noble/hashes/blake2.js';
 
 /**
  * Generates a Blake2b hash of typed data as a base64 string.

package/src/transactions/index.ts

@@ -1,13 +1,11 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { NamedPackagesOverrides } from '../experimental/mvr.js';
-
 export { normalizedTypeToMoveTypeSignature, getPureBcsSchema } from './serializer.js';
 
 export { Inputs } from './Inputs.js';
 export {
-	Commands,
+	TransactionCommands,
 	type TransactionArgument,
 	type TransactionInput,
 	UpgradePolicy,
@@ -31,8 +29,6 @@ export type {
 	GasData,
 	CallArg,
 	Command,
-	OpenMoveTypeSignature,
-	OpenMoveTypeSignatureBody,
 } from './data/internal.js';
 
 export { TransactionDataBuilder } from './TransactionData.js';
@@ -50,13 +46,4 @@ export type {
 
 export { Arguments } from './Arguments.js';
 
-export {
-	namedPackagesPlugin,
-	type NamedPackagesPluginOptions,
-} from './plugins/NamedPackagesPlugin.js';
-
-export type { NamedPackagesOverrides };
-/** @deprecated Use NamedPackagesOverrides instead */
-export type NamedPackagesPluginCache = NamedPackagesOverrides;
-
 export { isArgument } from './utils.js';

package/src/transactions/intents/CoinWithBalance.ts

@@ -5,17 +5,16 @@ import type { InferInput } from 'valibot';
 import { bigint, object, parse, string } from 'valibot';
 
 import { bcs } from '../../bcs/index.js';
-import type { CoinStruct, HaneulClient } from '../../client/index.js';
 import { normalizeStructTag } from '../../utils/haneul-types.js';
-import { Commands } from '../Commands.js';
+import { TransactionCommands } from '../Commands.js';
 import type { Argument } from '../data/internal.js';
 import { Inputs } from '../Inputs.js';
-import { getClient } from '../resolve.js';
 import type { BuildTransactionOptions } from '../resolve.js';
 import type { Transaction, TransactionResult } from '../Transaction.js';
 import type { TransactionDataBuilder } from '../TransactionData.js';
+import type { ClientWithCoreApi, HaneulClientTypes } from '../../client/index.js';
 
-const COIN_WITH_BALANCE = 'CoinWithBalance';
+export const COIN_WITH_BALANCE = 'CoinWithBalance';
 const SUI_TYPE = normalizeStructTag('0x2::haneul::HANEUL');
 
 export function coinWithBalance({
@@ -38,7 +37,7 @@ export function coinWithBalance({
 		const coinType = type === 'gas' ? type : normalizeStructTag(type);
 
 		coinResult = tx.add(
-			Commands.Intent({
+			TransactionCommands.Intent({
 				name: COIN_WITH_BALANCE,
 				inputs: {},
 				data: {
@@ -57,7 +56,7 @@ const CoinWithBalanceData = object({
 	balance: bigint(),
 });
 
-async function resolveCoinBalance(
+export async function resolveCoinBalance(
 	transactionData: TransactionDataBuilder,
 	buildOptions: BuildTransactionOptions,
 	next: () => Promise<void>,
@@ -91,27 +90,43 @@ async function resolveCoinBalance(
 		}
 	}
 
-	const coinsByType = new Map<string, CoinStruct[]>();
-	const client = getHaneulClient(buildOptions);
-	await Promise.all(
-		[...coinTypes].map(async (coinType) => {
-			coinsByType.set(
+	const coinsByType = new Map<string, HaneulClientTypes.Coin[]>();
+	const addressBalanceByType = new Map<string, bigint>();
+	const client = buildOptions.client;
+
+	if (!client) {
+		throw new Error(
+			'Client must be provided to build or serialize transactions with CoinWithBalance intents',
+		);
+	}
+
+	await Promise.all([
+		...[...coinTypes].map(async (coinType) => {
+			const { coins, addressBalance } = await getCoinsAndBalanceOfType({
 				coinType,
-				await getCoinsOfType({
-					coinType,
-					balance: totalByType.get(coinType)!,
-					client,
-					owner: transactionData.sender!,
-					usedIds,
-				}),
-			);
+				balance: totalByType.get(coinType)!,
+				client,
+				owner: transactionData.sender!,
+				usedIds,
+			});
+
+			coinsByType.set(coinType, coins);
+			addressBalanceByType.set(coinType, addressBalance);
 		}),
-	);
+		totalByType.has('gas')
+			? await client.core
+					.getBalance({
+						owner: transactionData.sender!,
+						coinType: SUI_TYPE,
+					})
+					.then(({ balance }) => {
+						addressBalanceByType.set('gas', BigInt(balance.addressBalance));
+					})
+			: null,
+	]);
 
 	const mergedCoins = new Map<string, Argument>();
 
-	mergedCoins.set('gas', { $kind: 'GasCoin', GasCoin: true });
-
 	for (const [index, transaction] of transactionData.commands.entries()) {
 		if (transaction.$kind !== '$Intent' || transaction.$Intent.name !== COIN_WITH_BALANCE) {
 			continue;
@@ -122,44 +137,123 @@ async function resolveCoinBalance(
 			balance: bigint;
 		};
 
-		if (balance === 0n && type !== 'gas') {
+		if (balance === 0n) {
 			transactionData.replaceCommand(
 				index,
-				Commands.MoveCall({ target: '0x2::coin::zero', typeArguments: [type] }),
+				TransactionCommands.MoveCall({
+					target: '0x2::coin::zero',
+					typeArguments: [type === 'gas' ? SUI_TYPE : type],
+				}),
 			);
 			continue;
 		}
 
 		const commands = [];
 
-		if (!mergedCoins.has(type)) {
-			const [first, ...rest] = coinsByType.get(type)!.map((coin) =>
-				transactionData.addInput(
-					'object',
-					Inputs.ObjectRef({
-						objectId: coin.coinObjectId,
-						digest: coin.digest,
-						version: coin.version,
-					}),
-				),
+		if (addressBalanceByType.get(type)! >= totalByType.get(type)!) {
+			commands.push(
+				TransactionCommands.MoveCall({
+					target: '0x2::coin::redeem_funds',
+					typeArguments: [type === 'gas' ? SUI_TYPE : type],
+					arguments: [
+						transactionData.addInput(
+							'withdrawal',
+							Inputs.FundsWithdrawal({
+								reservation: {
+									$kind: 'MaxAmountU64',
+									MaxAmountU64: String(balance),
+								},
+								typeArg: {
+									$kind: 'Balance',
+									Balance: type === 'gas' ? SUI_TYPE : type,
+								},
+								withdrawFrom: {
+									$kind: 'Sender',
+									Sender: true,
+								},
+							}),
+						),
+					],
+				}),
 			);
-
-			if (rest.length > 0) {
-				commands.push(Commands.MergeCoins(first, rest));
+		} else {
+			if (!mergedCoins.has(type)) {
+				const addressBalance = addressBalanceByType.get(type) ?? 0n;
+				const coinType = type === 'gas' ? SUI_TYPE : type;
+
+				let baseCoin: Argument;
+				let restCoins: Argument[];
+
+				if (type === 'gas') {
+					baseCoin = { $kind: 'GasCoin', GasCoin: true };
+					restCoins = [];
+				} else {
+					[baseCoin, ...restCoins] = coinsByType.get(type)!.map((coin) =>
+						transactionData.addInput(
+							'object',
+							Inputs.ObjectRef({
+								objectId: coin.objectId,
+								digest: coin.digest,
+								version: coin.version,
+							}),
+						),
+					);
+				}
+
+				if (addressBalance > 0n) {
+					commands.push(
+						TransactionCommands.MoveCall({
+							target: '0x2::coin::redeem_funds',
+							typeArguments: [coinType],
+							arguments: [
+								transactionData.addInput(
+									'withdrawal',
+									Inputs.FundsWithdrawal({
+										reservation: {
+											$kind: 'MaxAmountU64',
+											MaxAmountU64: String(addressBalance),
+										},
+										typeArg: {
+											$kind: 'Balance',
+											Balance: coinType,
+										},
+										withdrawFrom: {
+											$kind: 'Sender',
+											Sender: true,
+										},
+									}),
+								),
+							],
+						}),
+					);
+
+					commands.push(
+						TransactionCommands.MergeCoins(baseCoin, [
+							{ $kind: 'Result', Result: index + commands.length - 1 },
+							...restCoins,
+						]),
+					);
+				} else if (restCoins.length > 0) {
+					commands.push(TransactionCommands.MergeCoins(baseCoin, restCoins));
+				}
+
+				mergedCoins.set(type, baseCoin);
 			}
 
-			mergedCoins.set(type, first);
+			commands.push(
+				TransactionCommands.SplitCoins(mergedCoins.get(type)!, [
+					transactionData.addInput('pure', Inputs.Pure(bcs.u64().serialize(balance))),
+				]),
+			);
 		}
 
-		commands.push(
-			Commands.SplitCoins(mergedCoins.get(type)!, [
-				transactionData.addInput('pure', Inputs.Pure(bcs.u64().serialize(balance))),
-			]),
-		);
-
 		transactionData.replaceCommand(index, commands);
 
-		transactionData.mapArguments((arg) => {
+		transactionData.mapArguments((arg, _command, commandIndex) => {
+			if (commandIndex >= index && commandIndex < index + commands.length) {
+				return arg;
+			}
+
 			if (arg.$kind === 'Result' && arg.Result === index) {
 				return {
 					$kind: 'NestedResult',
@@ -174,7 +268,7 @@ async function resolveCoinBalance(
 	return next();
 }
 
-async function getCoinsOfType({
+async function getCoinsAndBalanceOfType({
 	coinType,
 	balance,
 	client,
@@ -183,48 +277,74 @@ async function getCoinsOfType({
 }: {
 	coinType: string;
 	balance: bigint;
-	client: HaneulClient;
+	client: ClientWithCoreApi;
 	owner: string;
 	usedIds: Set<string>;
-}): Promise<CoinStruct[]> {
+}): Promise<{
+	coins: HaneulClientTypes.Coin[];
+	balance: bigint;
+	addressBalance: bigint;
+	coinBalance: bigint;
+}> {
 	let remainingBalance = balance;
-	const coins: CoinStruct[] = [];
+	const coins: HaneulClientTypes.Coin[] = [];
+	const balanceRequest = client.core.getBalance({ owner, coinType }).then(({ balance }) => {
+		remainingBalance -= BigInt(balance.addressBalance);
 
-	return loadMoreCoins();
+		return balance;
+	});
 
-	async function loadMoreCoins(cursor: string | null = null): Promise<CoinStruct[]> {
-		const { data, hasNextPage, nextCursor } = await client.getCoins({ owner, coinType, cursor });
+	const [allCoins, balanceResponse] = await Promise.all([loadMoreCoins(), balanceRequest]);
 
-		const sortedCoins = data.sort((a, b) => Number(BigInt(b.balance) - BigInt(a.balance)));
+	if (BigInt(balanceResponse.balance) < balance) {
+		throw new Error(
+			`Insufficient balance of ${coinType} for owner ${owner}. Required: ${balance}, Available: ${
+				balance - remainingBalance
+			}`,
+		);
+	}
 
-		for (const coin of sortedCoins) {
-			if (usedIds.has(coin.coinObjectId)) {
-				continue;
-			}
+	return {
+		coins: allCoins,
+		balance: BigInt(balanceResponse.coinBalance),
+		addressBalance: BigInt(balanceResponse.addressBalance),
+		coinBalance: BigInt(balanceResponse.coinBalance),
+	};
+
+	async function loadMoreCoins(cursor: string | null = null): Promise<HaneulClientTypes.Coin[]> {
+		const {
+			objects,
+			hasNextPage,
+			cursor: nextCursor,
+		} = await client.core.listCoins({
+			owner,
+			coinType,
+			cursor,
+		});
+
+		await balanceRequest;
 
-			const coinBalance = BigInt(coin.balance);
+		if (remainingBalance > 0n) {
+			for (const coin of objects) {
+				if (usedIds.has(coin.objectId)) {
+					continue;
+				}
 
-			coins.push(coin);
-			remainingBalance -= coinBalance;
+				const coinBalance = BigInt(coin.balance);
 
-			if (remainingBalance <= 0) {
-				return coins;
+				coins.push(coin);
+				remainingBalance -= coinBalance;
+
+				if (remainingBalance <= 0) {
+					break;
+				}
 			}
-		}
 
-		if (hasNextPage) {
-			return loadMoreCoins(nextCursor);
+			if (hasNextPage) {
+				return loadMoreCoins(nextCursor);
+			}
 		}
 
-		throw new Error(`Not enough coins of type ${coinType} to satisfy requested balance`);
+		return coins;
 	}
 }
-
-export function getHaneulClient(options: BuildTransactionOptions): HaneulClient {
-	const client = getClient(options) as HaneulClient;
-	if (!client.jsonRpc) {
-		throw new Error(`CoinWithBalance intent currently only works with HaneulClient`);
-	}
-
-	return client;
-}

package/src/transactions/object.ts

@@ -3,6 +3,13 @@
 
 import type { Transaction, TransactionObjectInput } from './Transaction.js';
 import { Inputs } from './Inputs.js';
+import {
+	MOVE_STDLIB_ADDRESS,
+	HANEUL_CLOCK_OBJECT_ID,
+	HANEUL_DENY_LIST_OBJECT_ID,
+	HANEUL_RANDOM_OBJECT_ID,
+	HANEUL_SYSTEM_STATE_OBJECT_ID,
+} from '../utils/index.js';
 
 export function createObjectMethods<T>(makeObject: (value: TransactionObjectInput) => T) {
 	function object(value: TransactionObjectInput) {
@@ -15,7 +22,7 @@ export function createObjectMethods<T>(makeObject: (value: TransactionObjectInpu
 		if (mutable !== undefined) {
 			return object(
 				Inputs.SharedObjectRef({
-					objectId: '0x5',
+					objectId: HANEUL_SYSTEM_STATE_OBJECT_ID,
 					initialSharedVersion: 1,
 					mutable,
 				}),
@@ -25,7 +32,7 @@ export function createObjectMethods<T>(makeObject: (value: TransactionObjectInpu
 		return object({
 			$kind: 'UnresolvedObject',
 			UnresolvedObject: {
-				objectId: '0x5',
+				objectId: HANEUL_SYSTEM_STATE_OBJECT_ID,
 				initialSharedVersion: 1,
 			},
 		});
@@ -33,7 +40,7 @@ export function createObjectMethods<T>(makeObject: (value: TransactionObjectInpu
 	object.clock = () =>
 		object(
 			Inputs.SharedObjectRef({
-				objectId: '0x6',
+				objectId: HANEUL_CLOCK_OBJECT_ID,
 				initialSharedVersion: 1,
 				mutable: false,
 			}),
@@ -42,7 +49,7 @@ export function createObjectMethods<T>(makeObject: (value: TransactionObjectInpu
 		object({
 			$kind: 'UnresolvedObject',
 			UnresolvedObject: {
-				objectId: '0x8',
+				objectId: HANEUL_RANDOM_OBJECT_ID,
 				mutable: false,
 			},
 		});
@@ -50,7 +57,7 @@ export function createObjectMethods<T>(makeObject: (value: TransactionObjectInpu
 		return object({
 			$kind: 'UnresolvedObject',
 			UnresolvedObject: {
-				objectId: '0x403',
+				objectId: HANEUL_DENY_LIST_OBJECT_ID,
 				mutable: options?.mutable,
 			},
 		});
@@ -60,7 +67,7 @@ export function createObjectMethods<T>(makeObject: (value: TransactionObjectInpu
 		(tx: Transaction) =>
 			tx.moveCall({
 				typeArguments: [type],
-				target: `0x1::option::${value === null ? 'none' : 'some'}`,
+				target: `${MOVE_STDLIB_ADDRESS}::option::${value === null ? 'none' : 'some'}`,
 				arguments: value === null ? [] : [tx.object(value)],
 			});