@haneullabs/haneul 2.5.2 → 2.13.0

package/src/transactions/intents/CoinWithBalance.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { InferInput } from 'valibot';
-import { bigint, object, parse, string } from 'valibot';
+import { bigint, object, optional, parse, picklist, string } from 'valibot';
 
 import { bcs } from '../../bcs/index.js';
 import { normalizeStructTag } from '../../utils/haneul-types.js';
@@ -15,10 +15,10 @@ import type { TransactionDataBuilder } from '../TransactionData.js';
 import type { ClientWithCoreApi, HaneulClientTypes } from '../../client/index.js';
 
 export const COIN_WITH_BALANCE = 'CoinWithBalance';
-const SUI_TYPE = normalizeStructTag('0x2::haneul::HANEUL');
+const HANEUL_TYPE = normalizeStructTag('0x2::haneul::HANEUL');
 
 export function coinWithBalance({
-	type = SUI_TYPE,
+	type = HANEUL_TYPE,
 	balance,
 	useGasCoin = true,
 }: {
@@ -41,8 +41,9 @@ export function coinWithBalance({
 				name: COIN_WITH_BALANCE,
 				inputs: {},
 				data: {
-					type: coinType === SUI_TYPE && useGasCoin ? 'gas' : coinType,
+					type: coinType === HANEUL_TYPE && useGasCoin ? 'gas' : coinType,
 					balance: BigInt(balance),
+					outputKind: 'coin',
 				} satisfies InferInput<typeof CoinWithBalanceData>,
 			}),
 		);
@@ -51,9 +52,45 @@ export function coinWithBalance({
 	};
 }
 
+export function createBalance({
+	type = HANEUL_TYPE,
+	balance,
+	useGasCoin = true,
+}: {
+	balance: bigint | number;
+	type?: string;
+	useGasCoin?: boolean;
+}): (tx: Transaction) => TransactionResult {
+	let balanceResult: TransactionResult | null = null;
+
+	return (tx: Transaction) => {
+		if (balanceResult) {
+			return balanceResult;
+		}
+
+		tx.addIntentResolver(COIN_WITH_BALANCE, resolveCoinBalance);
+		const coinType = type === 'gas' ? type : normalizeStructTag(type);
+
+		balanceResult = tx.add(
+			TransactionCommands.Intent({
+				name: COIN_WITH_BALANCE,
+				inputs: {},
+				data: {
+					type: coinType === HANEUL_TYPE && useGasCoin ? 'gas' : coinType,
+					balance: BigInt(balance),
+					outputKind: 'balance',
+				} satisfies InferInput<typeof CoinWithBalanceData>,
+			}),
+		);
+
+		return balanceResult;
+	};
+}
+
 const CoinWithBalanceData = object({
 	type: string(),
 	balance: bigint(),
+	outputKind: optional(picklist(['coin', 'balance'])),
 });
 
 export async function resolveCoinBalance(
@@ -61,24 +98,48 @@ export async function resolveCoinBalance(
 	buildOptions: BuildTransactionOptions,
 	next: () => Promise<void>,
 ) {
+	type IntentInfo = { balance: bigint; outputKind: 'coin' | 'balance' };
+
 	const coinTypes = new Set<string>();
 	const totalByType = new Map<string, bigint>();
+	const intentsByType = new Map<string, IntentInfo[]>();
 
 	if (!transactionData.sender) {
 		throw new Error('Sender must be set to resolve CoinWithBalance');
 	}
 
-	for (const command of transactionData.commands) {
-		if (command.$kind === '$Intent' && command.$Intent.name === COIN_WITH_BALANCE) {
-			const { type, balance } = parse(CoinWithBalanceData, command.$Intent.data);
+	// First pass: scan intents, collect per-type data, and resolve zero-balance intents in place.
+	for (const [i, command] of transactionData.commands.entries()) {
+		if (command.$kind !== '$Intent' || command.$Intent.name !== COIN_WITH_BALANCE) {
+			continue;
+		}
 
-			if (type !== 'gas' && balance > 0n) {
-				coinTypes.add(type);
-			}
+		const { type, balance, outputKind } = parse(CoinWithBalanceData, command.$Intent.data);
+
+		// Zero-balance intents are resolved immediately — no coins or AB needed.
+		// This is a 1:1 replacement so indices don't shift.
+		if (balance === 0n) {
+			const coinType = type === 'gas' ? HANEUL_TYPE : type;
+			transactionData.replaceCommand(
+				i,
+				TransactionCommands.MoveCall({
+					target: (outputKind ?? 'coin') === 'balance' ? '0x2::balance::zero' : '0x2::coin::zero',
+					typeArguments: [coinType],
+				}),
+			);
+			continue;
+		}
 
-			totalByType.set(type, (totalByType.get(type) ?? 0n) + balance);
+		if (type !== 'gas') {
+			coinTypes.add(type);
 		}
+
+		totalByType.set(type, (totalByType.get(type) ?? 0n) + balance);
+
+		if (!intentsByType.has(type)) intentsByType.set(type, []);
+		intentsByType.get(type)!.push({ balance, outputKind: outputKind ?? 'coin' });
 	}
+
 	const usedIds = new Set<string>();
 
 	for (const input of transactionData.inputs) {
@@ -117,7 +178,7 @@ export async function resolveCoinBalance(
 			? await client.core
 					.getBalance({
 						owner: transactionData.sender!,
-						coinType: SUI_TYPE,
+						coinType: HANEUL_TYPE,
 					})
 					.then(({ balance }) => {
 						addressBalanceByType.set('gas', BigInt(balance.addressBalance));
@@ -126,9 +187,17 @@ export async function resolveCoinBalance(
 	]);
 
 	const mergedCoins = new Map<string, Argument>();
+	const exactBalanceByType = new Map<string, boolean>();
+
+	// Per-type state for Path 2 combined splits
+	type TypeState = { results: Argument[]; nextIntent: number };
+	const typeState = new Map<string, TypeState>();
 
-	for (const [index, transaction] of transactionData.commands.entries()) {
+	let index = 0;
+	while (index < transactionData.commands.length) {
+		const transaction = transactionData.commands[index];
 		if (transaction.$kind !== '$Intent' || transaction.$Intent.name !== COIN_WITH_BALANCE) {
+			index++;
 			continue;
 		}
 
@@ -136,25 +205,23 @@ export async function resolveCoinBalance(
 			type: string;
 			balance: bigint;
 		};
-
-		if (balance === 0n) {
-			transactionData.replaceCommand(
-				index,
-				TransactionCommands.MoveCall({
-					target: '0x2::coin::zero',
-					typeArguments: [type === 'gas' ? SUI_TYPE : type],
-				}),
-			);
-			continue;
-		}
+		const coinType = type === 'gas' ? HANEUL_TYPE : type;
+		const totalRequired = totalByType.get(type)!;
+		const addressBalance = addressBalanceByType.get(type) ?? 0n;
 
 		const commands = [];
+		let intentResult: Argument;
+
+		const intentsForType = intentsByType.get(type) ?? [];
+		const allBalance = intentsForType.every((i) => i.outputKind === 'balance');
 
-		if (addressBalanceByType.get(type)! >= totalByType.get(type)!) {
+		if (allBalance && addressBalance >= totalRequired) {
+			// Path 1: All balance intents and AB sufficient — direct per-intent withdrawal.
+			// No coins touched, enables parallel execution.
 			commands.push(
 				TransactionCommands.MoveCall({
-					target: '0x2::coin::redeem_funds',
-					typeArguments: [type === 'gas' ? SUI_TYPE : type],
+					target: '0x2::balance::redeem_funds',
+					typeArguments: [coinType],
 					arguments: [
 						transactionData.addInput(
 							'withdrawal',
@@ -163,106 +230,170 @@ export async function resolveCoinBalance(
 									$kind: 'MaxAmountU64',
 									MaxAmountU64: String(balance),
 								},
-								typeArg: {
-									$kind: 'Balance',
-									Balance: type === 'gas' ? SUI_TYPE : type,
-								},
-								withdrawFrom: {
-									$kind: 'Sender',
-									Sender: true,
-								},
+								typeArg: { $kind: 'Balance', Balance: coinType },
+								withdrawFrom: { $kind: 'Sender', Sender: true },
 							}),
 						),
 					],
 				}),
 			);
+
+			intentResult = {
+				$kind: 'NestedResult',
+				NestedResult: [index + commands.length - 1, 0],
+			};
 		} else {
-			if (!mergedCoins.has(type)) {
-				const addressBalance = addressBalanceByType.get(type) ?? 0n;
-				const coinType = type === 'gas' ? SUI_TYPE : type;
+			// Path 2: Merge and Split — build a merged coin, split all intents at once.
 
-				let baseCoin: Argument;
-				let restCoins: Argument[];
+			if (!typeState.has(type)) {
+				const intents = intentsForType;
+
+				// Step 1: Build sources and merge
+				const sources: Argument[] = [];
 
 				if (type === 'gas') {
-					baseCoin = { $kind: 'GasCoin', GasCoin: true };
-					restCoins = [];
+					sources.push({ $kind: 'GasCoin', GasCoin: true });
 				} else {
-					[baseCoin, ...restCoins] = coinsByType.get(type)!.map((coin) =>
-						transactionData.addInput(
-							'object',
-							Inputs.ObjectRef({
-								objectId: coin.objectId,
-								digest: coin.digest,
-								version: coin.version,
+					const coins = coinsByType.get(type)!;
+					const loadedCoinBalance = coins.reduce((sum, c) => sum + BigInt(c.balance), 0n);
+					const abNeeded =
+						totalRequired > loadedCoinBalance ? totalRequired - loadedCoinBalance : 0n;
+
+					exactBalanceByType.set(type, loadedCoinBalance + abNeeded === totalRequired);
+
+					for (const coin of coins) {
+						sources.push(
+							transactionData.addInput(
+								'object',
+								Inputs.ObjectRef({
+									objectId: coin.objectId,
+									digest: coin.digest,
+									version: coin.version,
+								}),
+							),
+						);
+					}
+
+					if (abNeeded > 0n) {
+						commands.push(
+							TransactionCommands.MoveCall({
+								target: '0x2::coin::redeem_funds',
+								typeArguments: [coinType],
+								arguments: [
+									transactionData.addInput(
+										'withdrawal',
+										Inputs.FundsWithdrawal({
+											reservation: {
+												$kind: 'MaxAmountU64',
+												MaxAmountU64: String(abNeeded),
+											},
+											typeArg: { $kind: 'Balance', Balance: coinType },
+											withdrawFrom: { $kind: 'Sender', Sender: true },
+										}),
+									),
+								],
 							}),
-						),
-					);
+						);
+						sources.push({ $kind: 'Result', Result: index + commands.length - 1 });
+					}
 				}
 
-				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));
+				const baseCoin = sources[0];
+				const rest = sources.slice(1);
+				for (let i = 0; i < rest.length; i += 500) {
+					commands.push(TransactionCommands.MergeCoins(baseCoin, rest.slice(i, i + 500)));
 				}
 
 				mergedCoins.set(type, baseCoin);
+
+				// Step 2: Combined SplitCoins for all intents of this type
+				const splitCmdIndex = index + commands.length;
+				commands.push(
+					TransactionCommands.SplitCoins(
+						baseCoin,
+						intents.map((i) =>
+							transactionData.addInput('pure', Inputs.Pure(bcs.u64().serialize(i.balance))),
+						),
+					),
+				);
+
+				// Build per-intent results, adding into_balance conversions for balance intents
+				const results: Argument[] = [];
+				for (let i = 0; i < intents.length; i++) {
+					const splitResult: Argument = {
+						$kind: 'NestedResult',
+						NestedResult: [splitCmdIndex, i],
+					};
+
+					if (intents[i].outputKind === 'balance') {
+						commands.push(
+							TransactionCommands.MoveCall({
+								target: '0x2::coin::into_balance',
+								typeArguments: [coinType],
+								arguments: [splitResult],
+							}),
+						);
+						results.push({
+							$kind: 'NestedResult',
+							NestedResult: [index + commands.length - 1, 0],
+						});
+					} else {
+						results.push(splitResult);
+					}
+				}
+
+				typeState.set(type, { results, nextIntent: 0 });
 			}
 
-			commands.push(
-				TransactionCommands.SplitCoins(mergedCoins.get(type)!, [
-					transactionData.addInput('pure', Inputs.Pure(bcs.u64().serialize(balance))),
-				]),
-			);
+			const state = typeState.get(type)!;
+			intentResult = state.results[state.nextIntent++];
 		}
 
-		transactionData.replaceCommand(index, commands);
+		transactionData.replaceCommand(
+			index,
+			commands,
+			intentResult as { NestedResult: [number, number] },
+		);
 
-		transactionData.mapArguments((arg, _command, commandIndex) => {
-			if (commandIndex >= index && commandIndex < index + commands.length) {
-				return arg;
-			}
+		// Advance past the replacement. When commands is empty (subsequent intents
+		// of a combined split), the command was removed and the next command shifted
+		// into this position — so we stay at the same index.
+		index += commands.length;
+	}
 
-			if (arg.$kind === 'Result' && arg.Result === index) {
-				return {
-					$kind: 'NestedResult',
-					NestedResult: [index + commands.length - 1, 0],
-				};
-			}
+	// Step 3: Remainder handling
+	for (const [type, mergedCoin] of mergedCoins) {
+		if (type === 'gas') continue;
 
-			return arg;
-		});
+		const hasBalanceIntent = intentsByType.get(type)?.some((i) => i.outputKind === 'balance');
+
+		if (hasBalanceIntent) {
+			// Balance intents exist: send remainder coin back to sender's address balance.
+			// coin::send_funds is gasless-eligible and handles zero amounts.
+			transactionData.commands.push(
+				TransactionCommands.MoveCall({
+					target: '0x2::coin::send_funds',
+					typeArguments: [type],
+					arguments: [
+						mergedCoin,
+						transactionData.addInput(
+							'pure',
+							Inputs.Pure(bcs.Address.serialize(transactionData.sender!)),
+						),
+					],
+				}),
+			);
+		} else if (exactBalanceByType.get(type)) {
+			// Coin-only with exact match: destroy the zero-value dust coin.
+			transactionData.commands.push(
+				TransactionCommands.MoveCall({
+					target: '0x2::coin::destroy_zero',
+					typeArguments: [type],
+					arguments: [mergedCoin],
+				}),
+			);
+		}
+		// Coin-only with surplus: merged coin stays with sender as an owned object
 	}
 
 	return next();
@@ -324,25 +455,20 @@ async function getCoinsAndBalanceOfType({
 
 		await balanceRequest;
 
-		if (remainingBalance > 0n) {
-			for (const coin of objects) {
-				if (usedIds.has(coin.objectId)) {
-					continue;
-				}
-
-				const coinBalance = BigInt(coin.balance);
-
-				coins.push(coin);
-				remainingBalance -= coinBalance;
-
-				if (remainingBalance <= 0) {
-					break;
-				}
+		// Always load all coins from the page (except already-used ones).
+		// This merges all available coins rather than leaving dust.
+		for (const coin of objects) {
+			if (usedIds.has(coin.objectId)) {
+				continue;
 			}
 
-			if (hasNextPage) {
-				return loadMoreCoins(nextCursor);
-			}
+			coins.push(coin);
+			remainingBalance -= BigInt(coin.balance);
+		}
+
+		// Only paginate if loaded coins + AB are still insufficient
+		if (remainingBalance > 0n && hasNextPage) {
+			return loadMoreCoins(nextCursor);
 		}
 
 		return coins;

package/src/utils/coin-reservation.ts

@@ -0,0 +1,84 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fromBase58, fromHex, toBase58, toHex } from '@haneullabs/bcs';
+import { parse } from 'valibot';
+
+import { bcs, TypeTagSerializer } from '../bcs/index.js';
+import { ObjectRefSchema } from '../transactions/data/internal.js';
+import { deriveDynamicFieldID } from './dynamic-fields.js';
+import { normalizeHaneulAddress } from './index.js';
+
+const HANEUL_ACCUMULATOR_ROOT_OBJECT_ID = normalizeHaneulAddress('0xacc');
+const ACCUMULATOR_KEY_TYPE_TAG = TypeTagSerializer.parseFromStr(
+	'0x2::accumulator::Key<0x2::balance::Balance<0x2::haneul::HANEUL>>',
+);
+
+export const COIN_RESERVATION_MAGIC = new Uint8Array([
+	0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
+	0xac, 0xac, 0xac, 0xac,
+]);
+
+export function isCoinReservationDigest(digestBase58: string): boolean {
+	const digestBytes = fromBase58(digestBase58);
+	const last20Bytes = digestBytes.slice(12, 32);
+	return last20Bytes.every((byte, i) => byte === COIN_RESERVATION_MAGIC[i]);
+}
+
+export function parseCoinReservationBalance(digestBase58: string): bigint {
+	const digestBytes = fromBase58(digestBase58);
+	const view = new DataView(digestBytes.buffer, digestBytes.byteOffset, digestBytes.byteLength);
+	return view.getBigUint64(0, true);
+}
+
+/**
+ * Derives the accumulator dynamic field object ID for the given owner,
+ * then XORs it with the chain identifier bytes to produce the objectId
+ * for the coin reservation ref.
+ */
+function deriveReservationObjectId(owner: string, chainIdentifier: string): string {
+	const keyBcs = bcs.Address.serialize(owner).toBytes();
+	const accumulatorId = deriveDynamicFieldID(
+		HANEUL_ACCUMULATOR_ROOT_OBJECT_ID,
+		ACCUMULATOR_KEY_TYPE_TAG,
+		keyBcs,
+	);
+
+	// XOR the accumulator object ID bytes with the chain identifier bytes
+	const accBytes = fromHex(accumulatorId.slice(2));
+	const chainBytes = fromBase58(chainIdentifier);
+	if (chainBytes.length !== 32) {
+		throw new Error(`Invalid chain identifier length: expected 32 bytes, got ${chainBytes.length}`);
+	}
+	const xored = new Uint8Array(32);
+	for (let i = 0; i < 32; i++) {
+		xored[i] = accBytes[i] ^ chainBytes[i];
+	}
+	return `0x${toHex(xored)}`;
+}
+
+export function createCoinReservationRef(
+	reservedBalance: bigint,
+	owner: string,
+	chainIdentifier: string,
+	epoch: string,
+) {
+	const digestBytes = new Uint8Array(32);
+	const view = new DataView(digestBytes.buffer);
+	// Bytes 0-7: reserved balance as LE u64
+	view.setBigUint64(0, reservedBalance, true);
+	// Bytes 8-11: epoch_id as LE u32
+	const epochNum = Number(epoch);
+	if (!Number.isSafeInteger(epochNum) || epochNum < 0 || epochNum > 0xffffffff) {
+		throw new Error(`Epoch ${epoch} out of u32 range for coin reservation digest`);
+	}
+	view.setUint32(8, epochNum, true);
+	// Bytes 12-31: magic bytes
+	digestBytes.set(COIN_RESERVATION_MAGIC, 12);
+
+	return parse(ObjectRefSchema, {
+		objectId: deriveReservationObjectId(owner, chainIdentifier),
+		version: '0',
+		digest: toBase58(digestBytes),
+	});
+}

package/src/utils/constants.ts

@@ -18,5 +18,7 @@ export const HANEUL_SYSTEM_STATE_OBJECT_ID =
 	'0x0000000000000000000000000000000000000000000000000000000000000005';
 export const HANEUL_RANDOM_OBJECT_ID =
 	'0x0000000000000000000000000000000000000000000000000000000000000008';
+export const HANEUL_COIN_REGISTRY_OBJECT_ID =
+	'0x000000000000000000000000000000000000000000000000000000000000000c';
 export const HANEUL_DENY_LIST_OBJECT_ID =
 	'0x0000000000000000000000000000000000000000000000000000000000000403';

package/src/utils/haneul-types.ts

@@ -19,7 +19,7 @@ export function isValidTransactionDigest(value: string): value is string {
 
 // TODO - can we automatically sync this with rust length definition?
 // Source of truth is
-// https://github.com/GeunhwaJeong/haneul/blob/acb2b97ae21f47600e05b0d28127d88d0725561d/crate./haneul-types/src/base_types.rs#L67
+// https://github.com/GeunhwaJeong/haneul/blob/acb2b97ae21f47600e05b0d28127d88d0725561d/crates/haneul-types/src/base_types.rs#L67
 // which uses the Move account address length
 // https://github.com/move-language/move/blob/67ec40dc50c66c34fd73512fcc412f3b68d67235/language/move-core/types/src/account_address.rs#L23 .
 
@@ -97,6 +97,21 @@ export type StructTag = {
 };
 
 function parseTypeTag(type: string): string | StructTag {
+	if (type.startsWith('vector<')) {
+		if (!type.endsWith('>')) {
+			throw new Error(`Invalid type tag: ${type}`);
+		}
+		const inner = type.slice(7, -1);
+		if (!inner) {
+			throw new Error(`Invalid type tag: ${type}`);
+		}
+		const parsed = parseTypeTag(inner);
+		if (typeof parsed === 'string') {
+			return `vector<${parsed}>`;
+		}
+		return `vector<${normalizeStructTag(parsed)}>`;
+	}
+
 	if (!type.includes('::')) return type;
 
 	return parseStructTag(type);

package/src/utils/index.ts

@@ -28,6 +28,7 @@ export {
 	HANEUL_TYPE_ARG,
 	HANEUL_SYSTEM_STATE_OBJECT_ID,
 	HANEUL_RANDOM_OBJECT_ID,
+	HANEUL_COIN_REGISTRY_OBJECT_ID,
 	HANEUL_DENY_LIST_OBJECT_ID,
 } from './constants.js';
 

package/src/version.ts

@@ -3,5 +3,5 @@
 
 // This file is generated by genversion.mjs. Do not edit it directly.
 
-export const PACKAGE_VERSION = '2.5.2';
+export const PACKAGE_VERSION = '2.13.0';
 export const TARGETED_RPC_VERSION = '1.0.0';

package/src/zklogin/utils.ts

@@ -41,7 +41,7 @@ export function toBigEndianBytes(num: bigint, width: number): Uint8Array {
 }
 
 export function getExtendedEphemeralPublicKey(publicKey: PublicKey) {
-	return publicKey.toSuiPublicKey();
+	return publicKey.toHaneulPublicKey();
 }
 
 /**

package/dist/jsonRpc/rpc-websocket-client.d.mts

@@ -1,26 +0,0 @@
-//#region src/jsonRpc/rpc-websocket-client.d.ts
-
-/**
- * Configuration options for the websocket connection
- */
-type WebsocketClientOptions = {
-  /**
-   * Custom WebSocket class to use. Defaults to the global WebSocket class, if available.
-   */
-  WebSocketConstructor?: typeof WebSocket;
-  /**
-   * Milliseconds before timing out while calling an RPC method
-   */
-  callTimeout?: number;
-  /**
-   * Milliseconds between attempts to connect
-   */
-  reconnectTimeout?: number;
-  /**
-   * Maximum number of times to try connecting before giving up
-   */
-  maxReconnects?: number;
-};
-//#endregion
-export { WebsocketClientOptions };
-//# sourceMappingURL=rpc-websocket-client.d.mts.map

package/dist/jsonRpc/rpc-websocket-client.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpc-websocket-client.d.mts","names":[],"sources":["../../src/jsonRpc/rpc-websocket-client.ts"],"sourcesContent":[],"mappings":";;;;;KA8CY,sBAAA;;;;gCAImB"}