@haneullabs/haneul 0.1.0 → 2.5.0

package/src/grpc/core.ts

@@ -1,26 +1,36 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type {
-	Experimental_CoreClientOptions,
-	Experimental_HaneulClientTypes,
-} from '../experimental/index.js';
-import { Experimental_CoreClient } from '../experimental/index.js';
-import type { SuiGrpcClient } from './client.js';
+import type { CoreClientOptions, HaneulClientTypes } from '../client/index.js';
+import { CoreClient, formatMoveAbortMessage, SimulationError } from '../client/index.js';
+import type { HaneulGrpcClient } from './client.js';
 import type { Owner } from './proto/haneul/rpc/v2/owner.js';
 import { Owner_OwnerKind } from './proto/haneul/rpc/v2/owner.js';
+import { DynamicField_DynamicFieldKind } from './proto/haneul/rpc/v2/state_service.js';
 import { chunk, fromBase64, toBase64 } from '@haneullabs/utils';
 import type { ExecutedTransaction } from './proto/haneul/rpc/v2/executed_transaction.js';
 import type { TransactionEffects } from './proto/haneul/rpc/v2/effects.js';
-import { UnchangedConsensusObject_UnchangedConsensusObjectKind } from './proto/haneul/rpc/v2/effects.js';
 import {
+	UnchangedConsensusObject_UnchangedConsensusObjectKind,
 	ChangedObject_IdOperation,
 	ChangedObject_InputObjectState,
 	ChangedObject_OutputObjectState,
 } from './proto/haneul/rpc/v2/effects.js';
+import type {
+	ExecutionError as GrpcExecutionError,
+	MoveAbort as GrpcMoveAbort,
+} from './proto/haneul/rpc/v2/execution_status.js';
+import {
+	ExecutionError_ExecutionErrorKind,
+	CommandArgumentError_CommandArgumentErrorKind,
+	TypeArgumentError_TypeArgumentErrorKind,
+	PackageUpgradeError_PackageUpgradeErrorKind,
+} from './proto/haneul/rpc/v2/execution_status.js';
 import type { BuildTransactionOptions } from '../transactions/index.js';
 import { TransactionDataBuilder } from '../transactions/index.js';
 import { bcs } from '../bcs/index.js';
