@mysten/sui 2.20.3 → 2.21.0

package/src/grpc/core.ts

@@ -3,6 +3,7 @@
 
 import type { CoreClientOptions, SuiClientTypes } from '../client/index.js';
 import { CoreClient, formatMoveAbortMessage, SimulationError } from '../client/index.js';
+import { raceSignal } from '../client/mvr.js';
 import type { SuiGrpcClient } from './client.js';
 import type { Owner } from './proto/sui/rpc/v2/owner.js';
 import { Owner_OwnerKind } from './proto/sui/rpc/v2/owner.js';
@@ -44,6 +45,7 @@ import {
 	grpcTransactionToTransactionData,
 } from '../client/transaction-resolver.js';
 import { Value } from './proto/google/protobuf/struct.js';
+import type { SimulateTransactionResponse } from './proto/sui/rpc/v2/transaction_execution_service.js';
 import { SimulateTransactionRequest_TransactionChecks } from './proto/sui/rpc/v2/transaction_execution_service.js';
 
 export interface GrpcCoreClientOptions extends CoreClientOptions {
@@ -80,12 +82,15 @@ export class GrpcCoreClient extends CoreClient {
 		}
 
 		for (const batch of batches) {
-			const response = await this.#client.ledgerService.batchGetObjects({
-				requests: batch.map((id) => ({ objectId: id })),
-				readMask: {
-					paths,
+			const response = await this.#client.ledgerService.batchGetObjects(
+				{
+					requests: batch.map((id) => ({ objectId: id })),
+					readMask: {
+						paths,
+					},
 				},
-			});
+				{ abort: options.signal },
+			);
 
 			results.push(
 				...response.response.objects.map((object): SuiClientTypes.Object<Include> | Error => {
@@ -160,17 +165,20 @@ export class GrpcCoreClient extends CoreClient {
 			paths.push('display');
 		}
 
-		const response = await this.#client.stateService.listOwnedObjects({
-			owner: options.owner,
-			objectType: options.type
-				? (await this.mvr.resolveType({ type: options.type })).type
-				: undefined,
-			pageToken: options.cursor ? fromBase64(options.cursor) : undefined,
-			pageSize: options.limit,
-			readMask: {
-				paths,
+		const response = await this.#client.stateService.listOwnedObjects(
+			{
+				owner: options.owner,
+				objectType: options.type
+					? (await this.mvr.resolveType({ type: options.type, signal: options.signal })).type
+					: undefined,
+				pageToken: options.cursor ? fromBase64(options.cursor) : undefined,
+				pageSize: options.limit,
+				readMask: {
+					paths,
+				},
 			},
-		});
+			{ abort: options.signal },
+		);
 
 		const objects = response.response.objects.map(
 			(object): SuiClientTypes.Object<Include> => ({
@@ -207,15 +215,18 @@ export class GrpcCoreClient extends CoreClient {
 		const paths = ['owner', 'object_type', 'digest', 'version', 'object_id', 'balance'];
 		const coinType = options.coinType ?? SUI_TYPE_ARG;
 
-		const response = await this.#client.stateService.listOwnedObjects({
-			owner: options.owner,
-			objectType: `0x2::coin::Coin<${(await this.mvr.resolveType({ type: coinType })).type}>`,
-			pageToken: options.cursor ? fromBase64(options.cursor) : undefined,
-			pageSize: options.limit,
-			readMask: {
-				paths,
+		const response = await this.#client.stateService.listOwnedObjects(
+			{
+				owner: options.owner,
+				objectType: `0x2::coin::Coin<${(await this.mvr.resolveType({ type: coinType, signal: options.signal })).type}>`,
+				pageToken: options.cursor ? fromBase64(options.cursor) : undefined,
+				pageSize: options.limit,
+				readMask: {
+					paths,
+				},
 			},
-		});
+			{ abort: options.signal },
+		);
 
 		return {
 			objects: response.response.objects.map(
@@ -237,10 +248,13 @@ export class GrpcCoreClient extends CoreClient {
 		options: SuiClientTypes.GetBalanceOptions,
 	): Promise<SuiClientTypes.GetBalanceResponse> {
 		const coinType = options.coinType ?? SUI_TYPE_ARG;
-		const result = await this.#client.stateService.getBalance({
-			owner: options.owner,
-			coinType: (await this.mvr.resolveType({ type: coinType })).type,
-		});
+		const result = await this.#client.stateService.getBalance(
+			{
+				owner: options.owner,
+				coinType: (await this.mvr.resolveType({ type: coinType, signal: options.signal })).type,
+			},
+			{ abort: options.signal },
+		);
 
 		return {
 			balance: {
@@ -255,14 +269,23 @@ export class GrpcCoreClient extends CoreClient {
 	async getCoinMetadata(
 		options: SuiClientTypes.GetCoinMetadataOptions,
 	): Promise<SuiClientTypes.GetCoinMetadataResponse> {
-		const coinType = (await this.mvr.resolveType({ type: options.coinType })).type;
+		const coinType = (
+			await this.mvr.resolveType({ type: options.coinType, signal: options.signal })
+		).type;
 
 		let response;
 		try {
-			({ response } = await this.#client.stateService.getCoinInfo({
-				coinType,
-			}));
-		} catch {
+			({ response } = await this.#client.stateService.getCoinInfo(
+				{
+					coinType,
+				},
+				{ abort: options.signal },
+			));
+		} catch (error) {
+			// Don't swallow cancellation — only treat the coin as missing on real errors.
+			if (options.signal?.aborted) {
+				throw error;
+			}
 			return { coinMetadata: null };
 		}
 
@@ -285,11 +308,14 @@ export class GrpcCoreClient extends CoreClient {
 	async listBalances(
 		options: SuiClientTypes.ListBalancesOptions,
 	): Promise<SuiClientTypes.ListBalancesResponse> {
-		const result = await this.#client.stateService.listBalances({
-			owner: options.owner,
-			pageToken: options.cursor ? fromBase64(options.cursor) : undefined,
-			pageSize: options.limit,
-		});
+		const result = await this.#client.stateService.listBalances(
+			{
+				owner: options.owner,
+				pageToken: options.cursor ? fromBase64(options.cursor) : undefined,
+				pageSize: options.limit,
+			},
+			{ abort: options.signal },
+		);
 
 		return {
 			hasNextPage: !!result.response.nextPageToken,
@@ -331,18 +357,21 @@ export class GrpcCoreClient extends CoreClient {
 			paths.push('effects.changed_objects.object_id');
 		}
 
-		const { response } = await this.#client.ledgerService.getTransaction({
-			digest: options.digest,
-			readMask: {
-				paths,
+		const { response } = await this.#client.ledgerService.getTransaction(
+			{
+				digest: options.digest,
+				readMask: {
+					paths,
+				},
 			},
-		});
+			{ abort: options.signal },
+		);
 
 		if (!response.transaction) {
 			throw new Error(`Transaction ${options.digest} not found`);
 		}
 
-		return parseTransaction(response.transaction, options.include);
+		return parseGrpcTransactionResponse(response.transaction, { include: options.include });
 	}
 	async executeTransaction<Include extends SuiClientTypes.TransactionInclude = {}>(
 		options: SuiClientTypes.ExecuteTransactionOptions<Include>,
@@ -373,26 +402,29 @@ export class GrpcCoreClient extends CoreClient {
 			paths.push('effects.changed_objects.object_id');
 		}
 
-		const { response } = await this.#client.transactionExecutionService.executeTransaction({
-			transaction: {
-				bcs: {
-					value: options.transaction,
-				},
-			},
-			signatures: options.signatures.map((signature) => ({
-				bcs: {
-					value: fromBase64(signature),
+		const { response } = await this.#client.transactionExecutionService.executeTransaction(
+			{
+				transaction: {
+					bcs: {
+						value: options.transaction,
+					},
 				},
-				signature: {
-					oneofKind: undefined,
+				signatures: options.signatures.map((signature) => ({
+					bcs: {
+						value: fromBase64(signature),
+					},
+					signature: {
+						oneofKind: undefined,
+					},
+				})),
+				readMask: {
+					paths,
 				},
-			})),
-			readMask: {
-				paths,
 			},
-		});
+			{ abort: options.signal },
+		);
 
-		return parseTransaction(response.transaction!, options.include);
+		return parseGrpcTransactionResponse(response.transaction!, { include: options.include });
 	}
 	async simulateTransaction<Include extends SuiClientTypes.SimulateTransactionInclude = {}>(
 		options: SuiClientTypes.SimulateTransactionOptions<Include>,
@@ -436,72 +468,56 @@ export class GrpcCoreClient extends CoreClient {
 			await options.transaction.prepareForSerialization({ client: this });
 		}
 
-		const { response } = await this.#client.transactionExecutionService.simulateTransaction({
-			transaction:
-				options.transaction instanceof Uint8Array
-					? {
-							bcs: {
-								value: options.transaction,
-							},
-						}
-					: transactionToGrpcTransaction(options.transaction),
-			readMask: {
-				paths,
+		const { response } = await this.#client.transactionExecutionService.simulateTransaction(
+			{
+				transaction:
+					options.transaction instanceof Uint8Array
+						? {
+								bcs: {
+									value: options.transaction,
+								},
+							}
+						: transactionToGrpcTransaction(options.transaction),
+				readMask: {
+					paths,
+				},
+				doGasSelection: false,
+				checks:
+					options.checksEnabled === false
+						? SimulateTransactionRequest_TransactionChecks.DISABLED
+						: SimulateTransactionRequest_TransactionChecks.ENABLED,
 			},
-			doGasSelection: false,
-			checks:
-				options.checksEnabled === false
-					? SimulateTransactionRequest_TransactionChecks.DISABLED
-					: SimulateTransactionRequest_TransactionChecks.ENABLED,
-		});
+			{ abort: options.signal },
+		);
 
