@haneullabs/haneul 2.5.2 → 2.13.0

package/src/grpc/proto/haneul/rpc/v2/system_state.ts

@@ -577,9 +577,9 @@ export interface StakingPool {
 	 * The total number of HANEUL tokens in this pool, including the HANEUL in the rewards_pool, as well as in all the principal
 	 * in the `StakedHaneul` object, updated at epoch boundaries.
 	 *
-	 * @generated from protobuf field: optional uint64 sui_balance = 4;
+	 * @generated from protobuf field: optional uint64 haneul_balance = 4;
 	 */
-	suiBalance?: bigint;
+	haneulBalance?: bigint;
 	/**
 	 * The epoch stake rewards will be added here at the end of each epoch.
 	 *
@@ -613,7 +613,7 @@ export interface StakingPool {
 	 * Pending stake withdrawn during the current epoch, emptied at epoch boundaries.
 	 * This includes both the principal and rewards HANEUL withdrawn.
 	 *
-	 * @generated from protobuf field: optional uint64 pending_total_sui_withdraw = 9;
+	 * @generated from protobuf field: optional uint64 pending_total_haneul_withdraw = 9;
 	 */
 	pendingTotalHaneulWithdraw?: bigint;
 	/**
@@ -1160,7 +1160,7 @@ class StakingPool$Type extends MessageType<StakingPool> {
 			},
 			{
 				no: 9,
-				name: 'pending_total_sui_withdraw',
+				name: 'pending_total_haneul_withdraw',
 				kind: 'scalar',
 				opt: true,
 				T: 4 /*ScalarType.UINT64*/,

package/src/grpc/proto/haneul/rpc/v2/transaction_execution_service.ts

@@ -111,6 +111,14 @@ export interface SimulateTransactionResponse {
 	 * @generated from protobuf field: repeated haneul.rpc.v2.CommandResult command_outputs = 2;
 	 */
 	commandOutputs: CommandResult[];
+	/**
+	 * A suggested gas price to use, that is above RGP, in order to provide a
+	 * better chance of the transaction being included in the presence of
+	 * congested objects.
+	 *
+	 * @generated from protobuf field: optional uint64 suggested_gas_price = 3;
+	 */
+	suggestedGasPrice?: bigint;
 }
 /**
  * An intermediate result/output from the execution of a single command
@@ -214,6 +222,14 @@ class SimulateTransactionResponse$Type extends MessageType<SimulateTransactionRe
 				repeat: 1 /*RepeatType.PACKED*/,
 				T: () => CommandResult,
 			},
+			{
+				no: 3,
+				name: 'suggested_gas_price',
+				kind: 'scalar',
+				opt: true,
+				T: 4 /*ScalarType.UINT64*/,
+				L: 0 /*LongType.BIGINT*/,
+			},
 		]);
 	}
 }

package/src/jsonRpc/client.ts

@@ -5,6 +5,7 @@ import { fromBase58, toBase64, toHex } from '@haneullabs/bcs';
 import type { Signer } from '../cryptography/index.js';
 import { BaseClient } from '../client/client.js';
 import type { HaneulClientTypes } from '../client/types.js';
+import { isCoinReservationDigest } from '../utils/coin-reservation.js';
 import type { Transaction } from '../transactions/Transaction.js';
 import { isTransaction } from '../transactions/Transaction.js';
 import {
@@ -126,30 +127,11 @@ type NetworkOrTransport =
 			url?: never;
 	  };
 
-const SUI_CLIENT_BRAND = Symbol.for('@haneullabs/HaneulJsonRpcClient') as never;
-
-// Magic number used to identify fake address balance coins (last 20 bytes of the digest)
-// See: haneul/crate./haneul-types/src/coin_reservation.rs
-const COIN_RESERVATION_MAGIC = new Uint8Array([
-	0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
-	0xac, 0xac, 0xac, 0xac,
-]);
-
-/**
- * Checks if a digest indicates a fake address balance coin.
- * These "coins" are created by the JSON RPC to represent address balances
- * and should be filtered out from coin listings.
- */
-function isCoinReservationDigest(digestBase58: string): boolean {
-	const digestBytes = fromBase58(digestBase58);
-	// Check if the last 20 bytes match the magic number
-	const last20Bytes = digestBytes.slice(12, 32);
-	return last20Bytes.every((byte, i) => byte === COIN_RESERVATION_MAGIC[i]);
-}
+const HANEUL_CLIENT_BRAND = Symbol.for('@haneullabs/HaneulJsonRpcClient') as never;
 
 export function isHaneulJsonRpcClient(client: unknown): client is HaneulJsonRpcClient {
 	return (
-		typeof client === 'object' && client !== null && (client as any)[SUI_CLIENT_BRAND] === true
+		typeof client === 'object' && client !== null && (client as any)[HANEUL_CLIENT_BRAND] === true
 	);
 }
 