+import { normalizeStructTag, normalizeHaneulAddress } from '../utils/haneul-types.js';
+import { HANEUL_TYPE_ARG } from '../utils/constants.js';
 import type { OpenSignature, OpenSignatureBody } from './proto/haneul/rpc/v2/move_package.js';
 import {
 	Ability,
@@ -28,62 +38,92 @@ import {
 	OpenSignature_Reference,
 	OpenSignatureBody_Type,
 } from './proto/haneul/rpc/v2/move_package.js';
-export interface GrpcCoreClientOptions extends Experimental_CoreClientOptions {
-	client: SuiGrpcClient;
+import {
+	applyGrpcResolvedTransaction,
+	transactionDataToGrpcTransaction,
+	transactionToGrpcTransaction,
+	grpcTransactionToTransactionData,
+} from '../client/transaction-resolver.js';
+import { Value } from './proto/google/protobuf/struct.js';
+
+export interface GrpcCoreClientOptions extends CoreClientOptions {
+	client: HaneulGrpcClient;
 }
-export class GrpcCoreClient extends Experimental_CoreClient {
-	#client: SuiGrpcClient;
+export class GrpcCoreClient extends CoreClient {
+	#client: HaneulGrpcClient;
 	constructor({ client, ...options }: GrpcCoreClientOptions) {
 		super(options);
 		this.#client = client;
 	}
 
-	async getObjects(
-		options: Experimental_HaneulClientTypes.GetObjectsOptions,
-	): Promise<Experimental_HaneulClientTypes.GetObjectsResponse> {
+	async getObjects<Include extends HaneulClientTypes.ObjectInclude = object>(
+		options: HaneulClientTypes.GetObjectsOptions<Include>,
+	): Promise<HaneulClientTypes.GetObjectsResponse<Include>> {
 		const batches = chunk(options.objectIds, 50);
-		const results: Experimental_HaneulClientTypes.GetObjectsResponse['objects'] = [];
+		const results: HaneulClientTypes.GetObjectsResponse<Include>['objects'] = [];
+
+		const paths = ['owner', 'object_type', 'digest', 'version', 'object_id'];
+		if (options.include?.content) {
+			paths.push('contents');
+		}
+		if (options.include?.previousTransaction) {
+			paths.push('previous_transaction');
+		}
+		if (options.include?.objectBcs) {
+			paths.push('bcs');
+		}
+		if (options.include?.json) {
+			paths.push('json');
+		}
 
 		for (const batch of batches) {
 			const response = await this.#client.ledgerService.batchGetObjects({
 				requests: batch.map((id) => ({ objectId: id })),
 				readMask: {
-					paths: [
-						'owner',
-						'object_type',
-						'bcs',
-						'digest',
-						'version',
-						'object_id',
-						'previous_transaction',
-					],
+					paths,
 				},
 			});
 
 			results.push(
-				...response.response.objects.map(
-					(object): Experimental_HaneulClientTypes.ObjectResponse | Error => {
-						if (object.result.oneofKind === 'error') {
-							// TODO: improve error handling
-							return new Error(object.result.error.message);
-						}
+				...response.response.objects.map((object): HaneulClientTypes.Object<Include> | Error => {
+					if (object.result.oneofKind === 'error') {
+						// TODO: improve error handling
+						return new Error(object.result.error.message);
+					}
 
-						if (object.result.oneofKind !== 'object') {
-							return new Error('Unexpected result type');
-						}
+					if (object.result.oneofKind !== 'object') {
+						return new Error('Unexpected result type');
+					}
 
-						return {
-							id: object.result.object.objectId!,
-							version: object.result.object.version?.toString()!,
-							digest: object.result.object.digest!,
-							// TODO: bcs content is not returned in all cases
-							content: Promise.resolve(object.result.object.bcs?.value!),
-							owner: mapOwner(object.result.object.owner)!,
-							type: object.result.object.objectType!,
-							previousTransaction: object.result.object.previousTransaction ?? null,
-						};
-					},
-				),
+					const bcsContent = object.result.object.contents?.value ?? undefined;
+					const objectBcs = object.result.object.bcs?.value ?? undefined;
+
+					// Package objects have type "package" which is not a struct tag, so don't normalize it
+					const objectType = object.result.object.objectType;
+					const type =
+						objectType && objectType.includes('::')
+							? normalizeStructTag(objectType)
+							: (objectType ?? '');
+
+					const jsonContent = options.include?.json
+						? object.result.object.json
+							? (Value.toJson(object.result.object.json) as Record<string, unknown>)
+							: null
+						: undefined;
+
+					return {
+						objectId: object.result.object.objectId!,
+						version: object.result.object.version?.toString()!,
+						digest: object.result.object.digest!,
+						content: bcsContent as HaneulClientTypes.Object<Include>['content'],
+						owner: mapOwner(object.result.object.owner)!,
+						type,
+						previousTransaction: (object.result.object.previousTransaction ??
+							undefined) as HaneulClientTypes.Object<Include>['previousTransaction'],
+						objectBcs: objectBcs as HaneulClientTypes.Object<Include>['objectBcs'],
+						json: jsonContent as HaneulClientTypes.Object<Include>['json'],
+					};
+				}),
 			);
 		}
 
@@ -91,44 +131,51 @@ export class GrpcCoreClient extends Experimental_CoreClient {
 			objects: results,
 		};
 	}
-	async getOwnedObjects(
-		options: Experimental_HaneulClientTypes.GetOwnedObjectsOptions,
-	): Promise<Experimental_HaneulClientTypes.GetOwnedObjectsResponse> {
+	async listOwnedObjects<Include extends HaneulClientTypes.ObjectInclude = object>(
+		options: HaneulClientTypes.ListOwnedObjectsOptions<Include>,
+	): Promise<HaneulClientTypes.ListOwnedObjectsResponse<Include>> {
+		const paths = ['owner', 'object_type', 'digest', 'version', 'object_id'];
+		if (options.include?.content) {
+			paths.push('contents');
+		}
+		if (options.include?.previousTransaction) {
+			paths.push('previous_transaction');
+		}
+		if (options.include?.objectBcs) {
+			paths.push('bcs');
+		}
+		if (options.include?.json) {
+			paths.push('json');
+		}
+
 		const response = await this.#client.stateService.listOwnedObjects({
-			owner: options.address,
+			owner: options.owner,
 			objectType: options.type
 				? (await this.mvr.resolveType({ type: options.type })).type
 				: undefined,
 			pageToken: options.cursor ? fromBase64(options.cursor) : undefined,
+			pageSize: options.limit,
 			readMask: {
-				paths: [
-					'owner',
-					'object_type',
-					'bcs',
-					'digest',
-					'version',
-					'object_id',
-					'previous_transaction',
-				],
+				paths,
 			},
 		});
 
 		const objects = response.response.objects.map(
-			(object): Experimental_HaneulClientTypes.ObjectResponse => ({
-				id: object.objectId!,
+			(object): HaneulClientTypes.Object<Include> => ({
+				objectId: object.objectId!,
 				version: object.version?.toString()!,
 				digest: object.digest!,
-				// TODO: List owned objects doesn't return content right now
-				get content() {
-					return object.bcs?.value
-						? Promise.resolve(object.bcs.value)
-						: Promise.reject(
-								new Error('GRPC does not return object contents when listing owned objects'),
-							);
-				},
+				content: object.contents?.value as HaneulClientTypes.Object<Include>['content'],
 				owner: mapOwner(object.owner)!,
 				type: object.objectType!,
-				previousTransaction: object.previousTransaction ?? null,
+				previousTransaction: (object.previousTransaction ??
+					undefined) as HaneulClientTypes.Object<Include>['previousTransaction'],
+				objectBcs: object.bcs?.value as HaneulClientTypes.Object<Include>['objectBcs'],
+				json: (options.include?.json
+					? object.json
+						? (Value.toJson(object.json) as Record<string, unknown>)
+						: null
+					: undefined) as HaneulClientTypes.Object<Include>['json'],
 			}),
 		);
 
@@ -138,45 +185,30 @@ export class GrpcCoreClient extends Experimental_CoreClient {
 			hasNextPage: response.response.nextPageToken !== undefined,
 		};
 	}
-	async getCoins(
-		options: Experimental_HaneulClientTypes.GetCoinsOptions,
-	): Promise<Experimental_HaneulClientTypes.GetCoinsResponse> {
+	async listCoins(
+		options: HaneulClientTypes.ListCoinsOptions,
+	): Promise<HaneulClientTypes.ListCoinsResponse> {
+		const paths = ['owner', 'object_type', 'digest', 'version', 'object_id', 'balance'];
+		const coinType = options.coinType ?? HANEUL_TYPE_ARG;
+
 		const response = await this.#client.stateService.listOwnedObjects({
-			owner: options.address,
-			objectType: `0x2::coin::Coin<${(await this.mvr.resolveType({ type: options.coinType })).type}>`,
+			owner: options.owner,
+			objectType: `0x2::coin::Coin<${(await this.mvr.resolveType({ type: coinType })).type}>`,
 			pageToken: options.cursor ? fromBase64(options.cursor) : undefined,
 			readMask: {
-				paths: [
-					'owner',
-					'object_type',
-					'bcs',
-					'digest',
-					'version',
-					'object_id',
-					'balance',
-					'previous_transaction',
-				],
+				paths,
 			},
 		});
 
 		return {
 			objects: response.response.objects.map(
-				(object): Experimental_HaneulClientTypes.CoinResponse => ({
-					id: object.objectId!,
+				(object): HaneulClientTypes.Coin => ({
+					objectId: object.objectId!,
 					version: object.version?.toString()!,
 					digest: object.digest!,
-					// TODO: List owned objects doesn't return content right now
-					get content() {
-						return object.bcs?.value
-							? Promise.resolve(object.bcs.value)
-							: Promise.reject(
-									new Error('GRPC does not return object contents when listing owned objects'),
-								);
-					},
 					owner: mapOwner(object.owner)!,
 					type: object.objectType!,
 					balance: object.balance?.toString()!,
-					previousTransaction: object.previousTransaction ?? null,
 				}),
 			),
 			cursor: response.response.nextPageToken ? toBase64(response.response.nextPageToken) : null,
@@ -185,26 +217,59 @@ export class GrpcCoreClient extends Experimental_CoreClient {
 	}
 
 	async getBalance(
-		options: Experimental_HaneulClientTypes.GetBalanceOptions,
-	): Promise<Experimental_HaneulClientTypes.GetBalanceResponse> {
+		options: HaneulClientTypes.GetBalanceOptions,
+	): Promise<HaneulClientTypes.GetBalanceResponse> {
+		const coinType = options.coinType ?? HANEUL_TYPE_ARG;
 		const result = await this.#client.stateService.getBalance({
-			owner: options.address,
-			coinType: (await this.mvr.resolveType({ type: options.coinType })).type,
+			owner: options.owner,
+			coinType: (await this.mvr.resolveType({ type: coinType })).type,
 		});
 
 		return {
 			balance: {
 				balance: result.response.balance?.balance?.toString() ?? '0',
-				coinType: result.response.balance?.coinType ?? options.coinType,
+				coinType: result.response.balance?.coinType ?? coinType,
+				coinBalance: result.response.balance?.coinBalance?.toString() ?? '0',
+				addressBalance: result.response.balance?.addressBalance?.toString() ?? '0',
+			},
+		};
+	}
+
+	async getCoinMetadata(
+		options: HaneulClientTypes.GetCoinMetadataOptions,
+	): Promise<HaneulClientTypes.GetCoinMetadataResponse> {
+		const coinType = (await this.mvr.resolveType({ type: options.coinType })).type;
+
+		let response;
+		try {
+			({ response } = await this.#client.stateService.getCoinInfo({
+				coinType,
+			}));
+		} catch {
+			return { coinMetadata: null };
+		}
+
+		if (!response.metadata) {
+			return { coinMetadata: null };
+		}
+
+		return {
+			coinMetadata: {
+				id: response.metadata.id ?? null,
+				decimals: response.metadata.decimals ?? 0,
+				name: response.metadata.name ?? '',
+				symbol: response.metadata.symbol ?? '',
+				description: response.metadata.description ?? '',
+				iconUrl: response.metadata.iconUrl ?? null,
 			},
 		};
 	}
 
-	async getAllBalances(
-		options: Experimental_HaneulClientTypes.GetAllBalancesOptions,
-	): Promise<Experimental_HaneulClientTypes.GetAllBalancesResponse> {
+	async listBalances(
+		options: HaneulClientTypes.ListBalancesOptions,
+	): Promise<HaneulClientTypes.ListBalancesResponse> {
 		const result = await this.#client.stateService.listBalances({
-			owner: options.address,
+			owner: options.owner,
 			pageToken: options.cursor ? fromBase64(options.cursor) : undefined,
 			pageSize: options.limit,
 		});
@@ -215,26 +280,82 @@ export class GrpcCoreClient extends Experimental_CoreClient {
 			balances: result.response.balances.map((balance) => ({
 				balance: balance.balance?.toString() ?? '0',
 				coinType: balance.coinType!,
+				coinBalance: balance.coinBalance?.toString() ?? '0',
+				addressBalance: balance.addressBalance?.toString() ?? '0',
 			})),
 		};
 	}
-	async getTransaction(
-		options: Experimental_HaneulClientTypes.GetTransactionOptions,
-	): Promise<Experimental_HaneulClientTypes.GetTransactionResponse> {
+	async getTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
+		options: HaneulClientTypes.GetTransactionOptions<Include>,
+	): Promise<HaneulClientTypes.TransactionResult<Include>> {
+		const paths = ['digest', 'transaction.digest', 'signatures', 'effects.status'];
+		if (options.include?.transaction) {
+			paths.push(
+				'transaction.sender',
+				'transaction.gas_payment',
+				'transaction.expiration',
+				'transaction.kind',
+			);
+		}
+		if (options.include?.bcs) {
+			paths.push('transaction.bcs');
+		}
+		if (options.include?.balanceChanges) {
+			paths.push('balance_changes');
+		}
+		if (options.include?.effects) {
+			paths.push('effects');
+		}
+		if (options.include?.events) {
+			paths.push('events');
+		}
+		if (options.include?.objectTypes) {
+			paths.push('effects.changed_objects.object_type');
+			paths.push('effects.changed_objects.object_id');
+		}
+
 		const { response } = await this.#client.ledgerService.getTransaction({
 			digest: options.digest,
 			readMask: {
-				paths: ['digest', 'transaction', 'effects', 'signatures', 'balance_changes'],
+				paths,
 			},
 		});
 
-		return {
-			transaction: parseTransaction(response.transaction!),
-		};
+		if (!response.transaction) {
+			throw new Error(`Transaction ${options.digest} not found`);
+		}
+
+		return parseTransaction(response.transaction, options.include);
 	}
