@haneullabs/haneul 0.1.0 → 2.5.0

package/src/jsonRpc/core.ts

@@ -1,31 +1,106 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { fromBase64 } from '@haneullabs/bcs';
+import { fromBase64, type InferBcsInput } from '@haneullabs/bcs';
 
-import { bcs } from '../bcs/index.js';
+import { bcs, TypeTagSerializer } from '../bcs/index.js';
 import type {
+	ExecutionStatus as JsonRpcExecutionStatus,
 	ObjectOwner,
-	SuiMoveAbilitySet,
+	HaneulMoveAbilitySet,
+	HaneulMoveAbort,
 	HaneulMoveNormalizedType,
-	SuiMoveVisibility,
+	HaneulMoveVisibility,
 	HaneulObjectChange,
 	HaneulObjectData,
+	HaneulObjectDataFilter,
 	HaneulTransactionBlockResponse,
 	TransactionEffects,
 } from './types/index.js';
 import { Transaction } from '../transactions/Transaction.js';
-import { jsonRpcClientResolveTransactionPlugin } from './json-rpc-resolver.js';
+import { coreClientResolveTransactionPlugin } from '../client/core-resolver.js';
 import { TransactionDataBuilder } from '../transactions/TransactionData.js';
 import { chunk } from '@haneullabs/utils';
-import { normalizeHaneulAddress } from '../utils/haneul-types.js';
-import { Experimental_CoreClient } from '../experimental/core.js';
-import type { Experimental_HaneulClientTypes } from '../experimental/types.js';
-import { ObjectError } from '../experimental/errors.js';
-import { parseTransactionBcs, parseTransactionEffectsBcs } from '../experimental/index.js';
+import { normalizeHaneulAddress, normalizeStructTag } from '../utils/haneul-types.js';
+import { HANEUL_FRAMEWORK_ADDRESS, HANEUL_SYSTEM_ADDRESS } from '../utils/constants.js';
+import { CoreClient } from '../client/core.js';
+import type { HaneulClientTypes } from '../client/types.js';
+import { ObjectError } from '../client/errors.js';
+import {
+	formatMoveAbortMessage,
+	parseTransactionBcs,
+	parseTransactionEffectsBcs,
+} from '../client/index.js';
 import type { HaneulJsonRpcClient } from './client.js';
 
-export class JSONRpcCoreClient extends Experimental_CoreClient {
+const MAX_GAS = 50_000_000_000;
+
+function parseJsonRpcExecutionStatus(
+	status: JsonRpcExecutionStatus,
+	abortError?: HaneulMoveAbort | null,
+): HaneulClientTypes.ExecutionStatus {
+	if (status.status === 'success') {
+		return { success: true, error: null };
+	}
+
+	const rawMessage = status.error ?? 'Unknown';
+
+	if (abortError) {
+		const commandMatch = rawMessage.match(/in command (\d+)/);
+		const command = commandMatch ? parseInt(commandMatch[1], 10) : undefined;
+
+		const instructionMatch = rawMessage.match(/instruction:\s*(\d+)/);
+		const instruction = instructionMatch ? parseInt(instructionMatch[1], 10) : undefined;
+
+		const moduleParts = abortError.module_id?.split('::') ?? [];
+		const pkg = moduleParts[0] ? normalizeHaneulAddress(moduleParts[0]) : undefined;
+		const module = moduleParts[1];
+
+		return {
+			success: false,
+			error: {
+				$kind: 'MoveAbort',
+				message: formatMoveAbortMessage({
+					command,
+					location:
+						pkg && module
+							? {
+									package: pkg,
+									module,
+									functionName: abortError.function ?? undefined,
+									instruction,
+								}
+							: undefined,
+					abortCode: String(abortError.error_code ?? 0),
+					cleverError: abortError.line != null ? { lineNumber: abortError.line } : undefined,
+				}),
+				command,
+				MoveAbort: {
+					abortCode: String(abortError.error_code ?? 0),
+					location: abortError.module_id
+						? {
+								package: normalizeHaneulAddress(abortError.module_id.split('::')[0] ?? ''),
+								module: abortError.module_id.split('::')[1] ?? '',
+								functionName: abortError.function ?? undefined,
+								instruction,
+							}
+						: undefined,
+				},
+			},
+		};
+	}
+
+	return {
+		success: false,
+		error: {
+			$kind: 'Unknown',
+			message: rawMessage,
+			Unknown: null,
+		},
+	};
+}
+
+export class JSONRpcCoreClient extends CoreClient {
 	#jsonRpcClient: HaneulJsonRpcClient;
 
 	constructor({
@@ -33,24 +108,28 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 		mvr,
 	}: {
 		jsonRpcClient: HaneulJsonRpcClient;
-		mvr?: Experimental_HaneulClientTypes.MvrOptions;
+		mvr?: HaneulClientTypes.MvrOptions;
 	}) {
 		super({ network: jsonRpcClient.network, base: jsonRpcClient, mvr });
 		this.#jsonRpcClient = jsonRpcClient;
 	}
 
-	async getObjects(options: Experimental_HaneulClientTypes.GetObjectsOptions) {
+	async getObjects<Include extends HaneulClientTypes.ObjectInclude = object>(
+		options: HaneulClientTypes.GetObjectsOptions<Include>,
+	) {
 		const batches = chunk(options.objectIds, 50);
-		const results: Experimental_HaneulClientTypes.GetObjectsResponse['objects'] = [];
-
+		const results: HaneulClientTypes.GetObjectsResponse<Include>['objects'] = [];
 		for (const batch of batches) {
 			const objects = await this.#jsonRpcClient.multiGetObjects({
 				ids: batch,
 				options: {
 					showOwner: true,
 					showType: true,
-					showBcs: true,
-					showPreviousTransaction: true,
+					showBcs: options.include?.content || options.include?.objectBcs ? true : false,
+					showPreviousTransaction:
+						options.include?.previousTransaction || options.include?.objectBcs ? true : false,
+					showStorageRebate: options.include?.objectBcs ?? false,
+					showContent: options.include?.json ?? false,
 				},
 				signal: options.signal,
 			});
@@ -59,7 +138,7 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 				if (object.error) {
 					results.push(ObjectError.fromResponse(object.error, batch[idx]));
 				} else {
-					results.push(parseObject(object.data!));
+					results.push(parseObject(object.data!, options.include));
 				}
 			}
 		}
@@ -68,18 +147,35 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 			objects: results,
 		};
 	}