-		const transactionResult = parseTransaction(response.transaction!, options.include);
-
-		// Add command results if requested
-		const commandResults =
-			options.include?.commandResults && response.commandOutputs
-				? response.commandOutputs.map((output) => ({
-						returnValues: (output.returnValues ?? []).map((rv) => ({
-							bcs: rv.value?.value ?? null,
-						})),
-						mutatedReferences: (output.mutatedByRef ?? []).map((mr) => ({
-							bcs: mr.value?.value ?? null,
-						})),
-					}))
-				: undefined;
-
-		if (transactionResult.$kind === 'Transaction') {
-			return {
-				$kind: 'Transaction',
-				Transaction: transactionResult.Transaction,
-				commandResults:
-					commandResults as SuiClientTypes.SimulateTransactionResult<Include>['commandResults'],
-			};
-		} else {
-			return {
-				$kind: 'FailedTransaction',
-				FailedTransaction: transactionResult.FailedTransaction,
-				commandResults:
-					commandResults as SuiClientTypes.SimulateTransactionResult<Include>['commandResults'],
-			};
-		}
+		return parseGrpcSimulateTransactionResponse(response, { include: options.include });
 	}
-	async getReferenceGasPrice(): Promise<SuiClientTypes.GetReferenceGasPriceResponse> {
-		const response = await this.#client.ledgerService.getEpoch({
-			readMask: {
-				paths: ['reference_gas_price'],
+	async getReferenceGasPrice(
+		options?: SuiClientTypes.GetReferenceGasPriceOptions,
+	): Promise<SuiClientTypes.GetReferenceGasPriceResponse> {
+		const response = await this.#client.ledgerService.getEpoch(
+			{
+				readMask: {
+					paths: ['reference_gas_price'],
+				},
 			},
-		});
+			{ abort: options?.signal },
+		);
 
 		return {
 			referenceGasPrice: response.response.epoch?.referenceGasPrice?.toString() ?? '',
 		};
 	}
 