-	async executeTransaction(
-		options: Experimental_HaneulClientTypes.ExecuteTransactionOptions,
-	): Promise<Experimental_HaneulClientTypes.ExecuteTransactionResponse> {
+	async executeTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
+		options: HaneulClientTypes.ExecuteTransactionOptions<Include>,
+	): Promise<HaneulClientTypes.TransactionResult<Include>> {
+		const paths = ['digest', 'transaction.digest', 'signatures', 'effects.status'];
+		if (options.include?.transaction) {
+			paths.push(
+				'transaction.sender',
+				'transaction.gas_payment',
+				'transaction.expiration',
+				'transaction.kind',
+			);
+		}
+		if (options.include?.bcs) {
+			paths.push('transaction.bcs');
+		}
+		if (options.include?.balanceChanges) {
+			paths.push('balance_changes');
+		}
+		if (options.include?.effects) {
+			paths.push('effects');
+		}
+		if (options.include?.events) {
+			paths.push('events');
+		}
+		if (options.include?.objectTypes) {
+			paths.push('effects.changed_objects.object_type');
+			paths.push('effects.changed_objects.object_id');
+		}
+
 		const { response } = await this.#client.transactionExecutionService.executeTransaction({
 			transaction: {
 				bcs: {
@@ -250,82 +371,242 @@ export class GrpcCoreClient extends Experimental_CoreClient {
 				},
 			})),
 			readMask: {
-				paths: [
-					'transaction.digest',
-					'transaction.transaction',
-					'transaction.effects',
-					'transaction.signatures',
-					'transaction.balance_changes',
-				],
+				paths,
 			},
 		});
-		return {
-			transaction: parseTransaction(response.transaction!),
-		};
+
+		return parseTransaction(response.transaction!, options.include);
 	}