@@ -158,7 +140,7 @@ export class HaneulJsonRpcClient extends BaseClient {
 	jsonRpc = this;
 	protected transport: JsonRpcTransport;
 
-	get [SUI_CLIENT_BRAND]() {
+	get [HANEUL_CLIENT_BRAND]() {
 		return true;
 	}
 
@@ -993,7 +975,7 @@ export class HaneulJsonRpcClient extends BaseClient {
 		});
 	}
 
-	// TODO: Migrate this to `sui_getChainIdentifier` once it is widely available.
+	// TODO: Migrate this to `haneul_getChainIdentifier` once it is widely available.
 	async getChainIdentifier({ signal }: { signal?: AbortSignal } = {}): Promise<string> {
 		const checkpoint = await this.getCheckpoint({ id: '0', signal });
 		const bytes = fromBase58(checkpoint.digest);

package/src/jsonRpc/core.ts

@@ -5,6 +5,8 @@ import { fromBase64, type InferBcsInput } from '@haneullabs/bcs';
 
 import { bcs, TypeTagSerializer } from '../bcs/index.js';
 import type {
+	DevInspectResults,
+	DryRunTransactionBlockResponse,
 	ExecutionStatus as JsonRpcExecutionStatus,
 	ObjectOwner,
 	HaneulMoveAbilitySet,
@@ -22,6 +24,7 @@ import { coreClientResolveTransactionPlugin } from '../client/core-resolver.js';
 import { TransactionDataBuilder } from '../transactions/TransactionData.js';
 import { chunk } from '@haneullabs/utils';
 import { normalizeHaneulAddress, normalizeStructTag } from '../utils/haneul-types.js';
+import { deriveDynamicFieldID } from '../utils/dynamic-fields.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';
@@ -114,7 +117,7 @@ export class JSONRpcCoreClient extends CoreClient {
 		this.#jsonRpcClient = jsonRpcClient;
 	}
 
-	async getObjects<Include extends HaneulClientTypes.ObjectInclude = object>(
+	async getObjects<Include extends HaneulClientTypes.ObjectInclude = {}>(
 		options: HaneulClientTypes.GetObjectsOptions<Include>,
 	) {
 		const batches = chunk(options.objectIds, 50);
@@ -130,6 +133,7 @@ export class JSONRpcCoreClient extends CoreClient {
 						options.include?.previousTransaction || options.include?.objectBcs ? true : false,
 					showStorageRebate: options.include?.objectBcs ?? false,
 					showContent: options.include?.json ?? false,
+					showDisplay: options.include?.display ?? false,
 				},
 				signal: options.signal,
 			});
@@ -147,7 +151,7 @@ export class JSONRpcCoreClient extends CoreClient {
 			objects: results,
 		};
 	}
-	async listOwnedObjects<Include extends HaneulClientTypes.ObjectInclude = object>(
+	async listOwnedObjects<Include extends HaneulClientTypes.ObjectInclude = {}>(
 		options: HaneulClientTypes.ListOwnedObjectsOptions<Include>,
 	) {
 		let filter: HaneulObjectDataFilter | null = null;
@@ -174,6 +178,7 @@ export class JSONRpcCoreClient extends CoreClient {
 					options.include?.previousTransaction || options.include?.objectBcs ? true : false,
 				showStorageRebate: options.include?.objectBcs ?? false,
 				showContent: options.include?.json ?? false,
+				showDisplay: options.include?.display ?? false,
 			},
 			filter,
 			signal: options.signal,
@@ -286,7 +291,7 @@ export class JSONRpcCoreClient extends CoreClient {
 			cursor: null,
 		};
 	}
-	async getTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
+	async getTransaction<Include extends HaneulClientTypes.TransactionInclude = {}>(
 		options: HaneulClientTypes.GetTransactionOptions<Include>,
 	): Promise<HaneulClientTypes.TransactionResult<Include>> {
 		const transaction = await this.#jsonRpcClient.getTransactionBlock({
@@ -306,7 +311,7 @@ export class JSONRpcCoreClient extends CoreClient {
 
 		return parseTransaction(transaction, options.include);
 	}
-	async executeTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
+	async executeTransaction<Include extends HaneulClientTypes.TransactionInclude = {}>(
 		options: HaneulClientTypes.ExecuteTransactionOptions<Include>,
 	): Promise<HaneulClientTypes.TransactionResult<Include>> {
 		const transaction = await this.#jsonRpcClient.executeTransactionBlock({
@@ -327,11 +332,11 @@ export class JSONRpcCoreClient extends CoreClient {
 
 		return parseTransaction(transaction, options.include);
 	}
-	async simulateTransaction<Include extends HaneulClientTypes.SimulateTransactionInclude = object>(
+	async simulateTransaction<Include extends HaneulClientTypes.SimulateTransactionInclude = {}>(
 		options: HaneulClientTypes.SimulateTransactionOptions<Include>,
 	): Promise<HaneulClientTypes.SimulateTransactionResult<Include>> {
 		if (!(options.transaction instanceof Uint8Array)) {
-			await options.transaction.prepareForSerialization({ client: this });
+			await options.transaction.build({ client: this, onlyTransactionKind: true });
 		}
 
 		const tx = Transaction.from(options.transaction);
@@ -353,14 +358,44 @@ export class JSONRpcCoreClient extends CoreClient {
 				})
 			: (options.transaction as Uint8Array);
 
-		const result = await this.#jsonRpcClient.dryRunTransactionBlock({
-			transactionBlock: transactionBytes,
-			signal: options.signal,
-		});
+		const sender = tx.getData().sender ?? normalizeHaneulAddress('0x0');
+		const checksDisabled = options.checksEnabled === false;
+
+		let dryRunResult: DryRunTransactionBlockResponse | null = null;
+		try {
+			dryRunResult = await this.#jsonRpcClient.dryRunTransactionBlock({
+				transactionBlock: transactionBytes,
+				signal: options.signal,
+			});
+		} catch (e) {
+			if (!checksDisabled) {
+				throw e;
+			}
+		}
+
+		let devInspectResult: DevInspectResults | null = null;
+		if (options.include?.commandResults || checksDisabled) {
+			try {
+				devInspectResult = await this.#jsonRpcClient.devInspectTransactionBlock({
+					sender,
+					transactionBlock: tx,
+					signal: options.signal,
+				});
+			} catch {}
+		}
+
+		const dryRunFailed = !dryRunResult || dryRunResult.effects.status.status !== 'success';
+		const effectsSource =
+			checksDisabled && dryRunFailed && devInspectResult
+				? devInspectResult
+				: (dryRunResult ?? devInspectResult);
+		if (!effectsSource) {
+			throw new Error('simulateTransaction failed: no results from dryRun or devInspect');
+		}
 
 		const { effects, objectTypes } = parseTransactionEffectsJson({
-			effects: result.effects,
-			objectChanges: result.objectChanges,
+			effects: effectsSource.effects,
+			objectChanges: dryRunResult?.objectChanges ?? [],
 		});
 
 		const transactionData: HaneulClientTypes.Transaction<Include> = {
@@ -388,45 +423,35 @@ export class JSONRpcCoreClient extends CoreClient {
 			bcs: (options.include?.bcs
 				? transactionBytes
 				: undefined) as HaneulClientTypes.Transaction<Include>['bcs'],
-			balanceChanges: (options.include?.balanceChanges
-				? result.balanceChanges.map((change) => ({
+			balanceChanges: (options.include?.balanceChanges && dryRunResult
+				? dryRunResult.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) => ({
+				? (effectsSource.events?.map((event) => ({
 						packageId: event.packageId,
 						module: event.transactionModule,
 						sender: event.sender,
 						eventType: event.type,
 						bcs: 'bcs' in event ? fromBase64(event.bcs) : new Uint8Array(),
+						json: (event.parsedJson as Record<string, unknown>) ?? null,
 					})) ?? [])
 				: 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 {}
+		if (options.include?.commandResults && 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),
+				})),
+			}));
 		}
 
 		return effects.status.success
@@ -453,6 +478,40 @@ export class JSONRpcCoreClient extends CoreClient {
 		};
 	}
 
