@haneullabs/haneul 0.1.0 → 2.5.0

package/src/graphql/core.ts

@@ -1,40 +1,57 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { Experimental_CoreClient } from '../experimental/core.js';
-import type { Experimental_HaneulClientTypes } from '../experimental/types.js';
+import { CoreClient } from '../client/core.js';
+import type { HaneulClientTypes } from '../client/types.js';
+import { HANEUL_TYPE_ARG } from '../utils/constants.js';
 import type { GraphQLQueryOptions, HaneulGraphQLClient } from './client.js';
 import type {
 	Object_Owner_FieldsFragment,
 	Transaction_FieldsFragment,
 } from './generated/queries.js';
+
+type GraphQLExecutionError = NonNullable<
+	NonNullable<Transaction_FieldsFragment['effects']>['executionError']
+>;
 import {
-	DefaultHaneulnsNameDocument,
+	DefaultSuinsNameDocument,
 	ExecuteTransactionDocument,
+	ExecutionStatus,
 	GetAllBalancesDocument,
 	GetBalanceDocument,
+	GetChainIdentifierDocument,
+	GetCoinMetadataDocument,
 	GetCoinsDocument,
+	GetCurrentSystemStateDocument,
 	GetDynamicFieldsDocument,
 	GetMoveFunctionDocument,
 	GetOwnedObjectsDocument,
 	GetReferenceGasPriceDocument,
 	GetTransactionBlockDocument,
 	MultiGetObjectsDocument,
+	ResolveTransactionDocument,
 	SimulateTransactionDocument,
 	VerifyZkLoginSignatureDocument,
 	ZkLoginIntentScope,
 } from './generated/queries.js';
-import { ObjectError } from '../experimental/errors.js';
+import { ObjectError, SimulationError } from '../client/errors.js';
 import { chunk, fromBase64, toBase64 } from '@haneullabs/utils';
 import { normalizeStructTag, normalizeHaneulAddress } from '../utils/haneul-types.js';
 import { deriveDynamicFieldID } from '../utils/dynamic-fields.js';
-import {
-	parseTransactionBcs,
-	parseTransactionEffectsBcs,
-} from '../experimental/transports/utils.js';
+import { formatMoveAbortMessage, parseTransactionEffectsBcs } from '../client/utils.js';
 import type { OpenMoveTypeSignatureBody, OpenMoveTypeSignature } from './types.js';
+import {
+	transactionDataToGrpcTransaction,
+	transactionToGrpcJson,
+	grpcTransactionToTransactionData,
+} from '../client/transaction-resolver.js';
+import { BalanceChange as BalanceChangeType } from '../grpc/proto/haneul/rpc/v2/balance_change.js';
+import { TransactionEffects as TransactionEffectsType } from '../grpc/proto/haneul/rpc/v2/effects.js';
+import { Transaction as GrpcTransactionType } from '../grpc/proto/haneul/rpc/v2/transaction.js';
+import { TransactionDataBuilder } from '../transactions/TransactionData.js';
+import type { BuildTransactionOptions } from '../transactions/index.js';
 
-export class GraphQLCoreClient extends Experimental_CoreClient {
+export class GraphQLCoreClient extends CoreClient {
 	#graphqlClient: HaneulGraphQLClient;
 
 	constructor({
@@ -42,7 +59,7 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 		mvr,
 	}: {
 		graphqlClient: HaneulGraphQLClient;
-		mvr?: Experimental_HaneulClientTypes.MvrOptions;
+		mvr?: HaneulClientTypes.MvrOptions;
 	}) {
 		super({ network: graphqlClient.network, base: graphqlClient, mvr });
 		this.#graphqlClient = graphqlClient;
@@ -69,11 +86,11 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 		return extractedData as NonNullable<Data>;
 	}
 
-	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'] = [];
 
 		for (const batch of batches) {
 			const page = await this.#graphqlQuery(
@@ -81,6 +98,10 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 					query: MultiGetObjectsDocument,
 					variables: {
 						objectKeys: batch.map((address) => ({ address })),
+						includeContent: options.include?.content ?? false,
+						includePreviousTransaction: options.include?.previousTransaction ?? false,
+						includeObjectBcs: options.include?.objectBcs ?? false,
+						includeJson: options.include?.json ?? false,
 					},
 				},
 				(result) => result.multiGetObjects,
@@ -97,18 +118,40 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 						if (obj instanceof ObjectError) {
 							return obj;
 						}
+						const bcsContent = obj.asMoveObject?.contents?.bcs
+							? fromBase64(obj.asMoveObject.contents.bcs)
+							: undefined;
+
+						const objectBcs = obj.objectBcs ? fromBase64(obj.objectBcs) : undefined;
+
+						// Determine object type: package or Move object
+						// GraphQL already returns normalized struct tags
+						let type: string;
+						if (obj.asMovePackage) {
+							type = 'package';
+						} else if (obj.asMoveObject?.contents?.type?.repr) {
+							type = obj.asMoveObject.contents.type.repr;
+						} else {
+							type = '';
+						}
+
+						const jsonContent = options.include?.json
+							? obj.asMoveObject?.contents?.json
+								? (obj.asMoveObject.contents.json as Record<string, unknown>)
+								: null
+							: undefined;
+
 						return {
-							id: obj.address,
+							objectId: obj.address,
 							version: obj.version?.toString()!,
 							digest: obj.digest!,
 							owner: mapOwner(obj.owner!),
-							type: obj.asMoveObject?.contents?.type?.repr!,
-							content: Promise.resolve(
-								obj.asMoveObject?.contents?.bcs
-									? fromBase64(obj.asMoveObject.contents.bcs)
-									: new Uint8Array(),
-							),
-							previousTransaction: obj.previousTransaction?.digest ?? null,
+							type,
+							content: bcsContent as HaneulClientTypes.Object<Include>['content'],
+							previousTransaction: (obj.previousTransaction?.digest ??
+								undefined) as HaneulClientTypes.Object<Include>['previousTransaction'],
+							objectBcs: objectBcs as HaneulClientTypes.Object<Include>['objectBcs'],
+							json: jsonContent as HaneulClientTypes.Object<Include>['json'],
 						};
 					}),
 			);