-	async getOwnedObjects(options: Experimental_HaneulClientTypes.GetOwnedObjectsOptions) {
+	async listOwnedObjects<Include extends HaneulClientTypes.ObjectInclude = object>(
+		options: HaneulClientTypes.ListOwnedObjectsOptions<Include>,
+	) {
+		let filter: HaneulObjectDataFilter | null = null;
+		if (options.type) {
+			const parts = options.type.split('::');
+			if (parts.length === 1) {
+				filter = { Package: options.type };
+			} else if (parts.length === 2) {
+				filter = { MoveModule: { package: parts[0], module: parts[1] } };
+			} else {
+				filter = { StructType: options.type };
+			}
+		}
+
 		const objects = await this.#jsonRpcClient.getOwnedObjects({
-			owner: options.address,
+			owner: options.owner,
 			limit: options.limit,
 			cursor: options.cursor,
 			options: {
 				showOwner: true,
 				showType: true,
-				showBcs: true,
-				showPreviousTransaction: true,
+				showBcs: options.include?.content || options.include?.objectBcs ? true : false,
+				showPreviousTransaction:
+					options.include?.previousTransaction || options.include?.objectBcs ? true : false,
+				showStorageRebate: options.include?.objectBcs ?? false,
+				showContent: options.include?.json ?? false,
 			},
-			filter: options.type ? { StructType: options.type } : null,
+			filter,
 			signal: options.signal,
 		});
 
@@ -89,16 +185,16 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 					throw ObjectError.fromResponse(result.error);
 				}
 
-				return parseObject(result.data!);
+				return parseObject(result.data!, options.include);
 			}),
 			hasNextPage: objects.hasNextPage,
 			cursor: objects.nextCursor ?? null,
 		};
 	}
 
-	async getCoins(options: Experimental_HaneulClientTypes.GetCoinsOptions) {
+	async listCoins(options: HaneulClientTypes.ListCoinsOptions) {
 		const coins = await this.#jsonRpcClient.getCoins({
-			owner: options.address,
+			owner: options.owner,
 			coinType: options.coinType,
 			limit: options.limit,
 			cursor: options.cursor,
@@ -106,103 +202,159 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 		});
 
 		return {
-			objects: coins.data.map((coin) => {
-				return {
-					id: coin.coinObjectId,
+			objects: coins.data.map(
+				(coin): HaneulClientTypes.Coin => ({
+					objectId: coin.coinObjectId,
 					version: coin.version,
 					digest: coin.digest,
 					balance: coin.balance,
-					type: `0x2::coin::Coin<${coin.coinType}>`,
-					content: Promise.resolve(
-						Coin.serialize({
-							id: coin.coinObjectId,
-							balance: {
-								value: coin.balance,
-							},
-						}).toBytes(),
-					),
+					type: normalizeStructTag(`0x2::coin::Coin<${coin.coinType}>`),
 					owner: {
-						$kind: 'ObjectOwner' as const,
-						ObjectOwner: options.address,
+						$kind: 'AddressOwner' as const,
+						AddressOwner: options.owner,
 					},
-					previousTransaction: coin.previousTransaction,
-				};
-			}),
+				}),
+			),
 			hasNextPage: coins.hasNextPage,
 			cursor: coins.nextCursor ?? null,
 		};
 	}
 
-	async getBalance(options: Experimental_HaneulClientTypes.GetBalanceOptions) {
+	async getBalance(options: HaneulClientTypes.GetBalanceOptions) {
 		const balance = await this.#jsonRpcClient.getBalance({
-			owner: options.address,
+			owner: options.owner,
 			coinType: options.coinType,
 			signal: options.signal,
 		});
 
+		const addressBalance = balance.fundsInAddressBalance ?? '0';
+		const coinBalance = String(BigInt(balance.totalBalance) - BigInt(addressBalance));
+
 		return {
 			balance: {
-				coinType: balance.coinType,
+				coinType: normalizeStructTag(balance.coinType),
 				balance: balance.totalBalance,
+				coinBalance,
+				addressBalance,
 			},
 		};
 	}