-	async getProtocolConfig(): Promise<SuiClientTypes.GetProtocolConfigResponse> {
-		const response = await this.#client.ledgerService.getEpoch({
-			readMask: { paths: ['protocol_config'] },
-		});
+	async getProtocolConfig(
+		options?: SuiClientTypes.GetProtocolConfigOptions,
+	): Promise<SuiClientTypes.GetProtocolConfigResponse> {
+		const response = await this.#client.ledgerService.getEpoch(
+			{
+				readMask: { paths: ['protocol_config'] },
+			},
+			{ abort: options?.signal },
+		);
 
 		const protocolConfig = response.response.epoch?.protocolConfig;
 		if (!protocolConfig) {
@@ -525,26 +541,31 @@ export class GrpcCoreClient extends CoreClient {
 		};
 	}
 
-	async getCurrentSystemState(): Promise<SuiClientTypes.GetCurrentSystemStateResponse> {
-		const response = await this.#client.ledgerService.getEpoch({
-			readMask: {
-				paths: [
-					'system_state.version',
-					'system_state.epoch',
-					'system_state.protocol_version',
-					'system_state.reference_gas_price',
-					'system_state.epoch_start_timestamp_ms',
-					'system_state.safe_mode',
-					'system_state.safe_mode_storage_rewards',
-					'system_state.safe_mode_computation_rewards',
-					'system_state.safe_mode_storage_rebates',
-					'system_state.safe_mode_non_refundable_storage_fee',
-					'system_state.parameters',
-					'system_state.storage_fund',
-					'system_state.stake_subsidy',
-				],
+	async getCurrentSystemState(
+		options?: SuiClientTypes.GetCurrentSystemStateOptions,
+	): Promise<SuiClientTypes.GetCurrentSystemStateResponse> {
+		const response = await this.#client.ledgerService.getEpoch(
+			{
+				readMask: {
+					paths: [
+						'system_state.version',
+						'system_state.epoch',
+						'system_state.protocol_version',
+						'system_state.reference_gas_price',
+						'system_state.epoch_start_timestamp_ms',
+						'system_state.safe_mode',
+						'system_state.safe_mode_storage_rewards',
+						'system_state.safe_mode_computation_rewards',
+						'system_state.safe_mode_storage_rebates',
+						'system_state.safe_mode_non_refundable_storage_fee',
+						'system_state.parameters',
+						'system_state.storage_fund',
+						'system_state.stake_subsidy',
+					],
+				},
 			},
-		});
+			{ abort: options?.signal },
+		);
 
 		const epoch = response.response.epoch;
 		const systemState = epoch?.systemState;
