@haneullabs/haneul 2.5.1 → 2.13.0

package/src/bcs/effects.ts

@@ -5,7 +5,7 @@ import { bcs } from '@haneullabs/bcs';
 
 import { Address, ObjectDigest, Owner, HaneulObjectRef, TypeTag } from './bcs.js';
 
-// Rust: crate./haneul-types/src/execution_status.rs (PackageUpgradeError enum)
+// Rust: crates/haneul-types/src/execution_status.rs (PackageUpgradeError enum)
 const PackageUpgradeError = bcs.enum('PackageUpgradeError', {
 	UnableToFetchPackage: bcs.struct('UnableToFetchPackage', { packageId: Address }),
 	NotAPackage: bcs.struct('NotAPackage', { objectId: Address }),
@@ -23,7 +23,7 @@ const ModuleId = bcs.struct('ModuleId', {
 	address: Address,
 	name: bcs.string(),
 });
-// Rust: crate./haneul-types/src/execution_status.rs
+// Rust: crates/haneul-types/src/execution_status.rs
 const MoveLocation = bcs.struct('MoveLocation', {
 	module: ModuleId,
 	function: bcs.u16(),
@@ -31,7 +31,7 @@ const MoveLocation = bcs.struct('MoveLocation', {
 	functionName: bcs.option(bcs.string()),
 });
 
-// Rust: crate./haneul-types/src/execution_status.rs
+// Rust: crates/haneul-types/src/execution_status.rs
 const CommandArgumentError = bcs.enum('CommandArgumentError', {
 	TypeMismatch: null,
 	InvalidBCSBytes: null,
@@ -57,13 +57,13 @@ const CommandArgumentError = bcs.enum('CommandArgumentError', {
 	InvalidReferenceArgument: null,
 });
 
-// Rust: crate./haneul-types/src/execution_status.rs
+// Rust: crates/haneul-types/src/execution_status.rs
 const TypeArgumentError = bcs.enum('TypeArgumentError', {
 	TypeNotFound: null,
 	ConstraintNotSatisfied: null,
 });
 
-// Rust: crate./haneul-types/src/execution_status.rs
+// Rust: crates/haneul-types/src/execution_status.rs
 const ExecutionFailureStatus = bcs.enum('ExecutionFailureStatus', {
 	InsufficientGas: null,
 	InvalidGasObject: null,
@@ -145,7 +145,7 @@ const ExecutionFailureStatus = bcs.enum('ExecutionFailureStatus', {
 	}),
 });
 
-// Rust: crate./haneul-types/src/execution_status.rs
+// Rust: crates/haneul-types/src/execution_status.rs
 export const ExecutionStatus = bcs.enum('ExecutionStatus', {
 	Success: null,
 	Failure: bcs.struct('Failure', {
@@ -154,7 +154,7 @@ export const ExecutionStatus = bcs.enum('ExecutionStatus', {
 	}),
 });
 
-// Rust: crate./haneul-types/src/gas.rs
+// Rust: crates/haneul-types/src/gas.rs
 const GasCostSummary = bcs.struct('GasCostSummary', {
 	computationCost: bcs.u64(),
 	storageCost: bcs.u64(),
@@ -162,7 +162,7 @@ const GasCostSummary = bcs.struct('GasCostSummary', {
 	nonRefundableStorageFee: bcs.u64(),
 });
 
-// Rust: crate./haneul-types/src/effects/effects_v1.rs
+// Rust: crates/haneul-types/src/effects/effects_v1.rs
 const TransactionEffectsV1 = bcs.struct('TransactionEffectsV1', {
 	status: ExecutionStatus,
 	executedEpoch: bcs.u64(),
@@ -181,29 +181,29 @@ const TransactionEffectsV1 = bcs.struct('TransactionEffectsV1', {
 	dependencies: bcs.vector(ObjectDigest),
 });
 
-// Rust: crate./haneul-types/src/base_types.rs
+// Rust: crates/haneul-types/src/base_types.rs
 const VersionDigest = bcs.tuple([bcs.u64(), ObjectDigest]);
 
-// Rust: crate./haneul-types/src/effects/object_change.rs
+// Rust: crates/haneul-types/src/effects/object_change.rs
 const ObjectIn = bcs.enum('ObjectIn', {
 	NotExist: null,
 	Exist: bcs.tuple([VersionDigest, Owner]),
 });
 
-// Rust: crate./haneul-types/src/effects/object_change.rs
+// Rust: crates/haneul-types/src/effects/object_change.rs
 const AccumulatorAddress = bcs.struct('AccumulatorAddress', {
 	address: Address,
 	// TODO: ask why this is the name
 	ty: TypeTag,
 });
 
-// Rust: crate./haneul-types/src/effects/object_change.rs
+// Rust: crates/haneul-types/src/effects/object_change.rs
 const AccumulatorOperation = bcs.enum('AccumulatorOperation', {
 	Merge: null,
 	Split: null,
 });
 
-// Rust: crate./haneul-types/src/effects/object_change.rs
+// Rust: crates/haneul-types/src/effects/object_change.rs
 const AccumulatorValue = bcs.enum('AccumulatorValue', {
 	Integer: bcs.u64(),
 	IntegerTuple: bcs.tuple([bcs.u64(), bcs.u64()]),
@@ -211,14 +211,14 @@ const AccumulatorValue = bcs.enum('AccumulatorValue', {
 	EventDigest: bcs.vector(bcs.tuple([bcs.u64(), ObjectDigest])),
 });
 
-// Rust: crate./haneul-types/src/effects/object_change.rs
+// Rust: crates/haneul-types/src/effects/object_change.rs
 const AccumulatorWriteV1 = bcs.struct('AccumulatorWriteV1', {
 	address: AccumulatorAddress,
 	operation: AccumulatorOperation,
 	value: AccumulatorValue,
 });
 
-// Rust: crate./haneul-types/src/effects/object_change.rs
+// Rust: crates/haneul-types/src/effects/object_change.rs
 const ObjectOut = bcs.enum('ObjectOut', {
 	NotExist: null,
 	ObjectWrite: bcs.tuple([ObjectDigest, Owner]),
@@ -226,21 +226,21 @@ const ObjectOut = bcs.enum('ObjectOut', {
 	AccumulatorWriteV1: AccumulatorWriteV1,
 });
 
-// Rust: crate./haneul-types/src/effects/mod.rs
+// Rust: crates/haneul-types/src/effects/mod.rs
 const IDOperation = bcs.enum('IDOperation', {
 	None: null,
 	Created: null,
 	Deleted: null,
 });
 
-// Rust: crate./haneul-types/src/effects/object_change.rs
+// Rust: crates/haneul-types/src/effects/object_change.rs
 const EffectsObjectChange = bcs.struct('EffectsObjectChange', {
 	inputState: ObjectIn,
 	outputState: ObjectOut,
 	idOperation: IDOperation,
 });
 
-// Rust: crate./haneul-types/src/effects/effects_v2.rs
+// Rust: crates/haneul-types/src/effects/effects_v2.rs
 const UnchangedConsensusKind = bcs.enum('UnchangedConsensusKind', {
 	ReadOnlyRoot: VersionDigest,
 	MutateConsensusStreamEnded: bcs.u64(),
@@ -249,7 +249,7 @@ const UnchangedConsensusKind = bcs.enum('UnchangedConsensusKind', {
 	PerEpochConfig: null,
 });
 
-// Rust: crate./haneul-types/src/effects/effects_v2.rs
+// Rust: crates/haneul-types/src/effects/effects_v2.rs
 const TransactionEffectsV2 = bcs.struct('TransactionEffectsV2', {
 	status: ExecutionStatus,
 	executedEpoch: bcs.u64(),
@@ -264,7 +264,7 @@ const TransactionEffectsV2 = bcs.struct('TransactionEffectsV2', {
 	auxDataDigest: bcs.option(ObjectDigest),
 });
 
-// Rust: crate./haneul-types/src/effects/mod.rs
+// Rust: crates/haneul-types/src/effects/mod.rs
 export const TransactionEffects = bcs.enum('TransactionEffects', {
 	V1: TransactionEffectsV1,
 	V2: TransactionEffectsV2,

package/src/bcs/index.ts

@@ -57,7 +57,7 @@ export {
 	compareBcsBytes,
 } from '@haneullabs/bcs';
 
-const suiBcs = {
+const haneulBcs = {
 	...bcs,
 	U8: bcs.u8(),
 	U16: bcs.u16(),
@@ -114,4 +114,4 @@ export {
 	type PureTypeName,
 } from './pure.js';
 
-export { suiBcs as bcs };
+export { haneulBcs as bcs };

package/src/client/core-resolver.ts

@@ -1,11 +1,14 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { parse } from 'valibot';
-
-import { normalizeHaneulAddress, normalizeHaneulObjectId, HANEUL_TYPE_ARG } from '../utils/index.js';
+import {
+	normalizeHaneulAddress,
+	normalizeHaneulObjectId,
+	normalizeStructTag,
+	HANEUL_TYPE_ARG,
+} from '../utils/index.js';
+import { createCoinReservationRef } from '../utils/coin-reservation.js';
 import type { ClientWithCoreApi } from './core.js';
-import { ObjectRefSchema } from '../transactions/data/internal.js';
 import type { CallArg, Command } from '../transactions/data/internal.js';
 import type { HaneulClientTypes } from './types.js';
 import { SimulationError } from './errors.js';
@@ -38,36 +41,89 @@ export async function coreClientResolveTransactionPlugin(
 ) {
 	const client = getClient(options);
 
-	await normalizeInputs(transactionData, client);
-	await resolveObjectReferences(transactionData, client);
+	const needsGasPrice = !options.onlyTransactionKind && !transactionData.gasData.price;
+	const needsPayment = !options.onlyTransactionKind && !transactionData.gasData.payment;
+	const gasPayer = transactionData.gasData.owner ?? transactionData.sender;
 
-	if (!options.onlyTransactionKind) {
-		await setGasData(transactionData, client);
+	let usesGasCoin = false;
+	let withdrawals = 0n;
+
+	transactionData.mapArguments((arg) => {
+		if (arg.$kind === 'GasCoin') usesGasCoin = true;
+		return arg;
+	});
+
+	const normalizedGasPayer = gasPayer ? normalizeHaneulAddress(gasPayer) : null;
+	for (const input of transactionData.inputs) {
+		if (input.$kind !== 'FundsWithdrawal' || !normalizedGasPayer) continue;
+		if (normalizeStructTag(input.FundsWithdrawal.typeArg.Balance) !== HANEUL_TYPE_ARG) continue;
+
+		const withdrawalOwner = input.FundsWithdrawal.withdrawFrom.Sender
+			? transactionData.sender
+			: gasPayer;
+		if (
+			withdrawalOwner &&
+			normalizeHaneulAddress(withdrawalOwner) === normalizedGasPayer &&
+			input.FundsWithdrawal.reservation.$kind === 'MaxAmountU64'
+		) {
+			withdrawals += BigInt(input.FundsWithdrawal.reservation.MaxAmountU64);
+		}
 	}
 
-	return await next();
-}
+	const needsSystemState = needsGasPrice || (needsPayment && usesGasCoin);
+	const [, systemStateResult, balanceResult, coinsResult, protocolConfigResult, chainIdResult] =
+		await Promise.all([
+			normalizeInputs(transactionData, client),
+			needsSystemState ? client.core.getCurrentSystemState() : null,
+			needsPayment && gasPayer ? client.core.getBalance({ owner: gasPayer }) : null,
+			needsPayment && gasPayer
+				? client.core.listCoins({ owner: gasPayer, coinType: HANEUL_TYPE_ARG })
+				: null,
+			needsPayment && usesGasCoin ? client.core.getProtocolConfig() : null,
+			needsPayment && usesGasCoin ? client.core.getChainIdentifier() : null,
+		]);
 
-interface SystemStateData {
-	epoch: string;
-	referenceGasPrice: string;
-}
+	await resolveObjectReferences(transactionData, client);
 
-async function setGasData(transactionData: TransactionDataBuilder, client: ClientWithCoreApi) {
-	let systemState: SystemStateData | null = null;
+	if (!options.onlyTransactionKind) {
+		const systemState = systemStateResult?.systemState ?? null;
 
-	if (!transactionData.gasData.price) {
-		const response = await client.core.getCurrentSystemState();
-		systemState = response.systemState;
-		transactionData.gasData.price = systemState.referenceGasPrice;
-	}
+		if (systemState && !transactionData.gasData.price) {
+			transactionData.gasData.price = systemState.referenceGasPrice;
+		}
+
+		await setGasBudget(transactionData, client);
 
-	await setGasBudget(transactionData, client);
-	await setGasPayment(transactionData, client);
+		if (needsPayment) {
+			if (!balanceResult || !coinsResult) {
+				throw new Error(
+					'Could not resolve gas payment: a gas owner or sender must be set to fetch balance and coins.',
+				);
+			}
+			setGasPayment({
+				transactionData,
+				balance: balanceResult,
+				coins: coinsResult,
+				usesGasCoin,
+				withdrawals,
+				protocolConfig: protocolConfigResult?.protocolConfig,
+				gasPayer: gasPayer!,
+				chainIdentifier: chainIdResult?.chainIdentifier ?? null,
+				epoch: systemState?.epoch ?? null,
+			});
+		}
 
-	if (!transactionData.expiration) {
-		await setExpiration(transactionData, client, systemState);
+		if (!transactionData.expiration && transactionData.gasData.payment?.length === 0) {
+			await setExpiration(
+				transactionData,
+				client,
+				systemState,
+				chainIdResult?.chainIdentifier ?? null,
+			);
+		}
 	}
+
+	return await next();
 }
 
 async function setGasBudget(transactionData: TransactionDataBuilder, client: ClientWithCoreApi) {
@@ -109,95 +165,89 @@ async function setGasBudget(transactionData: TransactionDataBuilder, client: Cli
 	);
 }
 
-// The current default is just picking _all_ coins we can which may not be ideal.
-async function setGasPayment(transactionData: TransactionDataBuilder, client: ClientWithCoreApi) {
-	if (!transactionData.gasData.payment) {
-		const gasPayer = transactionData.gasData.owner ?? transactionData.sender!;
-		let usesGasCoin = false;
-		let withdrawals = 0n;
-
-		transactionData.mapArguments((arg) => {
-			if (arg.$kind === 'GasCoin') {
-				usesGasCoin = true;
-			} else if (arg.$kind === 'Input') {
-				const input = transactionData.inputs[arg.Input];
-
-				if (input.$kind === 'FundsWithdrawal') {
-					const withdrawalOwner = input.FundsWithdrawal.withdrawFrom.Sender
-						? transactionData.sender
-						: gasPayer;
-
-					if (withdrawalOwner === gasPayer) {
-						if (input.FundsWithdrawal.reservation.$kind === 'MaxAmountU64') {
-							withdrawals += BigInt(input.FundsWithdrawal.reservation.MaxAmountU64);
-						}
-					}
-				}
+function setGasPayment({
+	transactionData,
+	balance,
+	coins,
+	usesGasCoin,
+	withdrawals,
+	protocolConfig,
+	gasPayer,
+	chainIdentifier,
+	epoch,
+}: {
+	transactionData: TransactionDataBuilder;
+	balance: HaneulClientTypes.GetBalanceResponse;
+	coins: HaneulClientTypes.ListCoinsResponse;
+	usesGasCoin: boolean;
+	withdrawals: bigint;
+	protocolConfig: HaneulClientTypes.ProtocolConfig | undefined;
+	gasPayer: string;
+	chainIdentifier: string | null;
+	epoch: string | null;
+}) {
+	const budget = BigInt(transactionData.gasData.budget!);
+	const addressBalance = BigInt(balance.balance.addressBalance);
+
+	if (budget === 0n || (!usesGasCoin && addressBalance >= budget + withdrawals)) {
+		transactionData.gasData.payment = [];
+		return;
+	}
+
+	const filteredCoins = coins.objects.filter((coin) => {
+		const matchingInput = transactionData.inputs.find((input) => {
+			if (input.Object?.ImmOrOwnedObject) {
+				return coin.objectId === input.Object.ImmOrOwnedObject.objectId;
 			}
 
-			return arg;
+			return false;
 		});
 
-		const [suiBalance, coins] = await Promise.all([
-			usesGasCoin || !transactionData.gasData.owner
-				? null
-				: client.core.getBalance({
-						owner: transactionData.gasData.owner,
-					}),
-			client.core.listCoins({
-				owner: transactionData.gasData.owner || transactionData.sender!,
-				coinType: HANEUL_TYPE_ARG,
-			}),
-		]);
-
-		if (
-			suiBalance?.balance.addressBalance &&
-			BigInt(suiBalance.balance.addressBalance) >=
-				BigInt(transactionData.gasData.budget || '0') + withdrawals
-		) {
-			transactionData.gasData.payment = [];
-			return;
-		}
-
-		const paymentCoins = coins.objects
-			// Filter out coins that are also used as input:
-			.filter((coin) => {
-				const matchingInput = transactionData.inputs.find((input) => {
-					if (input.Object?.ImmOrOwnedObject) {
-						return coin.objectId === input.Object.ImmOrOwnedObject.objectId;
-					}
-
-					return false;
-				});
-
-				return !matchingInput;
-			})
-			.map((coin) =>
-				parse(ObjectRefSchema, {
-					objectId: coin.objectId,
-					digest: coin.digest,
-					version: coin.version,
-				}),
-			);
-
-		if (!paymentCoins.length) {
-			throw new Error('No valid gas coins found for the transaction.');
-		}
+		return !matchingInput;
+	});
 
+	const paymentCoins = filteredCoins.map((coin) => ({
+		objectId: coin.objectId,
+		digest: coin.digest,
+		version: coin.version,
+	}));
+
+	const reservationAmount = addressBalance - withdrawals;
+
+	if (
+		usesGasCoin &&
+		reservationAmount > 0n &&
+		protocolConfig?.featureFlags?.['enable_coin_reservation_obj_refs'] &&
+		chainIdentifier &&
+		epoch
+	) {
+		transactionData.gasData.payment = [
+			createCoinReservationRef(reservationAmount, gasPayer, chainIdentifier, epoch),
+			...paymentCoins,
+		];
+	} else if (!filteredCoins.length) {
+		throw new Error('No valid gas coins found for the transaction.');
+	} else {
 		transactionData.gasData.payment = paymentCoins;
 	}
 }
 
+interface SystemStateData {
+	epoch: string;
+	referenceGasPrice: string;
+}
+
 async function setExpiration(
 	transactionData: TransactionDataBuilder,
 	client: ClientWithCoreApi,
-	existingSystemState: SystemStateData | null,
+	systemState: SystemStateData | null,
+	existingChainIdentifier: string | null = null,
 ) {
-	const [systemState, { chainIdentifier }] = await Promise.all([
-		existingSystemState ?? client.core.getCurrentSystemState().then((r) => r.systemState),
-		client.core.getChainIdentifier(),
+	const [chainIdentifier, resolvedSystemState] = await Promise.all([
+		existingChainIdentifier ?? client.core.getChainIdentifier().then((r) => r.chainIdentifier),
+		systemState ?? client.core.getCurrentSystemState().then((r) => r.systemState),
 	]);
-	const currentEpoch = BigInt(systemState.epoch);
+	const currentEpoch = BigInt(resolvedSystemState.epoch);
 
 	transactionData.expiration = {
 		$kind: 'ValidDuring',

package/src/client/core.ts

@@ -39,11 +39,11 @@ export abstract class CoreClient extends BaseClient implements HaneulClientTypes
 		});
 	}
 
-	abstract getObjects<Include extends HaneulClientTypes.ObjectInclude = object>(
+	abstract getObjects<Include extends HaneulClientTypes.ObjectInclude = {}>(
 		options: HaneulClientTypes.GetObjectsOptions<Include>,
 	): Promise<HaneulClientTypes.GetObjectsResponse<Include>>;
 
-	async getObject<Include extends HaneulClientTypes.ObjectInclude = object>(
+	async getObject<Include extends HaneulClientTypes.ObjectInclude = {}>(
 		options: HaneulClientTypes.GetObjectOptions<Include>,
 	): Promise<HaneulClientTypes.GetObjectResponse<Include>> {
 		const { objectId } = options;
@@ -64,7 +64,7 @@ export abstract class CoreClient extends BaseClient implements HaneulClientTypes
 		options: HaneulClientTypes.ListCoinsOptions,
 	): Promise<HaneulClientTypes.ListCoinsResponse>;
 
-	abstract listOwnedObjects<Include extends HaneulClientTypes.ObjectInclude = object>(
+	abstract listOwnedObjects<Include extends HaneulClientTypes.ObjectInclude = {}>(
 		options: HaneulClientTypes.ListOwnedObjectsOptions<Include>,
 	): Promise<HaneulClientTypes.ListOwnedObjectsResponse<Include>>;
 
@@ -80,15 +80,15 @@ export abstract class CoreClient extends BaseClient implements HaneulClientTypes
 		options: HaneulClientTypes.GetCoinMetadataOptions,
 	): Promise<HaneulClientTypes.GetCoinMetadataResponse>;
 
-	abstract getTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
+	abstract getTransaction<Include extends HaneulClientTypes.TransactionInclude = {}>(
 		options: HaneulClientTypes.GetTransactionOptions<Include>,
 	): Promise<HaneulClientTypes.TransactionResult<Include>>;
 
-	abstract executeTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
+	abstract executeTransaction<Include extends HaneulClientTypes.TransactionInclude = {}>(
 		options: HaneulClientTypes.ExecuteTransactionOptions<Include>,
 	): Promise<HaneulClientTypes.TransactionResult<Include>>;
 
-	abstract simulateTransaction<Include extends HaneulClientTypes.SimulateTransactionInclude = object>(
+	abstract simulateTransaction<Include extends HaneulClientTypes.SimulateTransactionInclude = {}>(
 		options: HaneulClientTypes.SimulateTransactionOptions<Include>,
 	): Promise<HaneulClientTypes.SimulateTransactionResult<Include>>;
 
@@ -100,6 +100,10 @@ export abstract class CoreClient extends BaseClient implements HaneulClientTypes
 		options?: HaneulClientTypes.GetCurrentSystemStateOptions,
 	): Promise<HaneulClientTypes.GetCurrentSystemStateResponse>;
 
+	abstract getProtocolConfig(
+		options?: HaneulClientTypes.GetProtocolConfigOptions,
+	): Promise<HaneulClientTypes.GetProtocolConfigResponse>;
+
 	abstract getChainIdentifier(
 		options?: HaneulClientTypes.GetChainIdentifierOptions,
 	): Promise<HaneulClientTypes.GetChainIdentifierResponse>;
@@ -151,8 +155,22 @@ export abstract class CoreClient extends BaseClient implements HaneulClientTypes
 		const fieldType = parseStructTag(fieldObject.type);
 		const content = await fieldObject.content;
 
+		const nameTypeParam = fieldType.typeParams[0];
+		const isDynamicObject =
+			typeof nameTypeParam !== 'string' &&
+			nameTypeParam.module === 'dynamic_object_field' &&
+			nameTypeParam.name === 'Wrapper';
+
+		const valueBcs = content.slice(HANEUL_ADDRESS_LENGTH + options.name.bcs.length);
+
+		const valueType =
+			typeof fieldType.typeParams[1] === 'string'
+				? fieldType.typeParams[1]
+				: normalizeStructTag(fieldType.typeParams[1]);
+
 		return {
 			dynamicField: {
+				$kind: isDynamicObject ? 'DynamicObject' : 'DynamicField',
 				fieldId: fieldObject.objectId,
 				digest: fieldObject.digest,
 				version: fieldObject.version,
@@ -160,23 +178,19 @@ export abstract class CoreClient extends BaseClient implements HaneulClientTypes
 				previousTransaction: fieldObject.previousTransaction,
 				name: {
 					type:
-						typeof fieldType.typeParams[0] === 'string'
-							? fieldType.typeParams[0]
-							: normalizeStructTag(fieldType.typeParams[0]),
+						typeof nameTypeParam === 'string' ? nameTypeParam : normalizeStructTag(nameTypeParam),
 					bcs: options.name.bcs,
 				},
 				value: {
-					type:
-						typeof fieldType.typeParams[1] === 'string'
-							? fieldType.typeParams[1]
-							: normalizeStructTag(fieldType.typeParams[1]),
-					bcs: content.slice(HANEUL_ADDRESS_LENGTH + options.name.bcs.length),
+					type: valueType,
+					bcs: valueBcs,
 				},
-			},
+				childId: isDynamicObject ? bcs.Address.parse(valueBcs) : undefined,
+			} as HaneulClientTypes.GetDynamicFieldResponse['dynamicField'],
 		};
 	}
 
-	async getDynamicObjectField<Include extends HaneulClientTypes.ObjectInclude = object>(
+	async getDynamicObjectField<Include extends HaneulClientTypes.ObjectInclude = {}>(
 		options: HaneulClientTypes.GetDynamicObjectFieldOptions<Include>,
 	): Promise<HaneulClientTypes.GetDynamicObjectFieldResponse<Include>> {
 		const resolvedNameType = (
@@ -196,7 +210,7 @@ export abstract class CoreClient extends BaseClient implements HaneulClientTypes
 		});
 
 		const { object } = await this.getObject({
-			objectId: bcs.Address.parse(dynamicField.value.bcs),
+			objectId: dynamicField.childId!,
 			signal: options.signal,
 			include: options.include,
 		});
@@ -204,10 +218,10 @@ export abstract class CoreClient extends BaseClient implements HaneulClientTypes
 		return { object };
 	}
 
-	async waitForTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
+	async waitForTransaction<Include extends HaneulClientTypes.TransactionInclude = {}>(
 		options: HaneulClientTypes.WaitForTransactionOptions<Include>,
 	): Promise<HaneulClientTypes.TransactionResult<Include>> {
-		const { signal, timeout = 60 * 1000, include } = options;
+		const { signal, timeout = 60 * 1000, pollSchedule, include } = options;
 
 		const digest =
 			'result' in options && options.result
@@ -226,7 +240,35 @@ export abstract class CoreClient extends BaseClient implements HaneulClientTypes
 			// Swallow unhandled rejections that might be thrown after early return
 		});
 
+		// Default schedule tuned to testnet measurements:
+		// - Fullnode (gRPC/JSON-RPC): p50=130ms, p95=330ms
+		// - GraphQL indexer: p50=1300ms, p95=1430ms
+		// After schedule exhausted, repeats the last interval.
+		const schedule = pollSchedule ?? [0, 300, 600, 1500, 3500];
+		const t0 = Date.now();
+		let scheduleIndex = 0;
+		const lastInterval =
+			schedule.length > 0
+				? schedule[schedule.length - 1] - (schedule[schedule.length - 2] ?? 0)
+				: 2_000;
+
 		while (true) {
+			if (scheduleIndex < schedule.length) {
+				const remaining = t0 + schedule[scheduleIndex] - Date.now();
+				scheduleIndex++;
+				if (remaining > 0) {
+					await Promise.race([
+						new Promise((resolve) => setTimeout(resolve, remaining)),
+						abortPromise,
+					]);
+				}
+			} else {
+				await Promise.race([
+					new Promise((resolve) => setTimeout(resolve, lastInterval)),
+					abortPromise,
+				]);
+			}
+
 			abortSignal.throwIfAborted();
 			try {
 				return await this.getTransaction({
@@ -234,9 +276,7 @@ export abstract class CoreClient extends BaseClient implements HaneulClientTypes
 					include,
 					signal: abortSignal,
 				});
-			} catch {
-				await Promise.race([new Promise((resolve) => setTimeout(resolve, 2_000)), abortPromise]);
-			}
+			} catch {}
 		}
 	}