-	async getAllBalances(options: Experimental_HaneulClientTypes.GetAllBalancesOptions) {
+	async getCoinMetadata(
+		options: HaneulClientTypes.GetCoinMetadataOptions,
+	): Promise<HaneulClientTypes.GetCoinMetadataResponse> {
+		const coinType = (await this.mvr.resolveType({ type: options.coinType })).type;
+
+		const result = await this.#jsonRpcClient.getCoinMetadata({
+			coinType,
+			signal: options.signal,
+		});
+
+		if (!result) {
+			return { coinMetadata: null };
+		}
+
+		return {
+			coinMetadata: {
+				id: result.id ?? null,
+				decimals: result.decimals,
+				name: result.name,
+				symbol: result.symbol,
+				description: result.description,
+				iconUrl: result.iconUrl ?? null,
+			},
+		};
+	}
+
+	async listBalances(options: HaneulClientTypes.ListBalancesOptions) {
 		const balances = await this.#jsonRpcClient.getAllBalances({
-			owner: options.address,
+			owner: options.owner,
 			signal: options.signal,
 		});
 
 		return {
-			balances: balances.map((balance) => ({
-				coinType: balance.coinType,
-				balance: balance.totalBalance,
-			})),
+			balances: balances.map((balance) => {
+				const addressBalance = balance.fundsInAddressBalance ?? '0';
+				const coinBalance = String(BigInt(balance.totalBalance) - BigInt(addressBalance));
+				return {
+					coinType: normalizeStructTag(balance.coinType),
+					balance: balance.totalBalance,
+					coinBalance,
+					addressBalance,
+				};
+			}),
 			hasNextPage: false,
 			cursor: null,
 		};
 	}
-	async getTransaction(options: Experimental_HaneulClientTypes.GetTransactionOptions) {
+	async getTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
+		options: HaneulClientTypes.GetTransactionOptions<Include>,
+	): Promise<HaneulClientTypes.TransactionResult<Include>> {
 		const transaction = await this.#jsonRpcClient.getTransactionBlock({
 			digest: options.digest,
 			options: {
+				// showRawInput is always needed to extract signatures from SenderSignedData
 				showRawInput: true,
-				showObjectChanges: true,
-				showRawEffects: true,
-				showEvents: true,
+				// showEffects is always needed to get status
 				showEffects: true,
-				showBalanceChanges: true,
+				showObjectChanges: options.include?.objectTypes ?? false,
+				showRawEffects: options.include?.effects ?? false,
+				showEvents: options.include?.events ?? false,
+				showBalanceChanges: options.include?.balanceChanges ?? false,
 			},
 			signal: options.signal,
 		});
 
-		return {
-			transaction: parseTransaction(transaction),
-		};
+		return parseTransaction(transaction, options.include);
 	}
-	async executeTransaction(options: Experimental_HaneulClientTypes.ExecuteTransactionOptions) {
+	async executeTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
+		options: HaneulClientTypes.ExecuteTransactionOptions<Include>,
+	): Promise<HaneulClientTypes.TransactionResult<Include>> {
 		const transaction = await this.#jsonRpcClient.executeTransactionBlock({
 			transactionBlock: options.transaction,
 			signature: options.signatures,
 			options: {
-				showRawEffects: true,
-				showEvents: true,
-				showObjectChanges: true,
+				// showRawInput is always needed to extract signatures from SenderSignedData
 				showRawInput: true,
+				// showEffects is always needed to get status
 				showEffects: true,
-				showBalanceChanges: true,
+				showRawEffects: options.include?.effects ?? false,
+				showEvents: options.include?.events ?? false,
+				showObjectChanges: options.include?.objectTypes ?? false,
+				showBalanceChanges: options.include?.balanceChanges ?? false,
 			},
 			signal: options.signal,
 		});
 
-		return {
-			transaction: parseTransaction(transaction),
-		};
+		return parseTransaction(transaction, options.include);
 	}
-	async dryRunTransaction(options: Experimental_HaneulClientTypes.DryRunTransactionOptions) {
+	async simulateTransaction<Include extends HaneulClientTypes.SimulateTransactionInclude = object>(
+		options: HaneulClientTypes.SimulateTransactionOptions<Include>,
+	): Promise<HaneulClientTypes.SimulateTransactionResult<Include>> {
+		if (!(options.transaction instanceof Uint8Array)) {
+			await options.transaction.prepareForSerialization({ client: this });
+		}
+
 		const tx = Transaction.from(options.transaction);
+
+		const data =
+			options.transaction instanceof Uint8Array
+				? null
+				: TransactionDataBuilder.restore(options.transaction.getData());
+
+		const transactionBytes = data
+			? data.build({
+					overrides: {
+						gasData: {
+							budget: data.gasData.budget ?? String(MAX_GAS),
+							price: data.gasData.price ?? String(await this.#jsonRpcClient.getReferenceGasPrice()),
+							payment: data.gasData.payment ?? [],
+						},
+					},
+				})
+			: (options.transaction as Uint8Array);
+
 		const result = await this.#jsonRpcClient.dryRunTransactionBlock({
-			transactionBlock: options.transaction,
+			transactionBlock: transactionBytes,
 			signal: options.signal,
 		});
 
@@ -211,32 +363,139 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 			objectChanges: result.objectChanges,
 		});
 