@@ -624,22 +645,25 @@ export class GrpcCoreClient extends CoreClient {
 				? bcs.byteVector().serialize(messageBytes).toBytes()
 				: messageBytes;
 
-		const { response } = await this.#client.signatureVerificationService.verifySignature({
-			message: {
-				name: options.intentScope,
-				value: messageValue,
-			},
-			signature: {
-				bcs: {
-					value: fromBase64(options.signature),
+		const { response } = await this.#client.signatureVerificationService.verifySignature(
+			{
+				message: {
+					name: options.intentScope,
+					value: messageValue,
 				},
 				signature: {
-					oneofKind: undefined,
+					bcs: {
+						value: fromBase64(options.signature),
+					},
+					signature: {
+						oneofKind: undefined,
+					},
 				},
+				address: options.address,
+				jwks: [],
 			},
-			address: options.address,
-			jwks: [],
-		});
+			{ abort: options.signal },
+		);
 
 		return {
 			success: response.isValid ?? false,
@@ -652,9 +676,12 @@ export class GrpcCoreClient extends CoreClient {
 	): Promise<SuiClientTypes.DefaultNameServiceNameResponse> {
 		const name =
 			(
-				await this.#client.nameService.reverseLookupName({
-					address: options.address,
-				})
+				await this.#client.nameService.reverseLookupName(
+					{
+						address: options.address,
+					},
+					{ abort: options.signal },
+				)
 			).response.record?.name ?? null;
 		return {
 			data: {
@@ -666,13 +693,17 @@ export class GrpcCoreClient extends CoreClient {
 	async getMoveFunction(
 		options: SuiClientTypes.GetMoveFunctionOptions,
 	): Promise<SuiClientTypes.GetMoveFunctionResponse> {
-		const resolvedPackageId = (await this.mvr.resolvePackage({ package: options.packageId }))
-			.package;
-		const { response } = await this.#client.movePackageService.getFunction({
-			packageId: resolvedPackageId,
-			moduleName: options.moduleName,
-			name: options.name,
-		});
+		const resolvedPackageId = (
+			await this.mvr.resolvePackage({ package: options.packageId, signal: options.signal })
+		).package;
+		const { response } = await this.#client.movePackageService.getFunction(
+			{
+				packageId: resolvedPackageId,
+				moduleName: options.moduleName,
+				name: options.name,
+			},
+			{ abort: options.signal },
+		);
 
 		let visibility: 'public' | 'private' | 'friend' | 'unknown' = 'unknown';
 
@@ -722,17 +753,24 @@ export class GrpcCoreClient extends CoreClient {
 	}
 
 	async getChainIdentifier(
-		_options?: SuiClientTypes.GetChainIdentifierOptions,
+		options?: SuiClientTypes.GetChainIdentifierOptions,
 	): Promise<SuiClientTypes.GetChainIdentifierResponse> {
-		return this.cache.read(['chainIdentifier'], async () => {
-			const { response } = await this.#client.ledgerService.getServiceInfo({});
-			if (!response.chainId) {
-				throw new Error('Chain identifier not found in service info');
-			}
-			return {
-				chainIdentifier: response.chainId,
-			};
-		});
+		// The result is cached and shared across callers, so the underlying request must
+		// not carry any single caller's signal. Isolate cancellation per-caller instead.
+		return raceSignal(
+			Promise.resolve(
+				this.cache.read(['chainIdentifier'], async () => {
+					const { response } = await this.#client.ledgerService.getServiceInfo({});
+					if (!response.chainId) {
+						throw new Error('Chain identifier not found in service info');
+					}
+					return {
+						chainIdentifier: response.chainId,
+					};
+				}),
+			),
+			options?.signal,
+		);
 	}
 
 	resolveTransactionPlugin() {
@@ -1209,10 +1247,15 @@ export function parseTransactionEffects({
 	};
 }
 
-function parseTransaction<Include extends SuiClientTypes.TransactionInclude = {}>(
+export function parseGrpcTransactionResponse<
+	Include extends SuiClientTypes.TransactionInclude = {},
+>(
 	transaction: ExecutedTransaction,
-	include?: Include,
+	options?: {
+		include?: Include & SuiClientTypes.TransactionInclude;
+	},
 ): SuiClientTypes.TransactionResult<Include> {
+	const include = options?.include;
 	const objectTypes: Record<string, string> = {};
 	if (include?.objectTypes) {
 		transaction.effects?.changedObjects?.forEach((change) => {
@@ -1303,6 +1346,46 @@ function parseTransaction<Include extends SuiClientTypes.TransactionInclude = {}
 			};
 }
 
+export function parseGrpcSimulateTransactionResponse<
+	Include extends SuiClientTypes.SimulateTransactionInclude = {},
+>(
+	response: SimulateTransactionResponse,
+	options?: {
+		include?: Include & SuiClientTypes.SimulateTransactionInclude;
+	},
+): SuiClientTypes.SimulateTransactionResult<Include> {
+	const include = options?.include;
+	const transactionResult = parseGrpcTransactionResponse(response.transaction!, { include });
+
+	const commandResults =
+		include?.commandResults && response.commandOutputs
+			? response.commandOutputs.map((output) => ({
+					returnValues: (output.returnValues ?? []).map((rv) => ({
+						bcs: rv.value?.value ?? null,
+					})),
+					mutatedReferences: (output.mutatedByRef ?? []).map((mr) => ({
+						bcs: mr.value?.value ?? null,
+					})),
+				}))
+			: undefined;
+
+	if (transactionResult.$kind === 'Transaction') {
+		return {
+			$kind: 'Transaction',
+			Transaction: transactionResult.Transaction,
+			commandResults:
+				commandResults as SuiClientTypes.SimulateTransactionResult<Include>['commandResults'],
+		};
+	}
+
+	return {
+		$kind: 'FailedTransaction',
+		FailedTransaction: transactionResult.FailedTransaction,
+		commandResults:
+			commandResults as SuiClientTypes.SimulateTransactionResult<Include>['commandResults'],
+	};
+}
+
 function parseNormalizedSuiMoveType(type: OpenSignature): SuiClientTypes.OpenSignature {
 	let reference: 'mutable' | 'immutable' | null = null;
 

package/src/grpc/index.ts

@@ -2,7 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export { SuiGrpcClient, isSuiGrpcClient } from './client.js';
-export { GrpcCoreClient } from './core.js';
+export {
+	GrpcCoreClient,
+	parseGrpcSimulateTransactionResponse,
+	parseGrpcTransactionResponse,
+} from './core.js';
 export type { SuiGrpcClientOptions } from './client.js';
 export type { GrpcCoreClientOptions } from './core.js';