@mysten/sui 2.21.0 → 2.22.0

package/dist/zklogin/bcs.d.mts

@@ -1,31 +1,31 @@
-import * as _mysten_bcs810 from "@mysten/bcs";
+import * as _mysten_bcs1118 from "@mysten/bcs";
 import { InferBcsInput } from "@mysten/bcs";
 
 //#region src/zklogin/bcs.d.ts
-declare const zkLoginSignature: _mysten_bcs810.BcsStruct<{
-  inputs: _mysten_bcs810.BcsStruct<{
-    proofPoints: _mysten_bcs810.BcsStruct<{
-      a: _mysten_bcs810.BcsType<string[], Iterable<string> & {
+declare const zkLoginSignature: _mysten_bcs1118.BcsStruct<{
+  inputs: _mysten_bcs1118.BcsStruct<{
+    proofPoints: _mysten_bcs1118.BcsStruct<{
+      a: _mysten_bcs1118.BcsType<string[], Iterable<string> & {
         length: number;
       }, string>;
-      b: _mysten_bcs810.BcsType<string[][], Iterable<Iterable<string> & {
+      b: _mysten_bcs1118.BcsType<string[][], Iterable<Iterable<string> & {
         length: number;
       }> & {
         length: number;
       }, string>;
-      c: _mysten_bcs810.BcsType<string[], Iterable<string> & {
+      c: _mysten_bcs1118.BcsType<string[], Iterable<string> & {
         length: number;
       }, string>;
     }, string>;
-    issBase64Details: _mysten_bcs810.BcsStruct<{
-      value: _mysten_bcs810.BcsType<string, string, "string">;
-      indexMod4: _mysten_bcs810.BcsType<number, number, "u8">;
+    issBase64Details: _mysten_bcs1118.BcsStruct<{
+      value: _mysten_bcs1118.BcsType<string, string, "string">;
+      indexMod4: _mysten_bcs1118.BcsType<number, number, "u8">;
     }, string>;
-    headerBase64: _mysten_bcs810.BcsType<string, string, "string">;
-    addressSeed: _mysten_bcs810.BcsType<string, string, "string">;
+    headerBase64: _mysten_bcs1118.BcsType<string, string, "string">;
+    addressSeed: _mysten_bcs1118.BcsType<string, string, "string">;
   }, string>;
-  maxEpoch: _mysten_bcs810.BcsType<string, string | number | bigint, "u64">;
-  userSignature: _mysten_bcs810.BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
+  maxEpoch: _mysten_bcs1118.BcsType<string, string | number | bigint, "u64">;
+  userSignature: _mysten_bcs1118.BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
 }, string>;
 type ZkLoginSignature = InferBcsInput<typeof zkLoginSignature>;
 type ZkLoginSignatureInputs = ZkLoginSignature['inputs'];

package/dist/zklogin/bcs.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"bcs.d.mts","names":[],"sources":["../../src/zklogin/bcs.ts"],"mappings":";;;;cAMa,gBAAA,iBAAgB,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAkBjB,gBAAA,GAAmB,aAAA,QAAqB,gBAAA;AAAA,KACxC,sBAAA,GAAyB,gBAAA"}
+{"version":3,"file":"bcs.d.mts","names":[],"sources":["../../src/zklogin/bcs.ts"],"mappings":";;;;cAMa,gBAAA,kBAAgB,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAkBjB,gBAAA,GAAmB,aAAA,QAAqB,gBAAA;AAAA,KACxC,sBAAA,GAAyB,gBAAA"}

package/package.json

@@ -3,7 +3,7 @@
   "author": "Mysten Labs <build@mystenlabs.com>",
   "description": "Sui TypeScript API",
   "homepage": "https://sdk.mystenlabs.com",
-  "version": "2.21.0",
+  "version": "2.22.0",
   "license": "Apache-2.0",
   "sideEffects": false,
   "files": [

package/src/grpc/client.ts

@@ -57,6 +57,78 @@ export interface ListDynamicFieldsWithValueResponse<Include extends DynamicField
 	dynamicFields: DynamicFieldEntryWithValue<Include>[];
 }
 
+export interface GrpcTransactionInclude extends SuiClientTypes.TransactionInclude {
+	/** Include the parsed protobuf JSON value for the gRPC transaction response. */
+	protoJson?: boolean;
+}
+
+export interface GrpcSimulateTransactionInclude extends SuiClientTypes.SimulateTransactionInclude {
+	/** Include the parsed protobuf JSON value for the gRPC simulation response. */
+	protoJson?: boolean;
+}
+
+export type GrpcTransactionProtoJson = ReturnType<
+	typeof import('./proto/sui/rpc/v2/executed_transaction.js').ExecutedTransaction.toJson
+>;
+
+export type GrpcSimulateTransactionProtoJson = ReturnType<
+	typeof import('./proto/sui/rpc/v2/transaction_execution_service.js').SimulateTransactionResponse.toJson
+>;
+
+type ProtoJson<Include extends { protoJson?: boolean }, Json> = Include['protoJson'] extends true
+	? Json
+	: undefined;
+
+export type GrpcTransactionResult<Include extends GrpcTransactionInclude = {}> =
+	SuiClientTypes.TransactionResult<Include> & {
+		protoJson: ProtoJson<Include, GrpcTransactionProtoJson>;
+	};
+
+export type GrpcSimulateTransactionResult<Include extends GrpcSimulateTransactionInclude = {}> =
+	SuiClientTypes.SimulateTransactionResult<Include> & {
+		protoJson: ProtoJson<Include, GrpcSimulateTransactionProtoJson>;
+	};
+
+export interface GrpcGetTransactionOptions<
+	Include extends GrpcTransactionInclude = {},
+> extends SuiClientTypes.GetTransactionOptions<Include> {
+	include?: Include & GrpcTransactionInclude;
+}
+
+export interface GrpcWaitForTransactionByDigest<
+	Include extends GrpcTransactionInclude = {},
+> extends SuiClientTypes.WaitForTransactionByDigest<Include> {
+	include?: Include & GrpcTransactionInclude;
+}
+
+export interface GrpcWaitForTransactionByResult<
+	Include extends GrpcTransactionInclude = {},
+> extends SuiClientTypes.WaitForTransactionByResult<Include> {
+	include?: Include & GrpcTransactionInclude;
+}
+
+export type GrpcWaitForTransactionOptions<Include extends GrpcTransactionInclude = {}> =
+	| GrpcWaitForTransactionByDigest<Include>
+	| GrpcWaitForTransactionByResult<Include>;
+
+export interface GrpcExecuteTransactionOptions<
+	Include extends GrpcTransactionInclude = {},
+> extends SuiClientTypes.ExecuteTransactionOptions<Include> {
+	include?: Include & GrpcTransactionInclude;
+}
+
+export interface GrpcSignAndExecuteTransactionOptions<
+	Include extends GrpcTransactionInclude = {},
+> extends SuiClientTypes.SignAndExecuteTransactionOptions<Include> {
+	include?: Include & GrpcTransactionInclude;
+}
+
+export interface GrpcSimulateTransactionOptions<
+	Include extends GrpcSimulateTransactionInclude = {},
+> extends SuiClientTypes.SimulateTransactionOptions<Include> {
+	include?: Include & GrpcSimulateTransactionInclude;
+}
+
 export class SuiGrpcClient extends BaseClient implements SuiClientTypes.TransportMethods {
 	core: GrpcCoreClient;
 	get mvr(): SuiClientTypes.MvrMethods {
@@ -135,34 +207,34 @@ export class SuiGrpcClient extends BaseClient implements SuiClientTypes.Transpor
 		return this.core.getCoinMetadata(input);
 	}
 
-	getTransaction<Include extends SuiClientTypes.TransactionInclude = {}>(
-		input: SuiClientTypes.GetTransactionOptions<Include>,
-	): Promise<SuiClientTypes.TransactionResult<Include>> {
-		return this.core.getTransaction(input);
+	getTransaction<Include extends GrpcTransactionInclude = {}>(
+		input: GrpcGetTransactionOptions<Include>,
+	): Promise<GrpcTransactionResult<Include>> {
+		return this.core.getTransaction(input) as Promise<GrpcTransactionResult<Include>>;
 	}
 
-	executeTransaction<Include extends SuiClientTypes.TransactionInclude = {}>(
-		input: SuiClientTypes.ExecuteTransactionOptions<Include>,
-	): Promise<SuiClientTypes.TransactionResult<Include>> {
-		return this.core.executeTransaction(input);
+	executeTransaction<Include extends GrpcTransactionInclude = {}>(
+		input: GrpcExecuteTransactionOptions<Include>,
+	): Promise<GrpcTransactionResult<Include>> {
+		return this.core.executeTransaction(input) as Promise<GrpcTransactionResult<Include>>;
 	}
 
-	signAndExecuteTransaction<Include extends SuiClientTypes.TransactionInclude = {}>(
-		input: SuiClientTypes.SignAndExecuteTransactionOptions<Include>,
-	): Promise<SuiClientTypes.TransactionResult<Include>> {
-		return this.core.signAndExecuteTransaction(input);
+	signAndExecuteTransaction<Include extends GrpcTransactionInclude = {}>(
+		input: GrpcSignAndExecuteTransactionOptions<Include>,
+	): Promise<GrpcTransactionResult<Include>> {
+		return this.core.signAndExecuteTransaction(input) as Promise<GrpcTransactionResult<Include>>;
 	}
 
-	waitForTransaction<Include extends SuiClientTypes.TransactionInclude = {}>(
-		input: SuiClientTypes.WaitForTransactionOptions<Include>,
-	): Promise<SuiClientTypes.TransactionResult<Include>> {
-		return this.core.waitForTransaction(input);
+	waitForTransaction<Include extends GrpcTransactionInclude = {}>(
+		input: GrpcWaitForTransactionOptions<Include>,
+	): Promise<GrpcTransactionResult<Include>> {
+		return this.core.waitForTransaction(input) as Promise<GrpcTransactionResult<Include>>;
 	}
 
-	simulateTransaction<Include extends SuiClientTypes.SimulateTransactionInclude = {}>(
-		input: SuiClientTypes.SimulateTransactionOptions<Include>,
-	): Promise<SuiClientTypes.SimulateTransactionResult<Include>> {
-		return this.core.simulateTransaction(input);
+	simulateTransaction<Include extends GrpcSimulateTransactionInclude = {}>(
+		input: GrpcSimulateTransactionOptions<Include>,
+	): Promise<GrpcSimulateTransactionResult<Include>> {
+		return this.core.simulateTransaction(input) as Promise<GrpcSimulateTransactionResult<Include>>;
 	}
 
 	getReferenceGasPrice(): Promise<SuiClientTypes.GetReferenceGasPriceResponse> {

package/src/grpc/core.ts

@@ -8,7 +8,6 @@ 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';
 import { chunk, fromBase64, toBase64 } from '@mysten/utils';
-import type { ExecutedTransaction } from './proto/sui/rpc/v2/executed_transaction.js';
 import type { TransactionEffects } from './proto/sui/rpc/v2/effects.js';
 import {
 	UnchangedConsensusObject_UnchangedConsensusObjectKind,
@@ -45,12 +44,16 @@ 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';
+import { ExecutedTransaction } from './proto/sui/rpc/v2/executed_transaction.js';
+import {
+	SimulateTransactionRequest_TransactionChecks,
+	SimulateTransactionResponse,
+} from './proto/sui/rpc/v2/transaction_execution_service.js';
 
 export interface GrpcCoreClientOptions extends CoreClientOptions {
 	client: SuiGrpcClient;
 }
+
 export class GrpcCoreClient extends CoreClient {
 	#client: SuiGrpcClient;
 	constructor({ client, ...options }: GrpcCoreClientOptions) {
@@ -331,37 +334,11 @@ export class GrpcCoreClient extends CoreClient {
 	async getTransaction<Include extends SuiClientTypes.TransactionInclude = {}>(
 		options: SuiClientTypes.GetTransactionOptions<Include>,
 	): Promise<SuiClientTypes.TransactionResult<Include>> {
-		const paths = ['digest', 'transaction.digest', 'signatures', 'effects.status'];
-		if (options.include?.transaction) {
-			paths.push(
-				'transaction.sender',
-				'transaction.gas_payment',
-				'transaction.expiration',
-				'transaction.kind',
-			);
-		}
-		if (options.include?.bcs) {
-			paths.push('transaction.bcs');
-		}
-		if (options.include?.balanceChanges) {
-			paths.push('balance_changes');
-		}
-		if (options.include?.effects) {
-			paths.push('effects');
-		}
-		if (options.include?.events) {
-			paths.push('events');
-		}
-		if (options.include?.objectTypes) {
-			paths.push('effects.changed_objects.object_type');
-			paths.push('effects.changed_objects.object_id');
-		}
-
 		const { response } = await this.#client.ledgerService.getTransaction(
 			{
 				digest: options.digest,
 				readMask: {
-					paths,
+					paths: transactionReadMaskPaths(options.include),
 				},
 			},
 			{ abort: options.signal },
@@ -371,37 +348,15 @@ export class GrpcCoreClient extends CoreClient {
 			throw new Error(`Transaction ${options.digest} not found`);
 		}
 
-		return parseGrpcTransactionResponse(response.transaction, { include: options.include });
+		return withProtoJson(
+			parseGrpcTransactionResponse(response.transaction, { include: options.include }),
+			options.include,
+			() => ExecutedTransaction.toJson(response.transaction!),
+		);
 	}
 	async executeTransaction<Include extends SuiClientTypes.TransactionInclude = {}>(
 		options: SuiClientTypes.ExecuteTransactionOptions<Include>,
 	): Promise<SuiClientTypes.TransactionResult<Include>> {
-		const paths = ['digest', 'transaction.digest', 'signatures', 'effects.status'];
-		if (options.include?.transaction) {
-			paths.push(
-				'transaction.sender',
-				'transaction.gas_payment',
-				'transaction.expiration',
-				'transaction.kind',
-			);
-		}
-		if (options.include?.bcs) {
-			paths.push('transaction.bcs');
-		}
-		if (options.include?.balanceChanges) {
-			paths.push('balance_changes');
-		}
-		if (options.include?.effects) {
-			paths.push('effects');
-		}
-		if (options.include?.events) {
-			paths.push('events');
-		}
-		if (options.include?.objectTypes) {
-			paths.push('effects.changed_objects.object_type');
-			paths.push('effects.changed_objects.object_id');
-		}
-
 		const { response } = await this.#client.transactionExecutionService.executeTransaction(
 			{
 				transaction: {
@@ -418,48 +373,22 @@ export class GrpcCoreClient extends CoreClient {
 					},
 				})),
 				readMask: {
-					paths,
+					paths: transactionReadMaskPaths(options.include),
 				},
 			},
 			{ abort: options.signal },
 		);
 
-		return parseGrpcTransactionResponse(response.transaction!, { include: options.include });
+		return withProtoJson(
+			parseGrpcTransactionResponse(response.transaction!, { include: options.include }),
+			options.include,
+			() => ExecutedTransaction.toJson(response.transaction!),
+		);
 	}
 	async simulateTransaction<Include extends SuiClientTypes.SimulateTransactionInclude = {}>(
 		options: SuiClientTypes.SimulateTransactionOptions<Include>,
 	): Promise<SuiClientTypes.SimulateTransactionResult<Include>> {
-		const paths = [
-			'transaction.digest',
-			'transaction.transaction.digest',
-			'transaction.signatures',
-			'transaction.effects.status',
-		];
-		if (options.include?.transaction) {
-			paths.push(
-				'transaction.transaction.sender',
-				'transaction.transaction.gas_payment',
-				'transaction.transaction.expiration',
-				'transaction.transaction.kind',
-			);
-		}
-		if (options.include?.bcs) {
-			paths.push('transaction.transaction.bcs');
-		}
-		if (options.include?.balanceChanges) {
-			paths.push('transaction.balance_changes');
-		}
-		if (options.include?.effects) {
-			paths.push('transaction.effects');
-		}
-		if (options.include?.events) {
-			paths.push('transaction.events');
-		}
-		if (options.include?.objectTypes) {
-			// Use effects.changed_objects to match JSON-RPC behavior (which uses objectChanges)
-			paths.push('transaction.effects.changed_objects.object_type');
-			paths.push('transaction.effects.changed_objects.object_id');
-		}
+		const paths = transactionReadMaskPaths(options.include, 'transaction.');
 		if (options.include?.commandResults) {
 			paths.push('command_outputs');
 		}
@@ -490,7 +419,11 @@ export class GrpcCoreClient extends CoreClient {
 			{ abort: options.signal },
 		);
 
-		return parseGrpcSimulateTransactionResponse(response, { include: options.include });
+		return withProtoJson(
+			parseGrpcSimulateTransactionResponse(response, { include: options.include }),
+			options.include,
+			() => SimulateTransactionResponse.toJson(response),
+		);
 	}
 	async getReferenceGasPrice(
 		options?: SuiClientTypes.GetReferenceGasPriceOptions,
@@ -843,6 +776,54 @@ export class GrpcCoreClient extends CoreClient {
 	}
 }
 
+function transactionReadMaskPaths(
+	include: SuiClientTypes.TransactionInclude | undefined,
+	prefix = '',
+) {
+	const paths = ['digest', 'transaction.digest', 'signatures', 'effects.status'];
+	if (include?.transaction) {
+		paths.push(
+			'transaction.sender',
+			'transaction.gas_payment',
+			'transaction.expiration',
+			'transaction.kind',
+		);
+	}
+	if (include?.bcs) {
+		paths.push('transaction.bcs');
+	}
+	if (include?.balanceChanges) {
+		paths.push('balance_changes');
+	}
+	if (include?.effects) {
+		paths.push('effects');
+	}
+	if (include?.events) {
+		paths.push('events');
+	}
+	if (include?.objectTypes) {
+		paths.push('effects.changed_objects.object_type');
+		paths.push('effects.changed_objects.object_id');
+	}
+
+	return prefix ? paths.map((path) => prefix + path) : paths;
+}
+
+function withProtoJson<Result>(
+	result: Result,
+	include: ({ protoJson?: boolean } & object) | undefined,
+	getProtoJson: () => unknown,
+): Result {
+	if (!include?.protoJson) {
+		return result;
+	}
+
+	return {
+		...result,
+		protoJson: getProtoJson(),
+	};
+}
+
 function mapDisplayProto(
 	include: boolean | undefined,
 	display: { output?: Value; errors?: Value } | undefined,

package/src/grpc/index.ts

@@ -7,7 +7,20 @@ export {
 	parseGrpcSimulateTransactionResponse,
 	parseGrpcTransactionResponse,
 } from './core.js';
-export type { SuiGrpcClientOptions } from './client.js';
+export type {
+	GrpcExecuteTransactionOptions,
+	GrpcGetTransactionOptions,
+	GrpcSignAndExecuteTransactionOptions,
+	GrpcSimulateTransactionInclude,
+	GrpcSimulateTransactionOptions,
+	GrpcSimulateTransactionProtoJson,
+	GrpcSimulateTransactionResult,
+	GrpcTransactionInclude,
+	GrpcTransactionProtoJson,
+	GrpcTransactionResult,
+	GrpcWaitForTransactionOptions,
+	SuiGrpcClientOptions,
+} from './client.js';
 export type { GrpcCoreClientOptions } from './core.js';
 
 // Re-export transports and types so users can configure custom transports

package/src/version.ts

@@ -3,4 +3,4 @@
 
 // This file is generated by genversion.mjs. Do not edit it directly.
 
-export const PACKAGE_VERSION = '2.21.0';
+export const PACKAGE_VERSION = '2.22.0';