-		return {
-			transaction: {
-				digest: await tx.getDigest(),
-				epoch: null,
-				effects,
-				objectTypes: Promise.resolve(objectTypes),
-				signatures: [],
-				transaction: parseTransactionBcs(options.transaction),
-				balanceChanges: result.balanceChanges.map((change) => ({
-					coinType: change.coinType,
-					address: parseOwnerAddress(change.owner)!,
-					amount: change.amount,
-				})),
-			},
+		const transactionData: HaneulClientTypes.Transaction<Include> = {
+			digest: TransactionDataBuilder.getDigestFromBytes(transactionBytes),
+			epoch: null,
+			status: effects.status,
+			effects: (options.include?.effects
+				? effects
+				: undefined) as HaneulClientTypes.Transaction<Include>['effects'],
+			objectTypes: (options.include?.objectTypes
+				? objectTypes
+				: undefined) as HaneulClientTypes.Transaction<Include>['objectTypes'],
+			signatures: [],
+			transaction: (options.include?.transaction
+				? parseTransactionBcs(
+						options.transaction instanceof Uint8Array
+							? options.transaction
+							: await options.transaction
+									.build({
+										client: this,
+									})
+									.catch(() => null as never),
+					)
+				: undefined) as HaneulClientTypes.Transaction<Include>['transaction'],
+			bcs: (options.include?.bcs
+				? transactionBytes
+				: undefined) as HaneulClientTypes.Transaction<Include>['bcs'],
+			balanceChanges: (options.include?.balanceChanges
+				? result.balanceChanges.map((change) => ({
+						coinType: normalizeStructTag(change.coinType),
+						address: parseOwnerAddress(change.owner)!,
+						amount: change.amount,
+					}))
+				: undefined) as HaneulClientTypes.Transaction<Include>['balanceChanges'],
+			events: (options.include?.events
+				? (result.events?.map((event) => ({
+						packageId: event.packageId,
+						module: event.transactionModule,
+						sender: event.sender,
+						eventType: event.type,
+						bcs: 'bcs' in event ? fromBase64(event.bcs) : new Uint8Array(),
+					})) ?? [])
+				: undefined) as HaneulClientTypes.Transaction<Include>['events'],
 		};
+
+		let commandResults: HaneulClientTypes.CommandResult[] | undefined;
+		if (options.include?.commandResults) {
+			try {
+				const sender = tx.getData().sender ?? normalizeHaneulAddress('0x0');
+				const devInspectResult = await this.#jsonRpcClient.devInspectTransactionBlock({
+					sender,
+					transactionBlock: tx,
+					signal: options.signal,
+				});
+
+				if (devInspectResult.results) {
+					commandResults = devInspectResult.results.map((result) => ({
+						returnValues: (result.returnValues ?? []).map(([bytes]) => ({
+							bcs: new Uint8Array(bytes),
+						})),
+						mutatedReferences: (result.mutableReferenceOutputs ?? []).map(([, bytes]) => ({
+							bcs: new Uint8Array(bytes),
+						})),
+					}));
+				}
+			} catch {}
+		}
+
+		return effects.status.success
+			? {
+					$kind: 'Transaction',
+					Transaction: transactionData,
+					commandResults:
+						commandResults as HaneulClientTypes.SimulateTransactionResult<Include>['commandResults'],
+				}
+			: {
+					$kind: 'FailedTransaction',
+					FailedTransaction: transactionData,
+					commandResults:
+						commandResults as HaneulClientTypes.SimulateTransactionResult<Include>['commandResults'],
+				};
 	}
-	async getReferenceGasPrice(options?: Experimental_HaneulClientTypes.GetReferenceGasPriceOptions) {
+	async getReferenceGasPrice(options?: HaneulClientTypes.GetReferenceGasPriceOptions) {
 		const referenceGasPrice = await this.#jsonRpcClient.getReferenceGasPrice({
 			signal: options?.signal,
 		});
+
 		return {
 			referenceGasPrice: String(referenceGasPrice),
 		};
 	}
 
-	async getDynamicFields(options: Experimental_HaneulClientTypes.GetDynamicFieldsOptions) {
+	async getCurrentSystemState(
+		options?: HaneulClientTypes.GetCurrentSystemStateOptions,
+	): Promise<HaneulClientTypes.GetCurrentSystemStateResponse> {
+		const systemState = await this.#jsonRpcClient.getLatestHaneulSystemState({
+			signal: options?.signal,
+		});
+
+		return {
+			systemState: {
+				systemStateVersion: systemState.systemStateVersion,
+				epoch: systemState.epoch,
+				protocolVersion: systemState.protocolVersion,
+				referenceGasPrice: systemState.referenceGasPrice?.toString() ?? (null as never),
+				epochStartTimestampMs: systemState.epochStartTimestampMs,
+				safeMode: systemState.safeMode,
+				safeModeStorageRewards: systemState.safeModeStorageRewards,
+				safeModeComputationRewards: systemState.safeModeComputationRewards,
+				safeModeStorageRebates: systemState.safeModeStorageRebates,
+				safeModeNonRefundableStorageFee: systemState.safeModeNonRefundableStorageFee,
+				parameters: {
+					epochDurationMs: systemState.epochDurationMs,
+					stakeSubsidyStartEpoch: systemState.stakeSubsidyStartEpoch,
+					maxValidatorCount: systemState.maxValidatorCount,
+					minValidatorJoiningStake: systemState.minValidatorJoiningStake,
+					validatorLowStakeThreshold: systemState.validatorLowStakeThreshold,
+					validatorLowStakeGracePeriod: systemState.validatorLowStakeGracePeriod,
+				},
+				storageFund: {
+					totalObjectStorageRebates: systemState.storageFundTotalObjectStorageRebates,
+					nonRefundableBalance: systemState.storageFundNonRefundableBalance,
+				},
+				stakeSubsidy: {
+					balance: systemState.stakeSubsidyBalance,
+					distributionCounter: systemState.stakeSubsidyDistributionCounter,
+					currentDistributionAmount: systemState.stakeSubsidyCurrentDistributionAmount,
+					stakeSubsidyPeriodLength: systemState.stakeSubsidyPeriodLength,
+					stakeSubsidyDecreaseRate: systemState.stakeSubsidyDecreaseRate,
+				},
+			},
+		};
+	}
+
+	async listDynamicFields(options: HaneulClientTypes.ListDynamicFieldsOptions) {
 		const dynamicFields = await this.#jsonRpcClient.getDynamicFields({
 			parentId: options.parentId,
 			limit: options.limit,
@@ -245,13 +504,19 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 
 		return {
 			dynamicFields: dynamicFields.data.map((dynamicField) => {
+				const isDynamicObject = dynamicField.type === 'DynamicObject';
+				const fullType = isDynamicObject
+					? `0x2::dynamic_field::Field<0x2::dynamic_object_field::Wrapper<${dynamicField.name.type}>, 0x2::object::ID>`
+					: `0x2::dynamic_field::Field<${dynamicField.name.type}, ${dynamicField.objectType}>`;
+
 				return {
-					id: dynamicField.objectId,
-					type: dynamicField.objectType,
+					fieldId: dynamicField.objectId,
+					type: normalizeStructTag(fullType),
 					name: {
 						type: dynamicField.name.type,
 						bcs: fromBase64(dynamicField.bcsName),
 					},
+					valueType: dynamicField.objectType,
 				};
 			}),
 			hasNextPage: dynamicFields.hasNextPage,
@@ -259,12 +524,12 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 		};
 	}
 