-	async dryRunTransaction(
-		options: Experimental_HaneulClientTypes.DryRunTransactionOptions,
-	): Promise<Experimental_HaneulClientTypes.DryRunTransactionResponse> {
+	async simulateTransaction<Include extends HaneulClientTypes.SimulateTransactionInclude = object>(
+		options: HaneulClientTypes.SimulateTransactionOptions<Include>,
+	): Promise<HaneulClientTypes.SimulateTransactionResult<Include>> {
+		const paths = [
+			'transaction.digest',
+			'transaction.transaction.digest',
+			'transaction.signatures',
+			'transaction.effects.status',
+		];
+		if (options.include?.transaction) {
+			paths.push(
+				'transaction.transaction.sender',
+				'transaction.transaction.gas_payment',
+				'transaction.transaction.expiration',
+				'transaction.transaction.kind',
+			);
+		}
+		if (options.include?.bcs) {
+			paths.push('transaction.transaction.bcs');
+		}
+		if (options.include?.balanceChanges) {
+			paths.push('transaction.balance_changes');
+		}
+		if (options.include?.effects) {
+			paths.push('transaction.effects');
+		}
+		if (options.include?.events) {
+			paths.push('transaction.events');
+		}
+		if (options.include?.objectTypes) {
+			// Use effects.changed_objects to match JSON-RPC behavior (which uses objectChanges)
+			paths.push('transaction.effects.changed_objects.object_type');
+			paths.push('transaction.effects.changed_objects.object_id');
+		}
+		if (options.include?.commandResults) {
+			paths.push('command_outputs');
+		}
+
+		if (!(options.transaction instanceof Uint8Array)) {
+			await options.transaction.prepareForSerialization({ client: this });
+		}
+
 		const { response } = await this.#client.transactionExecutionService.simulateTransaction({
-			transaction: {
-				bcs: {
-					value: options.transaction,
-				},
+			transaction:
+				options.transaction instanceof Uint8Array
+					? {
+							bcs: {
+								value: options.transaction,
+							},
+						}
+					: transactionToGrpcTransaction(options.transaction),
+			readMask: {
+				paths,
 			},
+			doGasSelection: false,
+		});
+
+		const transactionResult = parseTransaction(response.transaction!, options.include);
+
+		// Add command results if requested
+		const commandResults =
+			options.include?.commandResults && response.commandOutputs
+				? response.commandOutputs.map((output) => ({
+						returnValues: (output.returnValues ?? []).map((rv) => ({
+							bcs: rv.value?.value ?? null,
+						})),
+						mutatedReferences: (output.mutatedByRef ?? []).map((mr) => ({
+							bcs: mr.value?.value ?? null,
+						})),
+					}))
+				: undefined;
+
+		if (transactionResult.$kind === 'Transaction') {
+			return {
+				$kind: 'Transaction',
+				Transaction: transactionResult.Transaction,
+				commandResults:
+					commandResults as HaneulClientTypes.SimulateTransactionResult<Include>['commandResults'],
+			};
+		} else {
+			return {
+				$kind: 'FailedTransaction',
+				FailedTransaction: transactionResult.FailedTransaction,
+				commandResults:
+					commandResults as HaneulClientTypes.SimulateTransactionResult<Include>['commandResults'],
+			};
+		}
+	}
+	async getReferenceGasPrice(): Promise<HaneulClientTypes.GetReferenceGasPriceResponse> {
+		const response = await this.#client.ledgerService.getEpoch({
 			readMask: {
-				paths: [
-					'transaction.digest',
-					'transaction.transaction',
-					'transaction.effects',
-					'transaction.signatures',
-					'transaction.balance_changes',
-				],
+				paths: ['reference_gas_price'],
 			},
 		});
 
 		return {
-			transaction: parseTransaction(response.transaction!),
+			referenceGasPrice: response.response.epoch?.referenceGasPrice?.toString() ?? '',
 		};
 	}
-	async getReferenceGasPrice(): Promise<Experimental_HaneulClientTypes.GetReferenceGasPriceResponse> {
-		const response = await this.#client.ledgerService.getEpoch({});
+
+	async getCurrentSystemState(): Promise<HaneulClientTypes.GetCurrentSystemStateResponse> {
+		const response = await this.#client.ledgerService.getEpoch({
+			readMask: {
+				paths: [
+					'system_state.version',
+					'system_state.epoch',
+					'system_state.protocol_version',
+					'system_state.reference_gas_price',
+					'system_state.epoch_start_timestamp_ms',
+					'system_state.safe_mode',
+					'system_state.safe_mode_storage_rewards',
+					'system_state.safe_mode_computation_rewards',
+					'system_state.safe_mode_storage_rebates',
+					'system_state.safe_mode_non_refundable_storage_fee',
+					'system_state.parameters',
+					'system_state.storage_fund',
+					'system_state.stake_subsidy',
+				],
+			},
+		});
+
+		const epoch = response.response.epoch;
+		const systemState = epoch?.systemState;
+		if (!systemState) {
+			throw new Error('System state not found in response');
+		}
+
+		const startMs = epoch?.start?.seconds
+			? Number(epoch.start.seconds) * 1000 + Math.floor((epoch.start.nanos || 0) / 1_000_000)
+			: systemState.epochStartTimestampMs
+				? Number(systemState.epochStartTimestampMs)
+				: (null as never);
 
 		return {
-			referenceGasPrice: response.response.epoch?.referenceGasPrice?.toString()!,
+			systemState: {
+				systemStateVersion: systemState.version?.toString() ?? (null as never),
+				epoch: systemState.epoch?.toString() ?? (null as never),
+				protocolVersion: systemState.protocolVersion?.toString() ?? (null as never),
+				referenceGasPrice: systemState.referenceGasPrice?.toString() ?? (null as never),
+				epochStartTimestampMs: startMs.toString(),
+				safeMode: systemState.safeMode ?? false,
+				safeModeStorageRewards: systemState.safeModeStorageRewards?.toString() ?? (null as never),
+				safeModeComputationRewards:
+					systemState.safeModeComputationRewards?.toString() ?? (null as never),
+				safeModeStorageRebates: systemState.safeModeStorageRebates?.toString() ?? (null as never),
+				safeModeNonRefundableStorageFee:
+					systemState.safeModeNonRefundableStorageFee?.toString() ?? (null as never),
+				parameters: {
+					epochDurationMs: systemState.parameters?.epochDurationMs?.toString() ?? (null as never),
+					stakeSubsidyStartEpoch:
+						systemState.parameters?.stakeSubsidyStartEpoch?.toString() ?? (null as never),
+					maxValidatorCount:
+						systemState.parameters?.maxValidatorCount?.toString() ?? (null as never),
+					minValidatorJoiningStake:
+						systemState.parameters?.minValidatorJoiningStake?.toString() ?? (null as never),
+					validatorLowStakeThreshold:
+						systemState.parameters?.validatorLowStakeThreshold?.toString() ?? (null as never),
+					validatorLowStakeGracePeriod:
+						systemState.parameters?.validatorLowStakeGracePeriod?.toString() ?? (null as never),
+				},
+				storageFund: {
+					totalObjectStorageRebates:
+						systemState.storageFund?.totalObjectStorageRebates?.toString() ?? (null as never),
+					nonRefundableBalance:
+						systemState.storageFund?.nonRefundableBalance?.toString() ?? (null as never),
+				},
+				stakeSubsidy: {
+					balance: systemState.stakeSubsidy?.balance?.toString() ?? (null as never),
+					distributionCounter:
+						systemState.stakeSubsidy?.distributionCounter?.toString() ?? (null as never),
+					currentDistributionAmount:
+						systemState.stakeSubsidy?.currentDistributionAmount?.toString() ?? (null as never),
+					stakeSubsidyPeriodLength:
+						systemState.stakeSubsidy?.stakeSubsidyPeriodLength?.toString() ?? (null as never),
+					stakeSubsidyDecreaseRate:
+						systemState.stakeSubsidy?.stakeSubsidyDecreaseRate ?? (null as never),
+				},
+			},
 		};
 	}
 