@@ -118,51 +161,67 @@ export class GraphQLCoreClient 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 objects = await this.#graphqlQuery(
 			{
 				query: GetOwnedObjectsDocument,
 				variables: {
-					owner: options.address,
+					owner: options.owner,
 					limit: options.limit,
 					cursor: options.cursor,
 					filter: options.type
 						? { type: (await this.mvr.resolveType({ type: options.type })).type }
 						: undefined,
+					includeContent: options.include?.content ?? false,
+					includePreviousTransaction: options.include?.previousTransaction ?? false,
+					includeObjectBcs: options.include?.objectBcs ?? false,
+					includeJson: options.include?.json ?? false,
 				},
 			},
 			(result) => result.address?.objects,
 		);
 
 		return {
-			objects: objects.nodes.map((obj) => ({
-				id: obj.address,
-				version: obj.version?.toString()!,
-				digest: obj.digest!,
-				owner: mapOwner(obj.owner!),
-				type: obj.contents?.type?.repr!,
-				content: Promise.resolve(
-					obj.contents?.bcs ? fromBase64(obj.contents.bcs) : new Uint8Array(),
-				),
-				previousTransaction: obj.previousTransaction?.digest ?? null,
-			})),
+			objects: objects.nodes.map(
+				(obj): HaneulClientTypes.Object<Include> => ({
+					objectId: obj.address,
+					version: obj.version?.toString()!,
+					digest: obj.digest!,
+					owner: mapOwner(obj.owner!),
+					type: obj.contents?.type?.repr!,
+					content: (obj.contents?.bcs
+						? fromBase64(obj.contents.bcs)
+						: undefined) as HaneulClientTypes.Object<Include>['content'],
+					previousTransaction: (obj.previousTransaction?.digest ??
+						undefined) as HaneulClientTypes.Object<Include>['previousTransaction'],
+					objectBcs: (obj.objectBcs
+						? fromBase64(obj.objectBcs)
+						: undefined) as HaneulClientTypes.Object<Include>['objectBcs'],
+					json: (options.include?.json
+						? obj.contents?.json
+							? (obj.contents.json as Record<string, unknown>)
+							: null
+						: undefined) as HaneulClientTypes.Object<Include>['json'],
+				}),
+			),
 			hasNextPage: objects.pageInfo.hasNextPage,
 			cursor: objects.pageInfo.endCursor ?? null,
 		};
 	}
-	async getCoins(
-		options: Experimental_HaneulClientTypes.GetCoinsOptions,
-	): Promise<Experimental_HaneulClientTypes.GetCoinsResponse> {
+	async listCoins(
+		options: HaneulClientTypes.ListCoinsOptions,
+	): Promise<HaneulClientTypes.ListCoinsResponse> {
+		const coinType = options.coinType ?? HANEUL_TYPE_ARG;
 		const coins = await this.#graphqlQuery(
 			{
 				query: GetCoinsDocument,
 				variables: {
-					owner: options.address,
+					owner: options.owner,
 					cursor: options.cursor,
 					first: options.limit,
-					type: `0x2::coin::Coin<${(await this.mvr.resolveType({ type: options.coinType })).type}>`,
+					type: `0x2::coin::Coin<${(await this.mvr.resolveType({ type: coinType })).type}>`,
 				},
 			},
 			(result) => result.address?.objects,
@@ -171,49 +230,83 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 		return {
 			cursor: coins.pageInfo.endCursor ?? null,
 			hasNextPage: coins.pageInfo.hasNextPage,
-			objects: coins.nodes.map((coin) => ({
-				id: coin.address,
-				version: coin.version?.toString()!,
-				digest: coin.digest!,
-				owner: mapOwner(coin.owner!),
-				type: coin.contents?.type?.repr!,
-				balance: (coin.contents?.json as { balance: string })?.balance,
-				content: Promise.resolve(
-					coin.contents?.bcs ? fromBase64(coin.contents.bcs) : new Uint8Array(),
-				),
-				previousTransaction: coin.previousTransaction?.digest ?? null,
-			})),
+			objects: coins.nodes.map(
+				(coin): HaneulClientTypes.Coin => ({
+					objectId: coin.address,
+					version: coin.version?.toString()!,
+					digest: coin.digest!,
+					owner: mapOwner(coin.owner!),
+					type: coin.contents?.type?.repr!,
+					balance: (coin.contents?.json as { balance: string })?.balance,
+				}),
+			),
 		};
 	}
 
 	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.#graphqlQuery(
 			{
 				query: GetBalanceDocument,
 				variables: {
-					owner: options.address,
-					type: (await this.mvr.resolveType({ type: options.coinType })).type,
+					owner: options.owner,
+					coinType: (await this.mvr.resolveType({ type: coinType })).type,
 				},
 			},
 			(result) => result.address?.balance,
 		);
 