-	async verifyZkLoginSignature(options: Experimental_HaneulClientTypes.VerifyZkLoginSignatureOptions) {
+	async verifyZkLoginSignature(options: HaneulClientTypes.VerifyZkLoginSignatureOptions) {
 		const result = await this.#jsonRpcClient.verifyZkLoginSignature({
 			bytes: options.bytes,
 			signature: options.signature,
 			intentScope: options.intentScope,
-			author: options.author,
+			author: options.address,
 		});
 
 		return {
@@ -274,8 +539,8 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 	}
 
 	async defaultNameServiceName(
-		options: Experimental_HaneulClientTypes.DefaultNameServiceNameOptions,
-	): Promise<Experimental_HaneulClientTypes.DefaultNameServiceNameResponse> {
+		options: HaneulClientTypes.DefaultNameServiceNameOptions,
+	): Promise<HaneulClientTypes.DefaultNameServiceNameResponse> {
 		const name = (await this.#jsonRpcClient.resolveNameServiceNames(options)).data[0];
 		return {
 			data: {
@@ -285,21 +550,23 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 	}
 
 	resolveTransactionPlugin() {
-		return jsonRpcClientResolveTransactionPlugin(this.#jsonRpcClient);
+		return coreClientResolveTransactionPlugin;
 	}
 
 	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 result = await this.#jsonRpcClient.getNormalizedMoveFunction({
-			package: (await this.mvr.resolvePackage({ package: options.packageId })).package,
+			package: resolvedPackageId,
 			module: options.moduleName,
 			function: options.name,
 		});
 
 		return {
 			function: {
-				packageId: normalizeHaneulAddress(options.packageId),
+				packageId: normalizeHaneulAddress(resolvedPackageId),
 				moduleName: options.moduleName,
 				name: options.name,
 				visibility: parseVisibility(result.visibility),
@@ -308,28 +575,128 @@ export class JSONRpcCoreClient extends Experimental_CoreClient {
 					isPhantom: false,
 					constraints: parseAbilities(abilities),
 				})),
-				parameters: result.parameters.map((param) => parseNormalizedSuiMoveType(param)),
-				returns: result.return.map((ret) => parseNormalizedSuiMoveType(ret)),
+				parameters: result.parameters.map((param) => parseNormalizedHaneulMoveType(param)),
+				returns: result.return.map((ret) => parseNormalizedHaneulMoveType(ret)),
 			},
 		};
 	}
+
+	async getChainIdentifier(
+		_options?: HaneulClientTypes.GetChainIdentifierOptions,
+	): Promise<HaneulClientTypes.GetChainIdentifierResponse> {
+		return this.cache.read(['chainIdentifier'], async () => {
+			const checkpoint = await this.#jsonRpcClient.getCheckpoint({ id: '0' });
+			return {
+				chainIdentifier: checkpoint.digest,
+			};
+		});
+	}
 }
 