-	async getDynamicFields(
-		options: Experimental_HaneulClientTypes.GetDynamicFieldsOptions,
-	): Promise<Experimental_HaneulClientTypes.GetDynamicFieldsResponse> {
+	async listDynamicFields(
+		options: HaneulClientTypes.ListDynamicFieldsOptions,
+	): Promise<HaneulClientTypes.ListDynamicFieldsResponse> {
 		const response = await this.#client.stateService.listDynamicFields({
 			parent: options.parentId,
 			pageToken: options.cursor ? fromBase64(options.cursor) : undefined,
+			pageSize: options.limit,
+			readMask: {
+				paths: ['field_id', 'name', 'value_type', 'kind'],
+			},
 		});
 
 		return {
-			dynamicFields: response.response.dynamicFields.map((field) => ({
-				id: field.fieldId!,
-				name: {
-					type: field.name?.name!,
-					bcs: field.name?.value!,
-				},
-				type: field.fieldObject
+			dynamicFields: response.response.dynamicFields.map((field) => {
+				const isDynamicObject = field.kind === DynamicField_DynamicFieldKind.OBJECT;
+				const fieldType = isDynamicObject
 					? `0x2::dynamic_field::Field<0x2::dynamic_object_field::Wrapper<${field.name?.name!}>,0x2::object::ID>`
-					: `0x2::dynamic_field::Field<${field.name?.value!},${field.valueType!}>`,
-			})),
+					: `0x2::dynamic_field::Field<${field.name?.name!},${field.valueType!}>`;
+				return {
+					fieldId: field.fieldId!,
+					name: {
+						type: field.name?.name!,
+						bcs: field.name?.value!,
+					},
+					valueType: field.valueType!,
+					type: normalizeStructTag(fieldType),
+				};
+			}),
 			cursor: response.response.nextPageToken ? toBase64(response.response.nextPageToken) : null,
 			hasNextPage: response.response.nextPageToken !== undefined,
 		};
 	}
 
 	async verifyZkLoginSignature(
-		options: Experimental_HaneulClientTypes.VerifyZkLoginSignatureOptions,
-	): Promise<Experimental_HaneulClientTypes.ZkLoginVerifyResponse> {
+		options: HaneulClientTypes.VerifyZkLoginSignatureOptions,
+	): Promise<HaneulClientTypes.ZkLoginVerifyResponse> {
+		const messageBytes = fromBase64(options.bytes);
+
+		// For PersonalMessage, the server expects BCS-encoded vector<u8>
+		// For TransactionData, the server expects the raw BCS-encoded TransactionData as-is
+		const messageValue =
+			options.intentScope === 'PersonalMessage'
+				? bcs.byteVector().serialize(messageBytes).toBytes()
+				: messageBytes;
+
 		const { response } = await this.#client.signatureVerificationService.verifySignature({
 			message: {
 				name: options.intentScope,
-				value: fromBase64(options.bytes),
+				value: messageValue,
 			},
 			signature: {
 				bcs: {
@@ -335,6 +616,7 @@ export class GrpcCoreClient extends Experimental_CoreClient {
 					oneofKind: undefined,
 				},
 			},
+			address: options.address,
 			jwks: [],
 		});
 
@@ -345,8 +627,8 @@ export class GrpcCoreClient extends Experimental_CoreClient {
 	}
 
 	async defaultNameServiceName(
-		options: Experimental_HaneulClientTypes.DefaultNameServiceNameOptions,
-	): Promise<Experimental_HaneulClientTypes.DefaultNameServiceNameResponse> {
+		options: HaneulClientTypes.DefaultNameServiceNameOptions,
+	): Promise<HaneulClientTypes.DefaultNameServiceNameResponse> {
 		const name =
 			(
 				await this.#client.nameService.reverseLookupName({
@@ -361,10 +643,12 @@ export class GrpcCoreClient extends Experimental_CoreClient {
 	}
 
 	async getMoveFunction(
-		options: Experimental_HaneulClientTypes.GetMoveFunctionOptions,
-	): Promise<Experimental_HaneulClientTypes.GetMoveFunctionResponse> {
+		options: HaneulClientTypes.GetMoveFunctionOptions,
+	): Promise<HaneulClientTypes.GetMoveFunctionResponse> {
+		const resolvedPackageId = (await this.mvr.resolvePackage({ package: options.packageId }))
+			.package;
 		const { response } = await this.#client.movePackageService.getFunction({
-			packageId: (await this.mvr.resolvePackage({ package: options.packageId })).package,
+			packageId: resolvedPackageId,
 			moduleName: options.moduleName,
 			name: options.name,
 		});
@@ -385,7 +669,7 @@ export class GrpcCoreClient extends Experimental_CoreClient {
 
 		return {
 			function: {
-				packageId: options.packageId,
+				packageId: normalizeHaneulAddress(resolvedPackageId),
 				moduleName: options.moduleName,
 				name: response.function?.name!,
 				visibility,
@@ -410,33 +694,93 @@ export class GrpcCoreClient extends Experimental_CoreClient {
 							}) ?? [],
 					})) ?? [],
 				parameters:
-					response.function?.parameters?.map((param) => parseNormalizedSuiMoveType(param)) ?? [],
-				returns: response.function?.returns?.map((ret) => parseNormalizedSuiMoveType(ret)) ?? [],
+					response.function?.parameters?.map((param) => parseNormalizedHaneulMoveType(param)) ?? [],
+				returns: response.function?.returns?.map((ret) => parseNormalizedHaneulMoveType(ret)) ?? [],
 			},
 		};
 	}
 