+		const addressBalance = BigInt(result.addressBalance ?? '0');
+		const coinBalance = BigInt(result.totalBalance ?? '0') - addressBalance;
+
 		return {
 			balance: {
-				coinType: result.coinType?.repr!,
-				balance: result.totalBalance!,
+				coinType: result.coinType?.repr ?? coinType,
+				balance: result.totalBalance ?? '0',
+				coinBalance: coinBalance.toString(),
+				addressBalance: addressBalance.toString(),
+			},
+		};
+	}
+	async getCoinMetadata(
+		options: HaneulClientTypes.GetCoinMetadataOptions,
+	): Promise<HaneulClientTypes.GetCoinMetadataResponse> {
+		const coinType = (await this.mvr.resolveType({ type: options.coinType })).type;
+
+		const { data, errors } = await this.#graphqlClient.query({
+			query: GetCoinMetadataDocument,
+			variables: {
+				coinType,
+			},
+		});
+
+		handleGraphQLErrors(errors);
+
+		if (!data?.coinMetadata) {
+			return { coinMetadata: null };
+		}
+
+		return {
+			coinMetadata: {
+				id: data.coinMetadata.address!,
+				decimals: data.coinMetadata.decimals!,
+				name: data.coinMetadata.name!,
+				symbol: data.coinMetadata.symbol!,
+				description: data.coinMetadata.description!,
+				iconUrl: data.coinMetadata.iconUrl ?? null,
 			},
 		};
 	}
-	async getAllBalances(
-		options: Experimental_HaneulClientTypes.GetAllBalancesOptions,
-	): Promise<Experimental_HaneulClientTypes.GetAllBalancesResponse> {
+
+	async listBalances(
+		options: HaneulClientTypes.ListBalancesOptions,
+	): Promise<HaneulClientTypes.ListBalancesResponse> {
 		const balances = await this.#graphqlQuery(
 			{
 				query: GetAllBalancesDocument,
-				variables: { owner: options.address },
+				variables: { owner: options.owner },
 			},
 			(result) => result.address?.balances,
 		);
@@ -221,36 +314,54 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 		return {
 			cursor: balances.pageInfo.endCursor ?? null,
 			hasNextPage: balances.pageInfo.hasNextPage,
-			balances: balances.nodes.map((balance) => ({
-				coinType: balance.coinType?.repr!,
-				balance: balance.totalBalance!,
-			})),
+			balances: balances.nodes.map((balance) => {
+				const addressBalance = BigInt(balance.addressBalance ?? '0');
+				const coinBalance = BigInt(balance.totalBalance ?? '0') - addressBalance;
+				return {
+					coinType: balance.coinType?.repr!,
+					balance: balance.totalBalance!,
+					coinBalance: coinBalance.toString(),
+					addressBalance: addressBalance.toString(),
+				};
+			}),
 		};
 	}
-	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 result = await this.#graphqlQuery(
 			{
 				query: GetTransactionBlockDocument,
-				variables: { digest: options.digest },
+				variables: {
+					digest: options.digest,
+					includeTransaction: options.include?.transaction ?? false,
+					includeEffects: options.include?.effects ?? false,
+					includeEvents: options.include?.events ?? false,
+					includeBalanceChanges: options.include?.balanceChanges ?? false,
+					includeObjectTypes: options.include?.objectTypes ?? false,
+					includeBcs: options.include?.bcs ?? false,
+				},
 			},
 			(result) => result.transaction,
 		);
 
-		return {
-			transaction: parseTransaction(result),
-		};
+		return parseTransaction(result, 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 result = await this.#graphqlQuery(
 			{
 				query: ExecuteTransactionDocument,
 				variables: {
 					transactionDataBcs: toBase64(options.transaction),
 					signatures: options.signatures,
+					includeTransaction: options.include?.transaction ?? false,
+					includeEffects: options.include?.effects ?? false,
+					includeEvents: options.include?.events ?? false,
+					includeBalanceChanges: options.include?.balanceChanges ?? false,
+					includeObjectTypes: options.include?.objectTypes ?? false,
+					includeBcs: options.include?.bcs ?? false,
 				},
 			},
 			(result) => result.executeTransaction,
@@ -263,36 +374,74 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 			throw new AggregateError(result.errors.map((error) => new Error(error)));
 		}
 