-function parseObject(object: HaneulObjectData): Experimental_HaneulClientTypes.ObjectResponse {
+function serializeObjectToBcs(object: HaneulObjectData): Uint8Array | undefined {
+	if (object.bcs?.dataType !== 'moveObject') {
+		return undefined;
+	}
+
+	try {
+		// Normalize the type string to ensure consistent address formatting (0x2 vs 0x00...02)
+		const typeStr = normalizeStructTag(object.bcs.type);
+		let moveObjectType: InferBcsInput<typeof bcs.MoveObjectType>;
+
+		// Normalize constants for comparison
+		const normalizedHaneulFramework = normalizeHaneulAddress(HANEUL_FRAMEWORK_ADDRESS);
+		const gasCoinType = normalizeStructTag(
+			`${HANEUL_FRAMEWORK_ADDRESS}::coin::Coin<${HANEUL_FRAMEWORK_ADDRESS}::haneul::HANEUL>`,
+		);
+		const stakedHaneulType = normalizeStructTag(`${HANEUL_SYSTEM_ADDRESS}::staking_pool::StakedHaneul`);
+		const coinPrefix = `${normalizedHaneulFramework}::coin::Coin<`;
+
+		if (typeStr === gasCoinType) {
+			moveObjectType = { GasCoin: null };
+		} else if (typeStr === stakedHaneulType) {
+			moveObjectType = { StakedHaneul: null };
+		} else if (typeStr.startsWith(coinPrefix)) {
+			const innerTypeMatch = typeStr.match(
+				new RegExp(
+					`${normalizedHaneulFramework.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}::coin::Coin<(.+)>$`,
+				),
+			);
+			if (innerTypeMatch) {
+				const innerTypeTag = TypeTagSerializer.parseFromStr(innerTypeMatch[1], true);
+				moveObjectType = { Coin: innerTypeTag };
+			} else {
+				throw new Error('Failed to parse Coin type');
+			}
+		} else {
+			const typeTag = TypeTagSerializer.parseFromStr(typeStr, true);
+			if (typeof typeTag !== 'object' || !('struct' in typeTag)) {
+				throw new Error('Expected struct type tag');
+			}
+			moveObjectType = { Other: typeTag.struct };
+		}
+
+		const contents = fromBase64(object.bcs.bcsBytes);
+		const owner = convertOwnerToBcs(object.owner!);
+
+		return bcs.Object.serialize({
+			data: {
+				Move: {
+					type: moveObjectType,
+					hasPublicTransfer: object.bcs.hasPublicTransfer,
+					version: object.bcs.version,
+					contents,
+				},
+			},
+			owner,
+			previousTransaction: object.previousTransaction!,
+			storageRebate: object.storageRebate!,
+		}).toBytes();
+	} catch {
+		// If serialization fails, return undefined
+		return undefined;
+	}
+}
+
+function parseObject<Include extends HaneulClientTypes.ObjectInclude = object>(
+	object: HaneulObjectData,
+	include?: Include,
+): HaneulClientTypes.Object<Include> {
+	const bcsContent =
+		object.bcs?.dataType === 'moveObject' ? fromBase64(object.bcs.bcsBytes) : undefined;
+
+	const objectBcs = include?.objectBcs ? serializeObjectToBcs(object) : undefined;
+
+	// Package objects have type "package" which is not a struct tag, so don't normalize it
+	const type =
+		object.type && object.type.includes('::')
+			? normalizeStructTag(object.type)
+			: (object.type ?? '');
+
+	const jsonContent =
+		include?.json && object.content?.dataType === 'moveObject'
+			? (object.content.fields as Record<string, unknown>)
+			: include?.json
+				? null
+				: undefined;
+
 	return {
-		id: object.objectId,
+		objectId: object.objectId,
 		version: object.version,
 		digest: object.digest,
-		type: object.type!,
-		content: Promise.resolve(
-			object.bcs?.dataType === 'moveObject' ? fromBase64(object.bcs.bcsBytes) : new Uint8Array(),
-		),
+		type,
+		content: (include?.content
+			? bcsContent
+			: undefined) as HaneulClientTypes.Object<Include>['content'],
 		owner: parseOwner(object.owner!),
-		previousTransaction: object.previousTransaction ?? null,
+		previousTransaction: (include?.previousTransaction
+			? (object.previousTransaction ?? undefined)
+			: undefined) as HaneulClientTypes.Object<Include>['previousTransaction'],
+		objectBcs: objectBcs as HaneulClientTypes.Object<Include>['objectBcs'],
+		json: jsonContent as HaneulClientTypes.Object<Include>['json'],
 	};
 }
 
-function parseOwner(owner: ObjectOwner): Experimental_HaneulClientTypes.ObjectOwner {
+function parseOwner(owner: ObjectOwner): HaneulClientTypes.ObjectOwner {
 	if (owner === 'Immutable') {
 		return {
 			$kind: 'Immutable',
@@ -373,6 +740,37 @@ function parseOwner(owner: ObjectOwner): Experimental_HaneulClientTypes.ObjectOw
 	throw new Error(`Unknown owner type: ${JSON.stringify(owner)}`);
 }
 
+function convertOwnerToBcs(owner: ObjectOwner) {
+	if (owner === 'Immutable') {
+		return { Immutable: null };
+	}
+
+	if ('AddressOwner' in owner) {
+		return { AddressOwner: owner.AddressOwner };
+	}
+
+	if ('ObjectOwner' in owner) {
+		return { ObjectOwner: owner.ObjectOwner };
+	}
+
+	if ('Shared' in owner) {
+		return {
+			Shared: { initialSharedVersion: owner.Shared.initial_shared_version },
+		};
+	}
+
+	if (typeof owner === 'object' && owner !== null && 'ConsensusAddressOwner' in owner) {
+		return {
+			ConsensusAddressOwner: {
+				startVersion: owner.ConsensusAddressOwner.start_version,
+				owner: owner.ConsensusAddressOwner.owner,
+			},
+		};
+	}
+
+	throw new Error(`Unknown owner type: ${JSON.stringify(owner)}`);
+}
+
 function parseOwnerAddress(owner: ObjectOwner): string | null {
 	if (owner === 'Immutable') {
 		return null;
@@ -397,46 +795,103 @@ function parseOwnerAddress(owner: ObjectOwner): string | null {
 	throw new Error(`Unknown owner type: ${JSON.stringify(owner)}`);
 }
 
-function parseTransaction(
+function parseTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
 	transaction: HaneulTransactionBlockResponse,
-): Experimental_HaneulClientTypes.TransactionResponse {
-	const parsedTx = bcs.SenderSignedData.parse(fromBase64(transaction.rawTransaction!))[0];
+	include?: Include,
+): HaneulClientTypes.TransactionResult<Include> {
 	const objectTypes: Record<string, string> = {};
 
-	transaction.objectChanges?.forEach((change) => {
-		if (change.type !== 'published') {
-			objectTypes[change.objectId] = change.objectType;
+	if (include?.objectTypes) {
+		transaction.objectChanges?.forEach((change) => {
+			if (change.type !== 'published') {
+				objectTypes[change.objectId] = normalizeStructTag(change.objectType);
+			}
+		});
+	}
+
+	let transactionData: HaneulClientTypes.TransactionData | undefined;
+	let signatures: string[] = [];
+	let bcsBytes: Uint8Array | undefined;
+
+	if (transaction.rawTransaction) {
+		const parsedTx = bcs.SenderSignedData.parse(fromBase64(transaction.rawTransaction))[0];
+		signatures = parsedTx.txSignatures;
+
+		if (include?.transaction || include?.bcs) {
+			const bytes = bcs.TransactionData.serialize(parsedTx.intentMessage.value).toBytes();
+
+			if (include?.bcs) {
+				bcsBytes = bytes;
+			}
+
+			if (include?.transaction) {
+				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,
+				});
+				transactionData = { ...data };
+			}
 		}
-	});
+	}
 
-	const bytes = bcs.TransactionData.serialize(parsedTx.intentMessage.value).toBytes();
+	// Get status from JSON-RPC response
+	const status: HaneulClientTypes.ExecutionStatus = transaction.effects?.status
+		? parseJsonRpcExecutionStatus(transaction.effects.status, transaction.effects.abortError)
+		: {
+				success: false,
+				error: {
+					$kind: 'Unknown',
+					message: 'Unknown',
+					Unknown: null,
+				},
+			};
 
-	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,
-	});
+	const effectsBytes = transaction.rawEffects ? new Uint8Array(transaction.rawEffects) : null;
 
-	return {
+	const result: HaneulClientTypes.Transaction<Include> = {
 		digest: transaction.digest,
 		epoch: transaction.effects?.executedEpoch ?? null,
-		effects: parseTransactionEffectsBcs(new Uint8Array(transaction.rawEffects!)),
-		objectTypes: Promise.resolve(objectTypes),
-		transaction: {
-			...data,
-			bcs: bytes,
-		},
-		signatures: parsedTx.txSignatures,
-		balanceChanges:
-			transaction.balanceChanges?.map((change) => ({
-				coinType: change.coinType,
-				address: parseOwnerAddress(change.owner)!,
-				amount: change.amount,
-			})) ?? [],
+		status,
+		effects: (include?.effects && effectsBytes
+			? parseTransactionEffectsBcs(effectsBytes)
+			: undefined) 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,
+		balanceChanges: (include?.balanceChanges
+			? (transaction.balanceChanges?.map((change) => ({
+					coinType: normalizeStructTag(change.coinType),
+					address: parseOwnerAddress(change.owner)!,
+					amount: change.amount,
+				})) ?? [])
+			: undefined) as HaneulClientTypes.Transaction<Include>['balanceChanges'],
+		events: (include?.events
+			? (transaction.events?.map((event) => ({
+					packageId: event.packageId,
+					module: event.transactionModule,
+					sender: event.sender,
+					eventType: event.type,
+					bcs: 'bcs' in event ? fromBase64(event.bcs) : new Uint8Array(),
+				})) ?? [])
+			: undefined) as HaneulClientTypes.Transaction<Include>['events'],
 	};
+
+	return status.success
+		? {
+				$kind: 'Transaction',
+				Transaction: result,
+			}
+		: {
+				$kind: 'FailedTransaction',
+				FailedTransaction: result,
+			};
 }
 
 function parseTransactionEffectsJson({
@@ -448,18 +903,18 @@ function parseTransactionEffectsJson({
 	effects: TransactionEffects;
 	objectChanges: HaneulObjectChange[] | null;
 }): {
-	effects: Experimental_HaneulClientTypes.TransactionEffects;
+	effects: HaneulClientTypes.TransactionEffects;
 	objectTypes: Record<string, string>;
 } {
-	const changedObjects: Experimental_HaneulClientTypes.ChangedObject[] = [];
-	const unchangedConsensusObjects: Experimental_HaneulClientTypes.UnchangedConsensusObject[] = [];
+	const changedObjects: HaneulClientTypes.ChangedObject[] = [];
+	const unchangedConsensusObjects: HaneulClientTypes.UnchangedConsensusObject[] = [];
 	const objectTypes: Record<string, string> = {};
 
 	objectChanges?.forEach((change) => {
 		switch (change.type) {
 			case 'published':
 				changedObjects.push({
-					id: change.packageId,
+					objectId: change.packageId,
 					inputState: 'DoesNotExist',
 					inputVersion: null,
 					inputDigest: null,
@@ -473,7 +928,7 @@ function parseTransactionEffectsJson({
 				break;
 			case 'transferred':
 				changedObjects.push({
-					id: change.objectId,
+					objectId: change.objectId,
 					inputState: 'Exists',
 					inputVersion: change.version,
 					inputDigest: change.digest,
@@ -487,11 +942,11 @@ function parseTransactionEffectsJson({
 					outputOwner: parseOwner(change.recipient),
 					idOperation: 'None',
 				});
-				objectTypes[change.objectId] = change.objectType;
+				objectTypes[change.objectId] = normalizeStructTag(change.objectType);
 				break;
 			case 'mutated':
 				changedObjects.push({
-					id: change.objectId,
+					objectId: change.objectId,
 					inputState: 'Exists',
 					inputVersion: change.previousVersion,
 					inputDigest: null,
@@ -502,11 +957,11 @@ function parseTransactionEffectsJson({
 					outputOwner: parseOwner(change.owner),
 					idOperation: 'None',
 				});
-				objectTypes[change.objectId] = change.objectType;
+				objectTypes[change.objectId] = normalizeStructTag(change.objectType);
 				break;
 			case 'deleted':
 				changedObjects.push({
-					id: change.objectId,
+					objectId: change.objectId,
 					inputState: 'Exists',
 					inputVersion: change.version,
 					inputDigest: effects.deleted?.find((d) => d.objectId === change.objectId)?.digest ?? null,
@@ -517,11 +972,11 @@ function parseTransactionEffectsJson({
 					outputOwner: null,
 					idOperation: 'Deleted',
 				});
-				objectTypes[change.objectId] = change.objectType;
+				objectTypes[change.objectId] = normalizeStructTag(change.objectType);
 				break;
 			case 'wrapped':
 				changedObjects.push({
-					id: change.objectId,
+					objectId: change.objectId,
 					inputState: 'Exists',
 					inputVersion: change.version,
 					inputDigest: null,
@@ -539,11 +994,11 @@ function parseTransactionEffectsJson({
 					},
 					idOperation: 'None',
 				});
-				objectTypes[change.objectId] = change.objectType;
+				objectTypes[change.objectId] = normalizeStructTag(change.objectType);
 				break;
 			case 'created':
 				changedObjects.push({
-					id: change.objectId,
+					objectId: change.objectId,
 					inputState: 'DoesNotExist',
 					inputVersion: null,
 					inputDigest: null,
@@ -554,7 +1009,7 @@ function parseTransactionEffectsJson({
 					outputOwner: parseOwner(change.owner),
 					idOperation: 'Created',
 				});
-				objectTypes[change.objectId] = change.objectType;
+				objectTypes[change.objectId] = normalizeStructTag(change.objectType);
 				break;
 		}
 	});
@@ -563,16 +1018,12 @@ function parseTransactionEffectsJson({
 		objectTypes,
 		effects: {
 			bcs: bytes ?? null,
-			digest: effects.transactionDigest,
 			version: 2,
-			status:
-				effects.status.status === 'success'
-					? { success: true, error: null }
-					: { success: false, error: effects.status.error! },
+			status: parseJsonRpcExecutionStatus(effects.status, effects.abortError),
 			gasUsed: effects.gasUsed,
 			transactionDigest: effects.transactionDigest,
 			gasObject: {
-				id: effects.gasObject?.reference.objectId,
+				objectId: effects.gasObject?.reference.objectId,
 				inputState: 'Exists',
 				inputVersion: null,
 				inputDigest: null,
@@ -593,43 +1044,32 @@ function parseTransactionEffectsJson({
 	};
 }
 
-const Balance = bcs.struct('Balance', {
-	value: bcs.u64(),
-});
-
-const Coin = bcs.struct('Coin', {
-	id: bcs.Address,
-	balance: Balance,
-});
-
-function parseNormalizedSuiMoveType(
-	type: HaneulMoveNormalizedType,
-): Experimental_HaneulClientTypes.OpenSignature {
+function parseNormalizedHaneulMoveType(type: HaneulMoveNormalizedType): HaneulClientTypes.OpenSignature {
 	if (typeof type !== 'string') {
 		if ('Reference' in type) {
 			return {
 				reference: 'immutable',
-				body: parseNormalizedSuiMoveTypeBody(type.Reference),
+				body: parseNormalizedHaneulMoveTypeBody(type.Reference),
 			};
 		}
 
 		if ('MutableReference' in type) {
 			return {
 				reference: 'mutable',
-				body: parseNormalizedSuiMoveTypeBody(type.MutableReference),
+				body: parseNormalizedHaneulMoveTypeBody(type.MutableReference),
 			};
 		}
 	}
 
 	return {
 		reference: null,
-		body: parseNormalizedSuiMoveTypeBody(type),
+		body: parseNormalizedHaneulMoveTypeBody(type),
 	};
 }
 
-function parseNormalizedSuiMoveTypeBody(
+function parseNormalizedHaneulMoveTypeBody(
 	type: HaneulMoveNormalizedType,
-): Experimental_HaneulClientTypes.OpenSignatureBody {
+): HaneulClientTypes.OpenSignatureBody {
 	switch (type) {
 		case 'Address':
 			return { $kind: 'address' };
@@ -656,7 +1096,7 @@ function parseNormalizedSuiMoveTypeBody(
 	if ('Vector' in type) {
 		return {
 			$kind: 'vector',
-			vector: parseNormalizedSuiMoveTypeBody(type.Vector),
+			vector: parseNormalizedHaneulMoveTypeBody(type.Vector),
 		};
 	}
 
@@ -665,7 +1105,7 @@ function parseNormalizedSuiMoveTypeBody(
 			$kind: 'datatype',
 			datatype: {
 				typeName: `${normalizeHaneulAddress(type.Struct.address)}::${type.Struct.module}::${type.Struct.name}`,
-				typeParameters: type.Struct.typeArguments.map((t) => parseNormalizedSuiMoveTypeBody(t)),
+				typeParameters: type.Struct.typeArguments.map((t) => parseNormalizedHaneulMoveTypeBody(t)),
 			},
 		};
 	}
@@ -680,7 +1120,7 @@ function parseNormalizedSuiMoveTypeBody(
 	throw new Error(`Unknown type: ${JSON.stringify(type)}`);
 }
 
-function parseAbilities(abilitySet: SuiMoveAbilitySet): Experimental_HaneulClientTypes.Ability[] {
+function parseAbilities(abilitySet: HaneulMoveAbilitySet): HaneulClientTypes.Ability[] {
 	return abilitySet.abilities.map((ability) => {
 		switch (ability) {
 			case 'Copy':
@@ -697,7 +1137,7 @@ function parseAbilities(abilitySet: SuiMoveAbilitySet): Experimental_HaneulClien
 	});
 }
 
-function parseVisibility(visibility: SuiMoveVisibility): Experimental_HaneulClientTypes.Visibility {
+function parseVisibility(visibility: HaneulMoveVisibility): HaneulClientTypes.Visibility {
 	switch (visibility) {
 		case 'Public':
 			return 'public';