+	async getChainIdentifier(
+		_options?: HaneulClientTypes.GetChainIdentifierOptions,
+	): Promise<HaneulClientTypes.GetChainIdentifierResponse> {
+		return this.cache.read(['chainIdentifier'], async () => {
+			const { response } = await this.#client.ledgerService.getServiceInfo({});
+			if (!response.chainId) {
+				throw new Error('Chain identifier not found in service info');
+			}
+			return {
+				chainIdentifier: response.chainId,
+			};
+		});
+	}
+
 	resolveTransactionPlugin() {
-		// const client = this.#client;
+		const client = this.#client;
 		return async function resolveTransactionData(
-			_transactionData: TransactionDataBuilder,
-			_options: BuildTransactionOptions,
-			_next: () => Promise<void>,
+			transactionData: TransactionDataBuilder,
+			options: BuildTransactionOptions,
+			next: () => Promise<void>,
 		) {
-			throw new Error('Transaction resolution is not supported with the GRPC client');
+			const snapshot = transactionData.snapshot();
+			// If sender is not set, use a dummy address for resolution purposes
+			// The resolved transaction will not include the sender if it wasn't set originally
+			if (!snapshot.sender) {
+				snapshot.sender = '0x0000000000000000000000000000000000000000000000000000000000000000';
+			}
+			const grpcTransaction = transactionDataToGrpcTransaction(snapshot);
 
-			// const result = await client.liveDataService.simulateTransaction({
-			// 	transaction: transactionFromData(transactionData)
-			// })
-			// const resolvedData = dataFromSimulate(result)
-			// transactionData.applyResolvedData(resolvedData);
+			let response;
+			try {
+				const result = await client.transactionExecutionService.simulateTransaction({
+					transaction: grpcTransaction,
+					doGasSelection:
+						!options.onlyTransactionKind &&
+						(snapshot.gasData.budget == null || snapshot.gasData.payment == null),
+					readMask: {
+						paths: [
+							'transaction.transaction.sender',
+							'transaction.transaction.gas_payment',
+							'transaction.transaction.expiration',
+							'transaction.transaction.kind',
+							'transaction.effects.status',
+						],
+					},
+				});
+				response = result.response;
+			} catch (error) {
+				// https://github.com/timostamm/protobuf-ts/pull/739
+				if (error instanceof Error && error.message) {
+					throw new SimulationError(decodeURIComponent(error.message), { cause: error });
+				}
+				throw error;
+			}
+
+			if (
+				!options.onlyTransactionKind &&
+				response.transaction?.effects?.status &&
+				!response.transaction.effects.status.success
+			) {
+				const executionError = response.transaction.effects.status.error
+					? parseGrpcExecutionError(response.transaction.effects.status.error)
+					: undefined;
+				const errorMessage = executionError?.message ?? 'Transaction failed';
+				throw new SimulationError(`Transaction resolution failed: ${errorMessage}`, {
+					executionError,
+				});
+			}
+
+			if (!response.transaction?.transaction) {
+				throw new Error('simulateTransaction did not return resolved transaction data');
+			}
 
-			// return await next();
+			applyGrpcResolvedTransaction(transactionData, response.transaction.transaction, options);
+
+			return await next();
 		};
 	}
 }
 