+	async getProtocolConfig(
+		options?: HaneulClientTypes.GetProtocolConfigOptions,
+	): Promise<HaneulClientTypes.GetProtocolConfigResponse> {
+		const result = await this.#jsonRpcClient.getProtocolConfig({ signal: options?.signal });
+
+		const attributes: Record<string, string | null> = {};
+		for (const [key, value] of Object.entries(result.attributes)) {
+			if (value === null) {
+				attributes[key] = null;
+			} else if ('u16' in value) {
+				attributes[key] = value.u16;
+			} else if ('u32' in value) {
+				attributes[key] = value.u32;
+			} else if ('u64' in value) {
+				attributes[key] = value.u64;
+			} else if ('f64' in value) {
+				attributes[key] = value.f64;
+			} else if ('bool' in value) {
+				attributes[key] = value.bool;
+			} else {
+				const entries = Object.entries(value);
+				attributes[key] = entries.length === 1 ? String(entries[0][1]) : JSON.stringify(value);
+			}
+		}
+
+		return {
+			protocolConfig: {
+				protocolVersion: result.protocolVersion,
+				featureFlags: { ...result.featureFlags },
+				attributes,
+			},
+		};
+	}
+
 	async getCurrentSystemState(
 		options?: HaneulClientTypes.GetCurrentSystemStateOptions,
 	): Promise<HaneulClientTypes.GetCurrentSystemStateResponse> {
@@ -503,21 +562,27 @@ export class JSONRpcCoreClient extends CoreClient {
 		});
 
 		return {
-			dynamicFields: dynamicFields.data.map((dynamicField) => {
+			dynamicFields: dynamicFields.data.map((dynamicField): HaneulClientTypes.DynamicFieldEntry => {
 				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}>`;
 
+				const bcsBytes = fromBase64(dynamicField.bcsName);
+				const derivedNameType = isDynamicObject
+					? `0x2::dynamic_object_field::Wrapper<${dynamicField.name.type}>`
+					: dynamicField.name.type;
 				return {
-					fieldId: dynamicField.objectId,
+					$kind: isDynamicObject ? 'DynamicObject' : 'DynamicField',
+					fieldId: deriveDynamicFieldID(options.parentId, derivedNameType, bcsBytes),
 					type: normalizeStructTag(fullType),
 					name: {
 						type: dynamicField.name.type,
-						bcs: fromBase64(dynamicField.bcsName),
+						bcs: bcsBytes,
 					},
 					valueType: dynamicField.objectType,
-				};
+					childId: isDynamicObject ? dynamicField.objectId : undefined,
+				} as HaneulClientTypes.DynamicFieldEntry;
 			}),
 			hasNextPage: dynamicFields.hasNextPage,
 			cursor: dynamicFields.nextCursor,
@@ -657,7 +722,7 @@ function serializeObjectToBcs(object: HaneulObjectData): Uint8Array | undefined
 	}
 }
 
-function parseObject<Include extends HaneulClientTypes.ObjectInclude = object>(
+function parseObject<Include extends HaneulClientTypes.ObjectInclude = {}>(
 	object: HaneulObjectData,
 	include?: Include,
 ): HaneulClientTypes.Object<Include> {
@@ -679,6 +744,12 @@ function parseObject<Include extends HaneulClientTypes.ObjectInclude = object>(
 				? null
 				: undefined;
 
+	const displayData = include?.display
+		? object.display?.data != null
+			? { output: object.display.data as Record<string, string>, errors: null }
+			: null
+		: undefined;
+
 	return {
 		objectId: object.objectId,
 		version: object.version,
@@ -693,6 +764,7 @@ function parseObject<Include extends HaneulClientTypes.ObjectInclude = object>(
 			: undefined) as HaneulClientTypes.Object<Include>['previousTransaction'],
 		objectBcs: objectBcs as HaneulClientTypes.Object<Include>['objectBcs'],
 		json: jsonContent as HaneulClientTypes.Object<Include>['json'],
+		display: displayData as HaneulClientTypes.Object<Include>['display'],
 	};
 }
 
@@ -795,7 +867,7 @@ function parseOwnerAddress(owner: ObjectOwner): string | null {
 	throw new Error(`Unknown owner type: ${JSON.stringify(owner)}`);
 }
 
-function parseTransaction<Include extends HaneulClientTypes.TransactionInclude = object>(
+function parseTransaction<Include extends HaneulClientTypes.TransactionInclude = {}>(
 	transaction: HaneulTransactionBlockResponse,
 	include?: Include,
 ): HaneulClientTypes.TransactionResult<Include> {
@@ -879,6 +951,7 @@ function parseTransaction<Include extends HaneulClientTypes.TransactionInclude =
 					sender: event.sender,
 					eventType: event.type,
 					bcs: 'bcs' in event ? fromBase64(event.bcs) : new Uint8Array(),
+					json: (event.parsedJson as Record<string, unknown>) ?? null,
 				})) ?? [])
 			: undefined) as HaneulClientTypes.Transaction<Include>['events'],
 	};

package/src/jsonRpc/http-transport.ts

@@ -3,8 +3,6 @@
 
 import { PACKAGE_VERSION, TARGETED_RPC_VERSION } from '../version.js';
 import { JsonRpcError, HaneulHTTPStatusError } from './errors.js';
-import type { WebsocketClientOptions } from './rpc-websocket-client.js';
-import { WebsocketClient } from './rpc-websocket-client.js';
 
 /**
  * An object defining headers to be passed to the RPC server
@@ -13,15 +11,11 @@ export type HttpHeaders = { [header: string]: string };
 
 export interface JsonRpcHTTPTransportOptions {
 	fetch?: typeof fetch;
-	WebSocketConstructor?: typeof WebSocket;
 	url: string;
 	rpc?: {
 		headers?: HttpHeaders;
 		url?: string;
 	};
-	websocket?: WebsocketClientOptions & {
-		url?: string;
-	};
 }
 
 export interface JsonRpcTransportRequestOptions {
@@ -30,25 +24,13 @@ export interface JsonRpcTransportRequestOptions {
 	signal?: AbortSignal;
 }
 
-export interface JsonRpcTransportSubscribeOptions<T> {
-	method: string;
-	unsubscribe: string;
-	params: unknown[];
-	onMessage: (event: T) => void;
-	signal?: AbortSignal;
-}
-
 export interface JsonRpcTransport {
 	request<T = unknown>(input: JsonRpcTransportRequestOptions): Promise<T>;
-	subscribe<T = unknown>(
-		input: JsonRpcTransportSubscribeOptions<T>,
-	): Promise<() => Promise<boolean>>;
 }
 
 export class JsonRpcHTTPTransport implements JsonRpcTransport {
 	#requestId = 0;
 	#options: JsonRpcHTTPTransportOptions;
-	#websocketClient?: WebsocketClient;
 
 	constructor(options: JsonRpcHTTPTransportOptions) {
 		this.#options = options;
@@ -66,27 +48,6 @@ export class JsonRpcHTTPTransport implements JsonRpcTransport {
 		return fetchFn(input, init);
 	}
 
-	#getWebsocketClient(): WebsocketClient {
-		if (!this.#websocketClient) {
-			const WebSocketConstructor = this.#options.WebSocketConstructor ?? WebSocket;
-			if (!WebSocketConstructor) {
-				throw new Error(
-					'The current environment does not support WebSocket, you can provide a WebSocketConstructor in the options for HaneulHTTPTransport.',
-				);
-			}
-
-			this.#websocketClient = new WebsocketClient(
-				this.#options.websocket?.url ?? this.#options.url,
-				{
-					WebSocketConstructor,
-					...this.#options.websocket,
-				},
-			);
-		}
-
-		return this.#websocketClient;
-	}
-
 	async request<T>(input: JsonRpcTransportRequestOptions): Promise<T> {
 		this.#requestId += 1;
 
@@ -125,17 +86,4 @@ export class JsonRpcHTTPTransport implements JsonRpcTransport {
 
 		return data.result;
 	}
-
-	async subscribe<T>(input: JsonRpcTransportSubscribeOptions<T>): Promise<() => Promise<boolean>> {
-		const unsubscribe = await this.#getWebsocketClient().subscribe(input);
-
-		if (input.signal) {
-			input.signal.throwIfAborted();
-			input.signal.addEventListener('abort', () => {
-				unsubscribe();
-			});
-		}
-
-		return async () => !!(await unsubscribe());
-	}
 }

package/src/jsonRpc/index.ts

@@ -4,7 +4,6 @@
 export {
 	type JsonRpcTransport,
 	type JsonRpcTransportRequestOptions,
-	type JsonRpcTransportSubscribeOptions,
 	type HttpHeaders,
 	type JsonRpcHTTPTransportOptions,
 	JsonRpcHTTPTransport,

package/src/jsonRpc/types/common.ts

@@ -2,4 +2,3 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export type Order = 'ascending' | 'descending';
-export type Unsubscribe = () => Promise<boolean>;

package/src/jsonRpc/types/generated.ts

@@ -7,7 +7,7 @@
  *  ######################################
  *
  * This file is generated from:
- * /crate./haneul-open-rpc/spec/openrpc.json
+ * /crates/haneul-open-rpc/spec/openrpc.json
  */
 
 export interface AccumulatorEvent {
@@ -1374,7 +1374,7 @@ export interface HaneulValidatorSummary {
 	stakingPoolId: string;
 	/** The total number of HANEUL tokens in this pool. */
 	stakingPoolHaneulBalance: string;
-	suiAddress: string;
+	haneulAddress: string;
 	votingPower: string;
 	workerAddress: string;
 	workerPubkeyBytes: string;

package/src/jsonRpc/types/params.ts

@@ -7,7 +7,7 @@
  *  ######################################
  *
  * This file is generated from:
- * /crate./haneul-open-rpc/spec/openrpc.json
+ * /crates/haneul-open-rpc/spec/openrpc.json
  */
 
 import type * as RpcTypes from './generated.js';
@@ -304,7 +304,7 @@ export interface GetLatestHaneulSystemStateParams {
 /**
  * Return the list of objects owned by an address. Note that if the address owns more than
  * `QUERY_MAX_RESULT_LIMIT` objects, the pagination is not accurate, because previous page may have
- * been updated when the next page is fetched. Please use suix_queryObjects if this is a concern.
+ * been updated when the next page is fetched. Please use haneulx_queryObjects if this is a concern.
  */
 export type GetOwnedObjectsParams = {
 	/** the owner's Haneul address */
@@ -454,7 +454,7 @@ export interface UnsafeMoveCallParams {
 	/** the type arguments of the Move function */
 	typeArguments: string[];
 	/**
-	 * the arguments to be passed into the Move function, in [HaneulJson](https://docs.haneul.io/buil./haneul-json)
+	 * the arguments to be passed into the Move function, in [HaneulJson](https://docs.haneul.io/build/haneul-json)
 	 * format
 	 */
 	arguments: unknown[];
@@ -498,7 +498,7 @@ export interface UnsafePayParams {
 }
 /**
  * Send all HANEUL coins to one recipient. This is for HANEUL coin only and does not require a separate gas
- * coin object. Specifically, what pay_all_sui does are: 1. accumulate all HANEUL from input coins and
+ * coin object. Specifically, what pay_all_haneul does are: 1. accumulate all HANEUL from input coins and
  * deposit all HANEUL to the first input coin 2. transfer the updated first coin to the recipient and also
  * use this first coin as gas coin object. 3. the balance of the first input coin after tx is
  * sum(input_coins) - actual_gas_cost. 4. all other input coins other than the first are deleted.
@@ -516,7 +516,7 @@ export interface UnsafePayAllHaneulParams {
 }
 /**
  * Send HANEUL coins to a list of addresses, following a list of amounts. This is for HANEUL coin only and
- * does not require a separate gas coin object. Specifically, what pay_sui does are: 1. debit each
+ * does not require a separate gas coin object. Specifically, what pay_haneul does are: 1. debit each
  * input_coin to create new coin following the order of amounts and assign it to the corresponding
  * recipient. 2. accumulate all residual HANEUL from input coins left and deposit all HANEUL to the first
  * input coin, then use the first input coin as the gas coin object. 3. the balance of the first input
@@ -649,7 +649,7 @@ export interface UnsafeTransferHaneulParams {
 	/** the transaction signer's Haneul address */
 	signer: string;
 	/** the Haneul coin object to be used in this transaction */
-	suiObjectId: string;
+	haneulObjectId: string;
 	/** the gas budget, the transaction will fail if the gas cost exceed the budget */
 	gasBudget: string;
 	/** the recipient's Haneul address */