-		return {
-			transaction: parseTransaction(result.effects?.transaction!),
-		};
+		return parseTransaction(result.effects?.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>> {
+		if (!(options.transaction instanceof Uint8Array)) {
+			await options.transaction.prepareForSerialization({ client: this });
+		}
+
 		const result = await this.#graphqlQuery(
 			{
 				query: SimulateTransactionDocument,
 				variables: {
-					transaction: {
-						bcs: {
-							value: toBase64(options.transaction),
-						},
-					},
+					transaction:
+						options.transaction instanceof Uint8Array
+							? {
+									bcs: {
+										value: toBase64(options.transaction),
+									},
+								}
+							: transactionToGrpcJson(options.transaction),
+					includeTransaction: options.include?.transaction ?? false,
+					includeEffects: options.include?.effects ?? false,
+					includeEvents: options.include?.events ?? false,
+					includeBalanceChanges: options.include?.balanceChanges ?? false,
+					includeObjectTypes: options.include?.objectTypes ?? false,
+					includeCommandResults: options.include?.commandResults ?? false,
+					includeBcs: options.include?.bcs ?? false,
 				},
 			},
 			(result) => result.simulateTransaction,
 		);
 
-		if (result.error) {
-			throw new Error(result.error);
+		if (result.error && !result.effects?.transaction) {
+			throw new SimulationError(result.error);
 		}
 
-		return {
-			transaction: parseTransaction(result.effects?.transaction!),
-		};
+		const transactionResult = parseTransaction(result.effects?.transaction!, options.include);
+
+		const commandResults =
+			options.include?.commandResults && result.outputs
+				? result.outputs.map((output) => ({
+						returnValues: (output.returnValues ?? []).map((rv) => ({
+							bcs: rv.value?.bcs ? fromBase64(rv.value.bcs) : null,
+						})),
+						mutatedReferences: (output.mutatedReferences ?? []).map((mr) => ({
+							bcs: mr.value?.bcs ? fromBase64(mr.value.bcs) : 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<Experimental_HaneulClientTypes.GetReferenceGasPriceResponse> {
+	async getReferenceGasPrice(): Promise<HaneulClientTypes.GetReferenceGasPriceResponse> {
 		const result = await this.#graphqlQuery(
 			{
 				query: GetReferenceGasPriceDocument,
@@ -301,17 +450,122 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 		);
 
 		return {
-			referenceGasPrice: result,
+			referenceGasPrice: result ?? '',
 		};
 	}
 
-	async getDynamicFields(
-		options: Experimental_HaneulClientTypes.GetDynamicFieldsOptions,
-	): Promise<Experimental_HaneulClientTypes.GetDynamicFieldsResponse> {
+	async getCurrentSystemState(): Promise<HaneulClientTypes.GetCurrentSystemStateResponse> {
+		const result = await this.#graphqlQuery(
+			{
+				query: GetCurrentSystemStateDocument,
+			},
+			(result) => result.epoch,
+		);
+
+		if (!result) {
+			throw new Error('Epoch data not found in response');
+		}
+
+		const startMs = result.startTimestamp
+			? new Date(result.startTimestamp).getTime().toString()
+			: (null as never);
+
+		// Parse the system state JSON from the MoveValue
+		const systemStateJson = result.systemState?.json as
+			| {
+					system_state_version?: string | number;
+					safe_mode?: boolean;
+					safe_mode_storage_rewards?: string;
+					safe_mode_computation_rewards?: string;
+					safe_mode_storage_rebates?: string | number;
+					safe_mode_non_refundable_storage_fee?: string | number;
+					parameters?: {
+						epoch_duration_ms?: string | number;
+						stake_subsidy_start_epoch?: string | number;
+						max_validator_count?: string | number;
+						min_validator_joining_stake?: string | number;
+						validator_low_stake_threshold?: string | number;
+						validator_low_stake_grace_period?: string | number;
+					};
+					storage_fund?: {
+						total_object_storage_rebates?: string;
+						non_refundable_balance?: string;
+					};
+					stake_subsidy?: {
+						balance?: string;
+						distribution_counter?: string | number;
+						current_distribution_amount?: string | number;
+						stake_subsidy_period_length?: string | number;
+						stake_subsidy_decrease_rate?: number;
+					};
+			  }
+			| undefined;
+
+		return {
+			systemState: {
+				systemStateVersion: systemStateJson?.system_state_version?.toString() ?? (null as never),
+				epoch: result.epochId?.toString() ?? (null as never),
+				protocolVersion: result.protocolConfigs?.protocolVersion?.toString() ?? (null as never),
+				referenceGasPrice: result.referenceGasPrice ?? (null as never),
+				epochStartTimestampMs: startMs,
+				safeMode: systemStateJson?.safe_mode ?? false,
+				safeModeStorageRewards: systemStateJson?.safe_mode_storage_rewards ?? (null as never),
+				safeModeComputationRewards:
+					systemStateJson?.safe_mode_computation_rewards ?? (null as never),
+				safeModeStorageRebates:
+					systemStateJson?.safe_mode_storage_rebates?.toString() ?? (null as never),
+				safeModeNonRefundableStorageFee:
+					systemStateJson?.safe_mode_non_refundable_storage_fee?.toString() ?? (null as never),
+				parameters: {
+					epochDurationMs:
+						systemStateJson?.parameters?.epoch_duration_ms?.toString() ?? (null as never),
+					stakeSubsidyStartEpoch:
+						systemStateJson?.parameters?.stake_subsidy_start_epoch?.toString() ?? (null as never),
+					maxValidatorCount:
+						systemStateJson?.parameters?.max_validator_count?.toString() ?? (null as never),
+					minValidatorJoiningStake:
+						systemStateJson?.parameters?.min_validator_joining_stake?.toString() ?? (null as never),
+					validatorLowStakeThreshold:
+						systemStateJson?.parameters?.validator_low_stake_threshold?.toString() ??
+						(null as never),
+					validatorLowStakeGracePeriod:
+						systemStateJson?.parameters?.validator_low_stake_grace_period?.toString() ??
+						(null as never),
+				},
+				storageFund: {
+					totalObjectStorageRebates:
+						systemStateJson?.storage_fund?.total_object_storage_rebates ?? (null as never),
+					nonRefundableBalance:
+						systemStateJson?.storage_fund?.non_refundable_balance ?? (null as never),
+				},
+				stakeSubsidy: {
+					balance: systemStateJson?.stake_subsidy?.balance ?? (null as never),
+					distributionCounter:
+						systemStateJson?.stake_subsidy?.distribution_counter?.toString() ?? (null as never),
+					currentDistributionAmount:
+						systemStateJson?.stake_subsidy?.current_distribution_amount?.toString() ??
+						(null as never),
+					stakeSubsidyPeriodLength:
+						systemStateJson?.stake_subsidy?.stake_subsidy_period_length?.toString() ??
+						(null as never),
+					stakeSubsidyDecreaseRate:
+						systemStateJson?.stake_subsidy?.stake_subsidy_decrease_rate ?? (null as never),
+				},
+			},
+		};
+	}
+
+	async listDynamicFields(
+		options: HaneulClientTypes.ListDynamicFieldsOptions,
+	): Promise<HaneulClientTypes.ListDynamicFieldsResponse> {
 		const result = await this.#graphqlQuery(
 			{
 				query: GetDynamicFieldsDocument,
-				variables: { parentId: options.parentId },
+				variables: {
+					parentId: options.parentId,
+					first: options.limit,
+					cursor: options.cursor,
+				},
 			},
 			(result) => result.address?.dynamicFields,
 		);
@@ -323,7 +577,7 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 						? dynamicField.value.contents?.type?.repr!
 						: dynamicField.value?.type?.repr!;
 				return {
-					id: deriveDynamicFieldID(
+					fieldId: deriveDynamicFieldID(
 						options.parentId,
 						dynamicField.name?.type?.repr!,
 						fromBase64(dynamicField.name?.bcs!),
@@ -346,8 +600,8 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 	}
 
 	async verifyZkLoginSignature(
-		options: Experimental_HaneulClientTypes.VerifyZkLoginSignatureOptions,
-	): Promise<Experimental_HaneulClientTypes.ZkLoginVerifyResponse> {
+		options: HaneulClientTypes.VerifyZkLoginSignatureOptions,
+	): Promise<HaneulClientTypes.ZkLoginVerifyResponse> {
 		const intentScope =
 			options.intentScope === 'TransactionData'
 				? ZkLoginIntentScope.TransactionData
@@ -360,7 +614,7 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 					bytes: options.bytes,
 					signature: options.signature,
 					intentScope,
-					author: options.author,
+					author: options.address,
 				},
 			},
 			(result) => result.verifyZkLoginSignature,
@@ -373,17 +627,17 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 	}
 
 	async defaultNameServiceName(
-		options: Experimental_HaneulClientTypes.DefaultNameServiceNameOptions,
-	): Promise<Experimental_HaneulClientTypes.DefaultNameServiceNameResponse> {
+		options: HaneulClientTypes.DefaultNameServiceNameOptions,
+	): Promise<HaneulClientTypes.DefaultNameServiceNameResponse> {
 		const name = await this.#graphqlQuery(
 			{
-				query: DefaultHaneulnsNameDocument,
+				query: DefaultSuinsNameDocument,
 				signal: options.signal,
 				variables: {
 					address: options.address,
 				},
 			},
-			(result) => result.address?.defaultHaneulnsName ?? null,
+			(result) => result.address?.defaultNameRecord?.domain ?? null,
 		);
 
 		return {
@@ -392,8 +646,8 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 	}
 
 	async getMoveFunction(
-		options: Experimental_HaneulClientTypes.GetMoveFunctionOptions,
-	): Promise<Experimental_HaneulClientTypes.GetMoveFunctionResponse> {
+		options: HaneulClientTypes.GetMoveFunctionOptions,
+	): Promise<HaneulClientTypes.GetMoveFunctionResponse> {
 		const moveFunction = await this.#graphqlQuery(
 			{
 				query: GetMoveFunctionDocument,
@@ -447,16 +701,102 @@ export class GraphQLCoreClient extends Experimental_CoreClient {
 							}) ?? [],
 					})) ?? [],
 				parameters:
-					moveFunction.parameters?.map((param) => parseNormalizedSuiMoveType(param.signature)) ??
+					moveFunction.parameters?.map((param) => parseNormalizedHaneulMoveType(param.signature)) ??
 					[],
 				returns:
-					moveFunction.return?.map(({ signature }) => parseNormalizedSuiMoveType(signature)) ?? [],
+					moveFunction.return?.map(({ signature }) => parseNormalizedHaneulMoveType(signature)) ?? [],
 			},
 		};
 	}
 
-	resolveTransactionPlugin(): never {
-		throw new Error('GraphQL client does not support transaction resolution yet');
+	async getChainIdentifier(
+		_options?: HaneulClientTypes.GetChainIdentifierOptions,
+	): Promise<HaneulClientTypes.GetChainIdentifierResponse> {
+		return this.cache.read(['chainIdentifier'], async () => {
+			const checkpoint = await this.#graphqlQuery(
+				{
+					query: GetChainIdentifierDocument,
+				},
+				(result) => result.checkpoint,
+			);
+			if (!checkpoint?.digest) {
+				throw new Error('Genesis checkpoint digest not found');
+			}
+			return {
+				chainIdentifier: checkpoint.digest,
+			};
+		});
+	}
+
+	resolveTransactionPlugin() {
+		const graphqlClient = this.#graphqlClient;
+		return async function resolveTransactionData(
+			transactionData: TransactionDataBuilder,
+			options: BuildTransactionOptions,
+			next: () => Promise<void>,
+		) {
+			const snapshot = transactionData.snapshot();
+			// If sender is not set, use a dummy address for resolution purposes
+			if (!snapshot.sender) {
+				snapshot.sender = '0x0000000000000000000000000000000000000000000000000000000000000000';
+			}
+			const grpcTransaction = transactionDataToGrpcTransaction(snapshot);
+			const transactionJson = GrpcTransactionType.toJson(grpcTransaction);
+
+			const { data, errors } = await graphqlClient.query({
+				query: ResolveTransactionDocument,
+				variables: {
+					transaction: transactionJson,
+					doGasSelection:
+						!options.onlyTransactionKind &&
+						(snapshot.gasData.budget == null || snapshot.gasData.payment == null),
+				},
+			});
+
+			handleGraphQLErrors(errors);
+
+			if (data?.simulateTransaction?.error) {
+				throw new SimulationError(
+					`Transaction resolution failed: ${data.simulateTransaction.error}`,
+				);
+			}
+
+			const transactionEffects = data?.simulateTransaction?.effects?.transaction?.effects;
+			if (!options.onlyTransactionKind && transactionEffects?.status === ExecutionStatus.Failure) {
+				const executionError = parseGraphQLExecutionError(transactionEffects.executionError);
+				const errorMessage = executionError?.message ?? 'Transaction failed';
+				throw new SimulationError(`Transaction resolution failed: ${errorMessage}`, {
+					executionError,
+				});
+			}
+
+			const resolvedTransactionBcs =
+				data?.simulateTransaction?.effects?.transaction?.transactionBcs;
+
+			if (!resolvedTransactionBcs) {
+				throw new Error('simulateTransaction did not return resolved transaction data');
+			}
+
+			const resolvedBuilder = TransactionDataBuilder.fromBytes(fromBase64(resolvedTransactionBcs));
+			const resolved = resolvedBuilder.snapshot();
+
+			if (options.onlyTransactionKind) {
+				transactionData.applyResolvedData({
+					...resolved,
+					gasData: {
+						budget: null,
+						owner: null,
+						payment: null,
+						price: null,
+					},
+					expiration: null,
+				});
+			} else {
+				transactionData.applyResolvedData(resolved);
+			}
+
+			return await next();
+		};
 	}
 }
 export type GraphQLResponseErrors = Array<{
@@ -486,7 +826,7 @@ class GraphQLResponseError extends Error {
 	}
 }
 
-function mapOwner(owner: Object_Owner_FieldsFragment): Experimental_HaneulClientTypes.ObjectOwner {
+function mapOwner(owner: Object_Owner_FieldsFragment): HaneulClientTypes.ObjectOwner {
 	switch (owner.__typename) {
 		case 'AddressOwner':
 			return { $kind: 'AddressOwner', AddressOwner: owner.address?.address! };
@@ -510,57 +850,118 @@ function mapOwner(owner: Object_Owner_FieldsFragment): Experimental_HaneulClient
 	}
 }
 
-function parseTransaction(
+function parseTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
 	transaction: Transaction_FieldsFragment,
-): Experimental_HaneulClientTypes.TransactionResponse {
+	include?: Include,
+): HaneulClientTypes.TransactionResult<Include> {
 	const objectTypes: Record<string, string> = {};
 
-	transaction.effects?.unchangedConsensusObjects?.nodes.forEach((node) => {
-		if (node.__typename === 'ConsensusObjectRead') {
-			const type = node.object?.asMoveObject?.contents?.type?.repr;
-			const address = node.object?.asMoveObject?.address;
+	if (include?.objectTypes) {
+		const effectsJson = transaction.effects?.effectsJson;
+		if (effectsJson) {
+			const effects = TransactionEffectsType.fromJson(
+				effectsJson as Parameters<typeof TransactionEffectsType.fromJson>[0],
+			);
+			effects.changedObjects?.forEach((change) => {
+				if (change.objectId && change.objectType) {
+					objectTypes[change.objectId] = change.objectType;
+				}
+			});
+		}
 
-			if (type && address) {
-				objectTypes[address] = type;
+		const objectChanges = transaction.effects?.objectChanges?.nodes;
+		if (objectChanges) {
+			for (const change of objectChanges) {
+				const type = change.outputState?.asMoveObject?.contents?.type?.repr;
+				if (change.address && type) {
+					objectTypes[change.address] = type;
+				}
 			}
 		}
-	});
-
-	transaction.effects?.objectChanges?.nodes.forEach((node) => {
-		const address = node.address;
-		const type =
-			node.inputState?.asMoveObject?.contents?.type?.repr ??
-			node.outputState?.asMoveObject?.contents?.type?.repr;
+	}
 
-		if (address && type) {
-			objectTypes[address] = type;
+	let balanceChanges: HaneulClientTypes.BalanceChange[] | undefined;
+	if (include?.balanceChanges) {
+		const balanceChangesJson = transaction.effects?.balanceChangesJson;
+		if (Array.isArray(balanceChangesJson)) {
+			balanceChanges = balanceChangesJson.map((json) => {
+				const change = BalanceChangeType.fromJson(
+					json as Parameters<typeof BalanceChangeType.fromJson>[0],
+				);
+				return {
+					coinType: change.coinType!,
+					address: change.address!,
+					amount: change.amount!,
+				};
+			});
+		} else {
+			balanceChanges = [];
 		}
-	});
+	}
 
-	if (transaction.effects?.balanceChanges?.pageInfo.hasNextPage) {
-		throw new Error('Pagination for balance changes is not supported');
+	// Get status from GraphQL response
+	const status: HaneulClientTypes.ExecutionStatus =
+		transaction.effects?.status === ExecutionStatus.Success
+			? { success: true, error: null }
+			: {
+					success: false,
+					error: parseGraphQLExecutionError(transaction.effects?.executionError),
+				};
+
+	let transactionData: HaneulClientTypes.TransactionData | undefined;
+	if (include?.transaction && transaction.transactionJson) {
+		const grpcTx = GrpcTransactionType.fromJson(
+			transaction.transactionJson as Parameters<typeof GrpcTransactionType.fromJson>[0],
+		);
+		const resolved = grpcTransactionToTransactionData(grpcTx);
+		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.transactionBcs ? fromBase64(transaction.transactionBcs) : undefined;
+
+	const result: HaneulClientTypes.Transaction<Include> = {
 		digest: transaction.digest!,
-		effects: parseTransactionEffectsBcs(fromBase64(transaction.effects?.effectsBcs!)),
+		status,
+		effects: (include?.effects
+			? parseTransactionEffectsBcs(fromBase64(transaction.effects?.effectsBcs!))
+			: undefined) as HaneulClientTypes.Transaction<Include>['effects'],
 		epoch: transaction.effects?.epoch?.epochId?.toString() ?? null,
-		objectTypes: Promise.resolve(objectTypes),
-		transaction: parseTransactionBcs(fromBase64(transaction.transactionBcs!)),
+		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) => sig.signatureBytes!),
-		balanceChanges:
-			transaction.effects?.balanceChanges?.nodes.map((change) => ({
-				coinType: change?.coinType?.repr!,
-				address: change.owner?.address!,
-				amount: change.amount!,
-			})) ?? [],
-		// events: transaction.events?.pageInfo.hasNextPage
+		balanceChanges: balanceChanges as HaneulClientTypes.Transaction<Include>['balanceChanges'],
+		events: (include?.events
+			? (transaction.effects?.events?.nodes.map((event) => {
+					const eventType = event.contents?.type?.repr!;
+					const [packageId, module] = eventType.split('::');
+					return {
+						packageId,
+						module,
+						sender: event.sender?.address!,
+						eventType,
+						bcs: event.contents?.bcs ? fromBase64(event.contents.bcs) : new Uint8Array(),
+					};
+				}) ?? [])
+			: undefined) as HaneulClientTypes.Transaction<Include>['events'],
 	};
+
+	return status.success
+		? { $kind: 'Transaction', Transaction: result, FailedTransaction: undefined as never }
+		: { $kind: 'FailedTransaction', Transaction: undefined as never, FailedTransaction: result };
 }
 
-function parseNormalizedSuiMoveType(
-	type: OpenMoveTypeSignature,
-): Experimental_HaneulClientTypes.OpenSignature {
+function parseNormalizedHaneulMoveType(type: OpenMoveTypeSignature): HaneulClientTypes.OpenSignature {
 	let reference: 'mutable' | 'immutable' | null = null;
 
 	if (type.ref === '&') {
@@ -571,13 +972,103 @@ function parseNormalizedSuiMoveType(
 
 	return {
 		reference,
-		body: parseNormalizedSuiMoveTypeBody(type.body),
+		body: parseNormalizedHaneulMoveTypeBody(type.body),
+	};
+}
+
+function parseGraphQLExecutionError(
+	executionError: GraphQLExecutionError | null | undefined,
+): HaneulClientTypes.ExecutionError {
+	const name = mapGraphQLExecutionErrorKind(executionError);
+
+	if (name === 'MoveAbort' && executionError?.abortCode != null) {
+		const location = parseGraphQLMoveLocation(executionError);
+		const cleverError = parseGraphQLCleverError(executionError);
+		const commandMatch = executionError.message?.match(/in (\d+)\w* command/);
+		const command = commandMatch ? parseInt(commandMatch[1], 10) - 1 : undefined;
+
+		return {
+			$kind: 'MoveAbort',
+			message: formatMoveAbortMessage({
+				command,
+				location: location
+					? {
+							package: location.package,
+							module: location.module,
+							functionName: location.functionName,
+							instruction: location.instruction,
+						}
+					: undefined,
+				abortCode: executionError.abortCode!,
+				cleverError: cleverError
+					? {
+							lineNumber: cleverError.lineNumber,
+							constantName: cleverError.constantName,
+							value: cleverError.value,
+						}
+					: undefined,
+			}),
+			command,
+			MoveAbort: {
+				abortCode: executionError.abortCode!,
+				location,
+				cleverError,
+			},
+		};
+	}
+
+	return {
+		$kind: 'Unknown',
+		message: executionError?.message ?? 'Transaction failed',
+		Unknown: null,
+	};
+}
+
+function mapGraphQLExecutionErrorKind(
+	executionError: GraphQLExecutionError | null | undefined,
+): string {
+	if (executionError?.abortCode != null) {
+		return 'MoveAbort';
+	}
+
+	const match = executionError?.message?.match(/^(\w+)/);
+	return match?.[1] ?? 'Unknown';
+}
+
+function parseGraphQLMoveLocation(
+	executionError: GraphQLExecutionError,
+): HaneulClientTypes.MoveLocation | undefined {
+	const hasLocation = executionError.module?.package?.address && executionError.module?.name;
+	if (!hasLocation) {
+		return undefined;
+	}
+
+	return {
+		package: executionError.module?.package?.address,
+		module: executionError.module?.name,
+		functionName: executionError.function?.name,
+		instruction: executionError.instructionOffset ?? undefined,
+	};
+}
+
+function parseGraphQLCleverError(
+	executionError: GraphQLExecutionError,
+): HaneulClientTypes.CleverError | undefined {
+	const hasCleverError = executionError.identifier || executionError.constant;
+	if (!hasCleverError) {
+		return undefined;
+	}
+
+	return {
+		constantName: executionError.identifier ?? undefined,
+		value: executionError.constant ?? undefined,
+		lineNumber: executionError.sourceLineNumber ?? undefined,
 	};
 }
 
-function parseNormalizedSuiMoveTypeBody(
+function parseNormalizedHaneulMoveTypeBody(
 	type: OpenMoveTypeSignatureBody,
-): Experimental_HaneulClientTypes.OpenSignatureBody {
+): HaneulClientTypes.OpenSignatureBody {
 	switch (type) {
 		case 'address':
 			return { $kind: 'address' };
@@ -604,7 +1095,7 @@ function parseNormalizedSuiMoveTypeBody(
 	if ('vector' in type) {
 		return {
 			$kind: 'vector',
-			vector: parseNormalizedSuiMoveTypeBody(type.vector),
+			vector: parseNormalizedHaneulMoveTypeBody(type.vector),
 		};
 	}
 
@@ -613,7 +1104,7 @@ function parseNormalizedSuiMoveTypeBody(
 			$kind: 'datatype',
 			datatype: {
 				typeName: `${normalizeHaneulAddress(type.datatype.package)}::${type.datatype.module}::${type.datatype.type}`,
-				typeParameters: type.datatype.typeParameters.map((t) => parseNormalizedSuiMoveTypeBody(t)),
+				typeParameters: type.datatype.typeParameters.map((t) => parseNormalizedHaneulMoveTypeBody(t)),
 			},
 		};
 	}