-function mapOwner(owner: Owner | null | undefined): Experimental_HaneulClientTypes.ObjectOwner | null {
+function mapOwner(owner: Owner | null | undefined): HaneulClientTypes.ObjectOwner | null {
 	if (!owner) {
 		return null;
 	}
@@ -460,15 +804,6 @@ function mapOwner(owner: Owner | null | undefined): Experimental_HaneulClientTyp
 	}
 
 	if (owner.kind === Owner_OwnerKind.SHARED) {
-		if (owner.address) {
-			return {
-				$kind: 'ConsensusAddressOwner',
-				ConsensusAddressOwner: {
-					owner: owner.address,
-					startVersion: owner.version?.toString()!,
-				},
-			};
-		}
 		return {
 			$kind: 'Shared',
 			Shared: {
@@ -477,7 +812,196 @@ function mapOwner(owner: Owner | null | undefined): Experimental_HaneulClientTyp
 		};
 	}
 
-	throw new Error('Unknown owner kind');
+	if (owner.kind === Owner_OwnerKind.CONSENSUS_ADDRESS) {
+		return {
+			$kind: 'ConsensusAddressOwner',
+			ConsensusAddressOwner: {
+				startVersion: owner.version?.toString()!,
+				owner: owner.address!,
+			},
+		};
+	}
+
+	throw new Error(
+		`Unknown owner kind ${JSON.stringify(owner, (_k, v) => (typeof v === 'bigint' ? v.toString() : v))}`,
+	);
+}
+
+function parseGrpcExecutionError(error: GrpcExecutionError): HaneulClientTypes.ExecutionError {
+	const message = error.description ?? 'Unknown error';
+	const command = error.command != null ? Number(error.command) : undefined;
+	const details = error.errorDetails;
+
+	switch (details?.oneofKind) {
+		case 'abort': {
+			const abort = details.abort;
+			const cleverError = abort.cleverError;
+			return {
+				$kind: 'MoveAbort',
+				message: formatMoveAbortMessage({
+					command,
+					location: abort.location,
+					abortCode: String(abort.abortCode ?? 0n),
+					cleverError: cleverError
+						? {
+								lineNumber:
+									cleverError.lineNumber != null ? Number(cleverError.lineNumber) : undefined,
+								constantName: cleverError.constantName,
+								value:
+									cleverError.value?.oneofKind === 'rendered'
+										? cleverError.value.rendered
+										: undefined,
+							}
+						: undefined,
+				}),
+				command,
+				MoveAbort: parseMoveAbort(abort),
+			};
+		}
+
+		case 'sizeError':
+			return {
+				$kind: 'SizeError',
+				message,
+				command,
+				SizeError: {
+					name: mapErrorName(error.kind),
+					size: Number(details.sizeError.size ?? 0n),
+					maxSize: Number(details.sizeError.maxSize ?? 0n),
+				},
+			};
+
+		case 'commandArgumentError':
+			return {
+				$kind: 'CommandArgumentError',
+				message,
+				command,
+				CommandArgumentError: {
+					argument: details.commandArgumentError.argument ?? 0,
+					name: mapErrorName(details.commandArgumentError.kind),
+				},
+			};
+
+		case 'typeArgumentError':
+			return {
+				$kind: 'TypeArgumentError',
+				message,
+				command,
+				TypeArgumentError: {
+					typeArgument: details.typeArgumentError.typeArgument ?? 0,
+					name: mapErrorName(details.typeArgumentError.kind),
+				},
+			};
+
+		case 'packageUpgradeError':
+			return {
+				$kind: 'PackageUpgradeError',
+				message,
+				command,
+				PackageUpgradeError: {
+					name: mapErrorName(details.packageUpgradeError.kind),
+					packageId: details.packageUpgradeError.packageId,
+					digest: details.packageUpgradeError.digest,
+				},
+			};
+
+		case 'indexError':
+			return {
+				$kind: 'IndexError',
+				message,
+				command,
+				IndexError: {
+					index: details.indexError.index,
+					subresult: details.indexError.subresult,
+				},
+			};
+
+		case 'coinDenyListError':
+			return {
+				$kind: 'CoinDenyListError',
+				message,
+				command,
+				CoinDenyListError: {
+					name: mapErrorName(error.kind),
+					coinType: details.coinDenyListError.coinType!,
+					address: details.coinDenyListError.address,
+				},
+			};
+
+		case 'congestedObjects':
+			return {
+				$kind: 'CongestedObjects',
+				message,
+				command,
+				CongestedObjects: {
+					name: mapErrorName(error.kind),
+					objects: details.congestedObjects.objects,
+				},
+			};
+
+		case 'objectId':
+			return {
+				$kind: 'ObjectIdError',
+				message,
+				command,
+				ObjectIdError: {
+					name: mapErrorName(error.kind),
+					objectId: details.objectId,
+				},
+			};
+
+		default:
+			return {
+				$kind: 'Unknown',
+				message,
+				command,
+				Unknown: null,
+			};
+	}
+}
+
+function parseMoveAbort(abort: GrpcMoveAbort): HaneulClientTypes.MoveAbort {
+	return {
+		abortCode: String(abort.abortCode ?? 0n),
+		location: { ...abort.location },
+		cleverError: abort.cleverError
+			? {
+					errorCode:
+						abort.cleverError.errorCode != null ? Number(abort.cleverError.errorCode) : undefined,
+					lineNumber:
+						abort.cleverError.lineNumber != null ? Number(abort.cleverError.lineNumber) : undefined,
+					constantName: abort.cleverError.constantName,
+					constantType: abort.cleverError.constantType,
+					value:
+						abort.cleverError.value?.oneofKind === 'rendered'
+							? abort.cleverError.value.rendered
+							: abort.cleverError.value?.oneofKind === 'raw'
+								? toBase64(abort.cleverError.value.raw)
+								: undefined,
+				}
+			: undefined,
+	};
+}
+
+function mapErrorName(
+	kind:
+		| ExecutionError_ExecutionErrorKind
+		| CommandArgumentError_CommandArgumentErrorKind
+		| TypeArgumentError_TypeArgumentErrorKind
+		| PackageUpgradeError_PackageUpgradeErrorKind
+		| undefined,
+): string {
+	if (kind == null) {
+		return 'Unknown';
+	}
+	const name = CommandArgumentError_CommandArgumentErrorKind[kind];
+	if (!name || name.endsWith('_UNKNOWN')) {
+		return 'Unknown';
+	}
+	return name
+		.split('_')
+		.map((word) => word.charAt(0) + word.slice(1).toLowerCase())
+		.join('');
 }
 
 function mapIdOperation(
@@ -521,7 +1045,7 @@ function mapInputObjectState(
 
 function mapOutputObjectState(
 	state: ChangedObject_OutputObjectState | undefined,
-): null | 'ObjectWrite' | 'PackageWrite' | 'DoesNotExist' | 'Unknown' {
+): null | 'ObjectWrite' | 'PackageWrite' | 'DoesNotExist' | 'AccumulatorWriteV1' | 'Unknown' {
 	if (state == null) {
 		return null;
 	}
@@ -532,6 +1056,8 @@ function mapOutputObjectState(
 			return 'PackageWrite';
 		case ChangedObject_OutputObjectState.DOES_NOT_EXIST:
 			return 'DoesNotExist';
+		case ChangedObject_OutputObjectState.ACCUMULATOR_WRITE:
+			return 'AccumulatorWriteV1';
 		case ChangedObject_OutputObjectState.UNKNOWN:
 			return 'Unknown';
 		default:
@@ -542,7 +1068,7 @@ function mapOutputObjectState(
 
 function mapUnchangedConsensusObjectKind(
 	kind: UnchangedConsensusObject_UnchangedConsensusObjectKind | undefined,
-): null | Experimental_HaneulClientTypes.UnchangedConsensusObject['kind'] {
+): null | HaneulClientTypes.UnchangedConsensusObject['kind'] {
 	if (kind == null) {
 		return null;
 	}
@@ -569,31 +1095,29 @@ export function parseTransactionEffects({
 	effects,
 }: {
 	effects: TransactionEffects | undefined;
-}): Experimental_HaneulClientTypes.TransactionEffects | null {
+}): HaneulClientTypes.TransactionEffects | null {
 	if (!effects) {
 		return null;
 	}
 
-	const changedObjects = effects.changedObjects.map(
-		(change): Experimental_HaneulClientTypes.ChangedObject => {
-			return {
-				id: change.objectId!,
-				inputState: mapInputObjectState(change.inputState)!,
-				inputVersion: change.inputVersion?.toString() ?? null,
-				inputDigest: change.inputDigest ?? null,
-				inputOwner: mapOwner(change.inputOwner),
-				outputState: mapOutputObjectState(change.outputState)!,
-				outputVersion: change.outputVersion?.toString() ?? null,
-				outputDigest: change.outputDigest ?? null,
-				outputOwner: mapOwner(change.outputOwner),
-				idOperation: mapIdOperation(change.idOperation)!,
-			};
-		},
-	);
+	const changedObjects = effects.changedObjects.map((change): HaneulClientTypes.ChangedObject => {
+		return {
+			objectId: change.objectId!,
+			inputState: mapInputObjectState(change.inputState)!,
+			inputVersion: change.inputVersion?.toString() ?? null,
+			inputDigest: change.inputDigest ?? null,
+			inputOwner: mapOwner(change.inputOwner),
+			outputState: mapOutputObjectState(change.outputState)!,
+			outputVersion: change.outputVersion?.toString() ?? null,
+			outputDigest: change.outputDigest ?? null,
+			outputOwner: mapOwner(change.outputOwner),
+			idOperation: mapIdOperation(change.idOperation)!,
+		};
+	});
 
 	return {
 		bcs: effects.bcs?.value!,
-		digest: effects.digest!,
+
 		version: 2,
 		status: effects.status?.success
 			? {
@@ -602,8 +1126,7 @@ export function parseTransactionEffects({
 				}
 			: {
 					success: false,
-					// TODO: parse errors properly
-					error: JSON.stringify(effects.status?.error),
+					error: parseGrpcExecutionError(effects.status!.error!),
 				},
 		gasUsed: {
 			computationCost: effects.gasUsed?.computationCost?.toString()!,
@@ -613,7 +1136,7 @@ export function parseTransactionEffects({
 		},
 		transactionDigest: effects.transactionDigest!,
 		gasObject: {
-			id: effects.gasObject?.objectId!,
+			objectId: effects.gasObject?.objectId!,
 			inputState: mapInputObjectState(effects.gasObject?.inputState)!,
 			inputVersion: effects.gasObject?.inputVersion?.toString() ?? null,
 			inputDigest: effects.gasObject?.inputDigest ?? null,
@@ -629,7 +1152,7 @@ export function parseTransactionEffects({
 		lamportVersion: effects.lamportVersion?.toString() ?? null,
 		changedObjects,
 		unchangedConsensusObjects: effects.unchangedConsensusObjects.map(
-			(object): Experimental_HaneulClientTypes.UnchangedConsensusObject => {
+			(object): HaneulClientTypes.UnchangedConsensusObject => {
 				return {
 					kind: mapUnchangedConsensusObjectKind(object.kind)!,
 					// TODO: we are inconsistent about id vs objectId
@@ -643,58 +1166,100 @@ export function parseTransactionEffects({
 	};
 }
 
-function parseTransaction(
+function parseTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
 	transaction: ExecutedTransaction,
-): Experimental_HaneulClientTypes.TransactionResponse {
-	const parsedTx = bcs.SenderSignedData.parse(transaction.transaction?.bcs?.value!)[0];
-	const bytes = bcs.TransactionData.serialize(parsedTx.intentMessage.value).toBytes();
-	const data = TransactionDataBuilder.restore({
-		version: 2,
-		sender: parsedTx.intentMessage.value.V1.sender,
-		expiration: parsedTx.intentMessage.value.V1.expiration,
-		gasData: parsedTx.intentMessage.value.V1.gasData,
-		inputs: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction!.inputs,
-		commands: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction!.commands,
-	});
-
+	include?: Include,
+): HaneulClientTypes.TransactionResult<Include> {
 	const objectTypes: Record<string, string> = {};
-	transaction.objects?.objects.forEach((object) => {
-		if (object.objectId && object.objectType) {
-			objectTypes[object.objectId] = object.objectType;
+	if (include?.objectTypes) {
+		transaction.effects?.changedObjects?.forEach((change) => {
+			if (change.objectId && change.objectType) {
+				objectTypes[change.objectId] = change.objectType;
+			}
+		});
+	}
+
+	let transactionData: HaneulClientTypes.TransactionData | undefined;
+	if (include?.transaction) {
+		const tx = transaction.transaction;
+
+		if (!tx) {
+			throw new Error('Transaction data is required but missing from gRPC response');
 		}
-	});
 
-	const effects = parseTransactionEffects({
-		effects: transaction.effects,
-	})!;
+		const resolved = grpcTransactionToTransactionData(tx);
+		transactionData = {
+			gasData: resolved.gasData,
+			sender: resolved.sender,
+			expiration: resolved.expiration,
+			commands: resolved.commands,
+			inputs: resolved.inputs,
+			version: resolved.version,
+		};
+	}
 
-	return {
+	const bcsBytes = include?.bcs ? transaction.transaction?.bcs?.value : undefined;
+
+	const effects = include?.effects
+		? parseTransactionEffects({
+				effects: transaction.effects,
+			})
+		: undefined;
+
+	const status: HaneulClientTypes.ExecutionStatus = transaction.effects?.status?.success
+		? { success: true, error: null }
+		: {
+				success: false,
+				error: transaction.effects?.status?.error
+					? parseGrpcExecutionError(transaction.effects.status.error)
+					: {
+							$kind: 'Unknown',
+							message: 'Transaction failed',
+							Unknown: null,
+						},
+			};
+
+	const result: HaneulClientTypes.Transaction<Include> = {
 		digest: transaction.digest!,
 		epoch: transaction.effects?.epoch?.toString() ?? null,
-		effects,
-		objectTypes: Promise.resolve(objectTypes),
-		transaction: {
-			gasData: data.gasData,
-			sender: data.sender,
-			expiration: data.expiration,
-			commands: data.commands,
-			inputs: data.inputs,
-			version: data.version,
-			bcs: bytes,
-		},
-		signatures: parsedTx.txSignatures,
-		balanceChanges:
-			transaction.balanceChanges?.map((change) => ({
-				coinType: change.coinType!,
-				address: change.address!,
-				amount: change.amount!,
-			})) ?? [],
+		status,
+		effects: effects as HaneulClientTypes.Transaction<Include>['effects'],
+		objectTypes: (include?.objectTypes
+			? objectTypes
+			: undefined) as HaneulClientTypes.Transaction<Include>['objectTypes'],
+		transaction: transactionData as HaneulClientTypes.Transaction<Include>['transaction'],
+		bcs: bcsBytes as HaneulClientTypes.Transaction<Include>['bcs'],
+		signatures: transaction.signatures?.map((sig) => toBase64(sig.bcs?.value!)) ?? [],
+		balanceChanges: (include?.balanceChanges
+			? (transaction.balanceChanges?.map((change) => ({
+					coinType: change.coinType!,
+					address: change.address!,
+					amount: change.amount!,
+				})) ?? [])
+			: undefined) as HaneulClientTypes.Transaction<Include>['balanceChanges'],
+		events: (include?.events
+			? (transaction.events?.events.map((event) => ({
+					packageId: normalizeHaneulAddress(event.packageId!),
+					module: event.module!,
+					sender: normalizeHaneulAddress(event.sender!),
+					eventType: event.eventType!,
+					bcs: event.contents?.value ?? new Uint8Array(),
+				})) ?? [])
+			: undefined) as HaneulClientTypes.Transaction<Include>['events'],
 	};
+
+	return status.success
+		? {
+				$kind: 'Transaction',
+				Transaction: result,
+			}
+		: {
+				$kind: 'FailedTransaction',
+				FailedTransaction: result,
+			};
 }
 
-function parseNormalizedSuiMoveType(
-	type: OpenSignature,
-): Experimental_HaneulClientTypes.OpenSignature {
+function parseNormalizedHaneulMoveType(type: OpenSignature): HaneulClientTypes.OpenSignature {
 	let reference: 'mutable' | 'immutable' | null = null;
 
 	if (type.reference === OpenSignature_Reference.IMMUTABLE) {
@@ -705,13 +1270,11 @@ function parseNormalizedSuiMoveType(
 
 	return {
 		reference,
-		body: parseNormalizedSuiMoveTypeBody(type.body!),
+		body: parseNormalizedHaneulMoveTypeBody(type.body!),
 	};
 }
 
-function parseNormalizedSuiMoveTypeBody(
-	type: OpenSignatureBody,
-): Experimental_HaneulClientTypes.OpenSignatureBody {
+function parseNormalizedHaneulMoveTypeBody(type: OpenSignatureBody): HaneulClientTypes.OpenSignatureBody {
 	switch (type.type) {
 		case OpenSignatureBody_Type.TYPE_UNKNOWN:
 			return { $kind: 'unknown' };
@@ -734,7 +1297,7 @@ function parseNormalizedSuiMoveTypeBody(
 		case OpenSignatureBody_Type.VECTOR:
 			return {
 				$kind: 'vector',
-				vector: parseNormalizedSuiMoveTypeBody(type.typeParameterInstantiation[0]),
+				vector: parseNormalizedHaneulMoveTypeBody(type.typeParameterInstantiation[0]),
 			};
 		case OpenSignatureBody_Type.DATATYPE:
 			return {
@@ -742,7 +1305,7 @@ function parseNormalizedSuiMoveTypeBody(
 				datatype: {
 					typeName: type.typeName!,
 					typeParameters: type.typeParameterInstantiation.map((t) =>
-						parseNormalizedSuiMoveTypeBody(t),
+						parseNormalizedHaneulMoveTypeBody(t),
 					),
 				},
 			};