@mysten/sui 2.22.0 → 2.23.1

package/src/grpc/proto/sui/rpc/v2/query_options.ts

@@ -0,0 +1,255 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// @generated by protobuf-ts 2.9.6 with parameter force_server_none,optimize_code_size,ts_nocheck
+// @generated from protobuf file "sui/rpc/v2/query_options.proto" (package "sui.rpc.v2", syntax proto3)
+// tslint:disable
+// @ts-nocheck
+//
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+//
+import { MessageType } from '@protobuf-ts/runtime';
+/**
+ * Cursor-bounded query options.
+ *
+ * `after` and `before` are canonical ledger-position bounds, not
+ * ordering-relative cursors. `after` always excludes items at or below that
+ * cursor, and `before` always excludes items at or above that cursor. Ordering
+ * only controls the order of returned items within the resulting open interval.
+ *
+ * When a request also specifies a checkpoint range, cursor bounds and
+ * checkpoint bounds compose by intersection: results come only from ledger
+ * positions inside both. Checkpoint bounds are likewise canonical and
+ * ordering-independent.
+ *
+ * For example, with `after = A`, `before = B`, `ordering = DESCENDING`, and
+ * `limit = N`, the response contains up to N matching items in descending
+ * order from the interval `(A, B)`. If the response ends with
+ * `QUERY_END_REASON_ITEM_LIMIT`, resume by keeping `after = A` and setting
+ * `before` to the last `Watermark.cursor` received. That cursor is the
+ * lowest position reached in ledger order, so it becomes the next exclusive
+ * upper bound.
+ *
+ * @generated from protobuf message sui.rpc.v2.QueryOptions
+ */
+export interface QueryOptions {
+	/**
+	 * The maximum number of items to return. Each method applies its own default
+	 * and maximum. QueryEnd does not count against this limit.
+	 *
+	 * @generated from protobuf field: optional uint32 limit = 1;
+	 */
+	limit?: number;
+	/**
+	 * Opaque exclusive lower bound. Results must be strictly after this cursor in
+	 * canonical ledger order.
+	 *
+	 * @generated from protobuf field: optional bytes after = 2;
+	 */
+	after?: Uint8Array;
+	/**
+	 * Opaque exclusive upper bound. Results must be strictly before this cursor
+	 * in canonical ledger order.
+	 *
+	 * @generated from protobuf field: optional bytes before = 3;
+	 */
+	before?: Uint8Array;
+	/**
+	 * Ordering for returned results. Defaults to ASCENDING.
+	 *
+	 * Ordering only controls the order of results within the bounded interval;
+	 * cursor bounds keep the same meaning for ascending and descending reads.
+	 *
+	 * @generated from protobuf field: optional sui.rpc.v2.Ordering ordering = 4;
+	 */
+	ordering?: Ordering;
+}
+/**
+ * Progress marker for a query scan. Carried on every response frame, whether or
+ * not the frame delivers a matching item. Watermarks never regress in the
+ * requested ordering, but consecutive frames may carry the same watermark when
+ * additional work does not advance the safe resume frontier.
+ *
+ * @generated from protobuf message sui.rpc.v2.Watermark
+ */
+export interface Watermark {
+	/**
+	 * Opaque cursor at this scan position. Set on every watermark. Use as
+	 * `options.after` (ascending) or `options.before` (descending) on the next
+	 * request to resume from here. The most recently received cursor is always
+	 * the safe resume point.
+	 *
+	 * @generated from protobuf field: optional bytes cursor = 1;
+	 */
+	cursor?: Uint8Array;
+	/**
+	 * The inclusive boundary checkpoint that the scan has fully covered within
+	 * the request's effective interval, in the request's ordering direction: an
+	 * ascending scan has emitted every matching item in the interval at
+	 * checkpoints `<= checkpoint` (strictly greater ones may still hold
+	 * matches); a descending scan has emitted every matching item in the
+	 * interval at checkpoints `>= checkpoint`. This boundary never regresses in
+	 * the scan direction, but it may repeat while the cursor advances.
+	 *
+	 * Unset until the scan's first checkpoint is fully covered. For example, a
+	 * scan resumed from a cursor that lands mid-checkpoint leaves this unset
+	 * until the next checkpoint boundary in the scan direction is fully covered.
+	 * A watermark still has a valid resume cursor while this field is unset.
+	 *
+	 * @generated from protobuf field: optional uint64 checkpoint = 2;
+	 */
+	checkpoint?: bigint;
+}
+/**
+ * Marker for the final frame of a successful query stream. Every successful
+ * stream sets `QueryEnd` on exactly one frame, after which no further frames
+ * are sent. That frame always carries the final watermark. For `ItemLimit`, it
+ * also carries the final matching item; for every other reason it carries no
+ * item. A ScanLimit terminal watermark may repeat the previous frame's cursor
+ * when its authoritative scan frontier was already emitted; this does not
+ * repeat an item.
+ *
+ * A stream that fails or is cancelled terminates with a gRPC status and does
+ * not send `QueryEnd`.
+ *
+ * @generated from protobuf message sui.rpc.v2.QueryEnd
+ */
+export interface QueryEnd {
+	/**
+	 * Reason this response stopped.
+	 *
+	 * @generated from protobuf field: optional sui.rpc.v2.QueryEndReason reason = 1;
+	 */
+	reason?: QueryEndReason;
+}
+/**
+ * Ordering for the returned result set.
+ *
+ * @generated from protobuf enum sui.rpc.v2.Ordering
+ */
+export enum Ordering {
+	/**
+	 * Return results in increasing cursor order.
+	 *
+	 * @generated from protobuf enum value: ORDERING_ASCENDING = 0;
+	 */
+	ASCENDING = 0,
+	/**
+	 * Return results in decreasing cursor order.
+	 *
+	 * @generated from protobuf enum value: ORDERING_DESCENDING = 1;
+	 */
+	DESCENDING = 1,
+}
+/**
+ * Reason the server stopped this query response.
+ *
+ * @generated from protobuf enum sui.rpc.v2.QueryEndReason
+ */
+export enum QueryEndReason {
+	/**
+	 * The stop reason was not specified.
+	 *
+	 * @generated from protobuf enum value: QUERY_END_REASON_UNKNOWN = 0;
+	 */
+	UNKNOWN = 0,
+	/**
+	 * The response reached the requested item limit. The final matching item's
+	 * frame carries `QueryEnd` and the final watermark. Resume from that frame's
+	 * `Watermark.cursor` to continue reading the same effective interval.
+	 *
+	 * @generated from protobuf enum value: QUERY_END_REASON_ITEM_LIMIT = 1;
+	 */
+	ITEM_LIMIT = 1,
+	/**
+	 * The response reached the server's per-request bucket-fetch budget for
+	 * filtered scans before reaching the effective interval bound. The terminal
+	 * frame carries no item. Its watermark cursor is the authoritative scan
+	 * frontier from which to resume.
+	 *
+	 * @generated from protobuf enum value: QUERY_END_REASON_SCAN_LIMIT = 2;
+	 */
+	SCAN_LIMIT = 2,
+	/**
+	 * The scan reached a requested checkpoint range bound. The terminal frame
+	 * carries no item.
+	 *
+	 * @generated from protobuf enum value: QUERY_END_REASON_CHECKPOINT_BOUND = 3;
+	 */
+	CHECKPOINT_BOUND = 3,
+	/**
+	 * The scan reached an exclusive cursor bound. The terminal frame carries no
+	 * item. Its watermark cursor represents that resolved bound without claiming
+	 * that its containing checkpoint was fully covered.
+	 *
+	 * @generated from protobuf enum value: QUERY_END_REASON_CURSOR_BOUND = 4;
+	 */
+	CURSOR_BOUND = 4,
+	/**
+	 * The scan reached the currently indexed ledger tip. The terminal frame
+	 * carries no item.
+	 *
+	 * @generated from protobuf enum value: QUERY_END_REASON_LEDGER_TIP = 5;
+	 */
+	LEDGER_TIP = 5,
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class QueryOptions$Type extends MessageType<QueryOptions> {
+	constructor() {
+		super('sui.rpc.v2.QueryOptions', [
+			{ no: 1, name: 'limit', kind: 'scalar', opt: true, T: 13 /*ScalarType.UINT32*/ },
+			{ no: 2, name: 'after', kind: 'scalar', opt: true, T: 12 /*ScalarType.BYTES*/ },
+			{ no: 3, name: 'before', kind: 'scalar', opt: true, T: 12 /*ScalarType.BYTES*/ },
+			{
+				no: 4,
+				name: 'ordering',
+				kind: 'enum',
+				opt: true,
+				T: () => ['sui.rpc.v2.Ordering', Ordering, 'ORDERING_'],
+			},
+		]);
+	}
+}
+/**
+ * @generated MessageType for protobuf message sui.rpc.v2.QueryOptions
+ */
+export const QueryOptions = new QueryOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Watermark$Type extends MessageType<Watermark> {
+	constructor() {
+		super('sui.rpc.v2.Watermark', [
+			{ no: 1, name: 'cursor', kind: 'scalar', opt: true, T: 12 /*ScalarType.BYTES*/ },
+			{
+				no: 2,
+				name: 'checkpoint',
+				kind: 'scalar',
+				opt: true,
+				T: 4 /*ScalarType.UINT64*/,
+				L: 0 /*LongType.BIGINT*/,
+			},
+		]);
+	}
+}
+/**
+ * @generated MessageType for protobuf message sui.rpc.v2.Watermark
+ */
+export const Watermark = new Watermark$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class QueryEnd$Type extends MessageType<QueryEnd> {
+	constructor() {
+		super('sui.rpc.v2.QueryEnd', [
+			{
+				no: 1,
+				name: 'reason',
+				kind: 'enum',
+				opt: true,
+				T: () => ['sui.rpc.v2.QueryEndReason', QueryEndReason, 'QUERY_END_REASON_'],
+			},
+		]);
+	}
+}
+/**
+ * @generated MessageType for protobuf message sui.rpc.v2.QueryEnd
+ */
+export const QueryEnd = new QueryEnd$Type();

package/src/grpc/proto/sui/rpc/v2/subscription_service.client.ts

@@ -12,27 +12,54 @@
 import type { RpcTransport } from '@protobuf-ts/runtime-rpc';
 import type { ServiceInfo } from '@protobuf-ts/runtime-rpc';
 import { SubscriptionService } from './subscription_service.js';
+import type { SubscribeEventsResponse } from './subscription_service.js';
+import type { SubscribeEventsRequest } from './subscription_service.js';
+import type { SubscribeTransactionsResponse } from './subscription_service.js';
+import type { SubscribeTransactionsRequest } from './subscription_service.js';
 import { stackIntercept } from '@protobuf-ts/runtime-rpc';
 import type { SubscribeCheckpointsResponse } from './subscription_service.js';
 import type { SubscribeCheckpointsRequest } from './subscription_service.js';
 import type { ServerStreamingCall } from '@protobuf-ts/runtime-rpc';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 /**
+ * SubscriptionService provides filtered, real-time streams of checkpoints,
+ * transactions, and events.
+ *
+ * Each Subscribe API pairs with the LedgerService List API of the same name:
+ * requests take the same filter message, and responses carry the same item
+ * and watermark shapes with identical cursor semantics.
+ *
+ * Subscriptions do not support resumption. A new subscription always begins
+ * at the current tip of the chain as seen by the server (the latest executed
+ * checkpoint). To recover data missed between subscriptions, replay the gap
+ * with the paired List API: pass the last received `Watermark.cursor` as
+ * `options.after` on the List request (for checkpoints, pass the last
+ * received `cursor + 1` as `start_checkpoint`). The List scan reads from the
+ * indexed tip, which may trail the subscription's start position; repeat the
+ * List call as the index advances until the replay reaches the position
+ * established by the subscription's first frame.
+ *
+ * A subscription behaves like an unbounded ascending scan: every frame
+ * carries the subscriber's resume point, and progress advances as
+ * checkpoints are fully covered. Two delivery guarantees keep sparse
+ * filters live: the first frame on a filtered subscription is a
+ * progress-only frame establishing the stream's start position, and
+ * progress continues to advance with bounded staleness even when no item
+ * matches.
+ *
+ * Subscription streams have no successful end: they run until cancelled by
+ * the client or terminated by the server with a gRPC status.
+ *
  * @generated from protobuf service sui.rpc.v2.SubscriptionService
  */
 export interface ISubscriptionServiceClient {
 	/**
 	 * Subscribe to the stream of checkpoints.
 	 *
-	 * This API provides a subscription to the checkpoint stream for the Sui
-	 * blockchain. When a subscription is initialized the stream will begin with
-	 * the latest executed checkpoint as seen by the server. Responses are
-	 * guaranteed to return checkpoints in-order and without gaps. This enables
-	 * clients to know exactly the last checkpoint they have processed and in the
-	 * event the subscription terminates (either by the client/server or by the
-	 * connection breaking), clients will be able to reinitialize a subscription
-	 * and then leverage other APIs in order to request data for the checkpoints
-	 * they missed.
+	 * The stream begins at the latest executed checkpoint as seen by the
+	 * server and yields checkpoints matching the filter as they are executed.
+	 * A checkpoint matches if any transaction it contains satisfies the
+	 * filter.
 	 *
 	 * @generated from protobuf rpc: SubscribeCheckpoints(sui.rpc.v2.SubscribeCheckpointsRequest) returns (stream sui.rpc.v2.SubscribeCheckpointsResponse);
 	 */
@@ -40,8 +67,60 @@ export interface ISubscriptionServiceClient {
 		input: SubscribeCheckpointsRequest,
 		options?: RpcOptions,
 	): ServerStreamingCall<SubscribeCheckpointsRequest, SubscribeCheckpointsResponse>;
+	/**
+	 * Subscribe to the stream of transactions.
+	 *
+	 * The stream begins at the latest executed checkpoint as seen by the
+	 * server and yields transactions matching the filter as they are executed.
+	 *
+	 * @generated from protobuf rpc: SubscribeTransactions(sui.rpc.v2.SubscribeTransactionsRequest) returns (stream sui.rpc.v2.SubscribeTransactionsResponse);
+	 */
+	subscribeTransactions(
+		input: SubscribeTransactionsRequest,
+		options?: RpcOptions,
+	): ServerStreamingCall<SubscribeTransactionsRequest, SubscribeTransactionsResponse>;
+	/**
+	 * Subscribe to the stream of events.
+	 *
+	 * The stream begins at the latest executed checkpoint as seen by the
+	 * server and yields events matching the filter as they are emitted.
+	 *
+	 * @generated from protobuf rpc: SubscribeEvents(sui.rpc.v2.SubscribeEventsRequest) returns (stream sui.rpc.v2.SubscribeEventsResponse);
+	 */
+	subscribeEvents(
+		input: SubscribeEventsRequest,
+		options?: RpcOptions,
+	): ServerStreamingCall<SubscribeEventsRequest, SubscribeEventsResponse>;
 }
 /**
+ * SubscriptionService provides filtered, real-time streams of checkpoints,
+ * transactions, and events.
+ *
+ * Each Subscribe API pairs with the LedgerService List API of the same name:
+ * requests take the same filter message, and responses carry the same item
+ * and watermark shapes with identical cursor semantics.
+ *
+ * Subscriptions do not support resumption. A new subscription always begins
+ * at the current tip of the chain as seen by the server (the latest executed
+ * checkpoint). To recover data missed between subscriptions, replay the gap
+ * with the paired List API: pass the last received `Watermark.cursor` as
+ * `options.after` on the List request (for checkpoints, pass the last
+ * received `cursor + 1` as `start_checkpoint`). The List scan reads from the
+ * indexed tip, which may trail the subscription's start position; repeat the
+ * List call as the index advances until the replay reaches the position
+ * established by the subscription's first frame.
+ *
+ * A subscription behaves like an unbounded ascending scan: every frame
+ * carries the subscriber's resume point, and progress advances as
+ * checkpoints are fully covered. Two delivery guarantees keep sparse
+ * filters live: the first frame on a filtered subscription is a
+ * progress-only frame establishing the stream's start position, and
+ * progress continues to advance with bounded staleness even when no item
+ * matches.
+ *
+ * Subscription streams have no successful end: they run until cancelled by
+ * the client or terminated by the server with a gRPC status.
+ *
  * @generated from protobuf service sui.rpc.v2.SubscriptionService
  */
 export class SubscriptionServiceClient implements ISubscriptionServiceClient, ServiceInfo {
@@ -52,15 +131,10 @@ export class SubscriptionServiceClient implements ISubscriptionServiceClient, Se
 	/**
 	 * Subscribe to the stream of checkpoints.
 	 *
-	 * This API provides a subscription to the checkpoint stream for the Sui
-	 * blockchain. When a subscription is initialized the stream will begin with
-	 * the latest executed checkpoint as seen by the server. Responses are
-	 * guaranteed to return checkpoints in-order and without gaps. This enables
-	 * clients to know exactly the last checkpoint they have processed and in the
-	 * event the subscription terminates (either by the client/server or by the
-	 * connection breaking), clients will be able to reinitialize a subscription
-	 * and then leverage other APIs in order to request data for the checkpoints
-	 * they missed.
+	 * The stream begins at the latest executed checkpoint as seen by the
+	 * server and yields checkpoints matching the filter as they are executed.
+	 * A checkpoint matches if any transaction it contains satisfies the
+	 * filter.
 	 *
 	 * @generated from protobuf rpc: SubscribeCheckpoints(sui.rpc.v2.SubscribeCheckpointsRequest) returns (stream sui.rpc.v2.SubscribeCheckpointsResponse);
 	 */
@@ -78,4 +152,48 @@ export class SubscriptionServiceClient implements ISubscriptionServiceClient, Se
 			input,
 		);
 	}
+	/**
+	 * Subscribe to the stream of transactions.
+	 *
+	 * The stream begins at the latest executed checkpoint as seen by the
+	 * server and yields transactions matching the filter as they are executed.
+	 *
+	 * @generated from protobuf rpc: SubscribeTransactions(sui.rpc.v2.SubscribeTransactionsRequest) returns (stream sui.rpc.v2.SubscribeTransactionsResponse);
+	 */
+	subscribeTransactions(
+		input: SubscribeTransactionsRequest,
+		options?: RpcOptions,
+	): ServerStreamingCall<SubscribeTransactionsRequest, SubscribeTransactionsResponse> {
+		const method = this.methods[1],
+			opt = this._transport.mergeOptions(options);
+		return stackIntercept<SubscribeTransactionsRequest, SubscribeTransactionsResponse>(
+			'serverStreaming',
+			this._transport,
+			method,
+			opt,
+			input,
+		);
+	}
+	/**
+	 * Subscribe to the stream of events.
+	 *
+	 * The stream begins at the latest executed checkpoint as seen by the
+	 * server and yields events matching the filter as they are emitted.
+	 *
+	 * @generated from protobuf rpc: SubscribeEvents(sui.rpc.v2.SubscribeEventsRequest) returns (stream sui.rpc.v2.SubscribeEventsResponse);
+	 */
+	subscribeEvents(
+		input: SubscribeEventsRequest,
+		options?: RpcOptions,
+	): ServerStreamingCall<SubscribeEventsRequest, SubscribeEventsResponse> {
+		const method = this.methods[2],
+			opt = this._transport.mergeOptions(options);
+		return stackIntercept<SubscribeEventsRequest, SubscribeEventsResponse>(
+			'serverStreaming',
+			this._transport,
+			method,
+			opt,
+			input,
+		);
+	}
 }

package/src/grpc/proto/sui/rpc/v2/subscription_service.ts

@@ -11,47 +11,161 @@
 //
 import { ServiceType } from '@protobuf-ts/runtime-rpc';
 import { MessageType } from '@protobuf-ts/runtime';
+import { Event } from './event.js';
+import { EventFilter } from './filter.js';
+import { Watermark } from './query_options.js';
+import { ExecutedTransaction } from './executed_transaction.js';
 import { Checkpoint } from './checkpoint.js';
+import { TransactionFilter } from './filter.js';
 import { FieldMask } from '../../../google/protobuf/field_mask.js';
 /**
- * Request message for SubscriptionService.SubscribeCheckpoints
+ * Request message for SubscriptionService.SubscribeCheckpoints.
  *
  * @generated from protobuf message sui.rpc.v2.SubscribeCheckpointsRequest
  */
 export interface SubscribeCheckpointsRequest {
 	/**
-	 * Optional. Mask for specifying which parts of the
-	 * SubscribeCheckpointsResponse should be returned.
+	 * Optional. Mask for specifying which parts of the Checkpoint should be
+	 * returned (e.g. summary, contents, signatures). `cursor` is always
+	 * populated and is not subject to the mask.
 	 *
 	 * @generated from protobuf field: optional google.protobuf.FieldMask read_mask = 1;
 	 */
 	readMask?: FieldMask;
+	/**
+	 * Optional. DNF filter over indexed transaction dimensions. A checkpoint
+	 * matches if any transaction it contains satisfies the filter. If absent,
+	 * every checkpoint is streamed.
+	 *
+	 * @generated from protobuf field: optional sui.rpc.v2.TransactionFilter filter = 2;
+	 */
+	filter?: TransactionFilter;
 }
 /**
- * Response message for SubscriptionService.SubscribeCheckpoints
+ * Response message for SubscriptionService.SubscribeCheckpoints.
+ *
+ * A checkpoint stream's position is checkpoint-granular, so the `cursor`
+ * sequence number stands in for the `Watermark` message the other
+ * subscription responses carry. Progress-only frames (with `checkpoint`
+ * unset) occur only on filtered streams: on an unfiltered stream every frame
+ * carries both fields, in order and without gaps.
  *
  * @generated from protobuf message sui.rpc.v2.SubscribeCheckpointsResponse
  */
 export interface SubscribeCheckpointsResponse {
 	/**
-	 * Required. The checkpoint sequence number and value of the current cursor
-	 * into the checkpoint stream
+	 * Required. The checkpoint sequence number the stream has fully covered,
+	 * inclusive: every matching checkpoint from the stream's start position
+	 * through `cursor` has been delivered. Present on every frame and
+	 * advances monotonically.
 	 *
 	 * @generated from protobuf field: optional uint64 cursor = 1;
 	 */
 	cursor?: bigint;
 	/**
-	 * The requested data for this checkpoint
+	 * The matching checkpoint. Unset when this frame only advances the
+	 * cursor past non-matching checkpoints.
 	 *
 	 * @generated from protobuf field: optional sui.rpc.v2.Checkpoint checkpoint = 2;
 	 */
 	checkpoint?: Checkpoint;
 }
+/**
+ * Request message for SubscriptionService.SubscribeTransactions.
+ *
+ * @generated from protobuf message sui.rpc.v2.SubscribeTransactionsRequest
+ */
+export interface SubscribeTransactionsRequest {
+	/**
+	 * Optional. Mask for specifying which parts of the ExecutedTransaction
+	 * should be returned.
+	 *
+	 * @generated from protobuf field: optional google.protobuf.FieldMask read_mask = 1;
+	 */
+	readMask?: FieldMask;
+	/**
+	 * Optional. DNF filter over indexed dimensions. If absent, every
+	 * transaction is streamed.
+	 *
+	 * @generated from protobuf field: optional sui.rpc.v2.TransactionFilter filter = 2;
+	 */
+	filter?: TransactionFilter;
+}
+/**
+ * Response message for SubscriptionService.SubscribeTransactions.
+ *
+ * Mirrors ListTransactionsResponse, except there is no `end` field: a
+ * subscription stream has no successful end.
+ *
+ * @generated from protobuf message sui.rpc.v2.SubscribeTransactionsResponse
+ */
+export interface SubscribeTransactionsResponse {
+	/**
+	 * One matching transaction. Its position within the containing checkpoint
+	 * is reported by `ExecutedTransaction.transaction_index`.
+	 *
+	 * @generated from protobuf field: optional sui.rpc.v2.ExecutedTransaction transaction = 1;
+	 */
+	transaction?: ExecutedTransaction;
+	/**
+	 * Progress watermark as of this frame. Present on every frame.
+	 *
+	 * @generated from protobuf field: optional sui.rpc.v2.Watermark watermark = 2;
+	 */
+	watermark?: Watermark;
+}
+/**
+ * Request message for SubscriptionService.SubscribeEvents.
+ *
+ * @generated from protobuf message sui.rpc.v2.SubscribeEventsRequest
+ */
+export interface SubscribeEventsRequest {
+	/**
+	 * Optional. Mask for specifying which parts of the Event should be
+	 * returned.
+	 *
+	 * @generated from protobuf field: optional google.protobuf.FieldMask read_mask = 1;
+	 */
+	readMask?: FieldMask;
+	/**
+	 * Optional. DNF filter over indexed dimensions. If absent, every event is
+	 * streamed.
+	 *
+	 * @generated from protobuf field: optional sui.rpc.v2.EventFilter filter = 2;
+	 */
+	filter?: EventFilter;
+}
+/**
+ * Response message for SubscriptionService.SubscribeEvents.
+ *
+ * Mirrors ListEventsResponse, except there is no `end` field: a subscription
+ * stream has no successful end.
+ *
+ * @generated from protobuf message sui.rpc.v2.SubscribeEventsResponse
+ */
+export interface SubscribeEventsResponse {
+	/**
+	 * One matching event. Its ledger position -- containing checkpoint,
+	 * emitting transaction digest and offset, and index within that
+	 * transaction's event list -- is reported by the corresponding fields on
+	 * `Event`.
+	 *
+	 * @generated from protobuf field: optional sui.rpc.v2.Event event = 1;
+	 */
+	event?: Event;
+	/**
+	 * Progress watermark as of this frame. Present on every frame.
+	 *
+	 * @generated from protobuf field: optional sui.rpc.v2.Watermark watermark = 2;
+	 */
+	watermark?: Watermark;
+}
 // @generated message type with reflection information, may provide speed optimized methods
 class SubscribeCheckpointsRequest$Type extends MessageType<SubscribeCheckpointsRequest> {
 	constructor() {
 		super('sui.rpc.v2.SubscribeCheckpointsRequest', [
 			{ no: 1, name: 'read_mask', kind: 'message', T: () => FieldMask },
+			{ no: 2, name: 'filter', kind: 'message', T: () => TransactionFilter },
 		]);
 	}
 }
@@ -79,6 +193,58 @@ class SubscribeCheckpointsResponse$Type extends MessageType<SubscribeCheckpoints
  * @generated MessageType for protobuf message sui.rpc.v2.SubscribeCheckpointsResponse
  */
 export const SubscribeCheckpointsResponse = new SubscribeCheckpointsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SubscribeTransactionsRequest$Type extends MessageType<SubscribeTransactionsRequest> {
+	constructor() {
+		super('sui.rpc.v2.SubscribeTransactionsRequest', [
+			{ no: 1, name: 'read_mask', kind: 'message', T: () => FieldMask },
+			{ no: 2, name: 'filter', kind: 'message', T: () => TransactionFilter },
+		]);
+	}
+}
+/**
+ * @generated MessageType for protobuf message sui.rpc.v2.SubscribeTransactionsRequest
+ */
+export const SubscribeTransactionsRequest = new SubscribeTransactionsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SubscribeTransactionsResponse$Type extends MessageType<SubscribeTransactionsResponse> {
+	constructor() {
+		super('sui.rpc.v2.SubscribeTransactionsResponse', [
+			{ no: 1, name: 'transaction', kind: 'message', T: () => ExecutedTransaction },
+			{ no: 2, name: 'watermark', kind: 'message', T: () => Watermark },
+		]);
+	}
+}
+/**
+ * @generated MessageType for protobuf message sui.rpc.v2.SubscribeTransactionsResponse
+ */
+export const SubscribeTransactionsResponse = new SubscribeTransactionsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SubscribeEventsRequest$Type extends MessageType<SubscribeEventsRequest> {
+	constructor() {
+		super('sui.rpc.v2.SubscribeEventsRequest', [
+			{ no: 1, name: 'read_mask', kind: 'message', T: () => FieldMask },
+			{ no: 2, name: 'filter', kind: 'message', T: () => EventFilter },
+		]);
+	}
+}
+/**
+ * @generated MessageType for protobuf message sui.rpc.v2.SubscribeEventsRequest
+ */
+export const SubscribeEventsRequest = new SubscribeEventsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SubscribeEventsResponse$Type extends MessageType<SubscribeEventsResponse> {
+	constructor() {
+		super('sui.rpc.v2.SubscribeEventsResponse', [
+			{ no: 1, name: 'event', kind: 'message', T: () => Event },
+			{ no: 2, name: 'watermark', kind: 'message', T: () => Watermark },
+		]);
+	}
+}
+/**
+ * @generated MessageType for protobuf message sui.rpc.v2.SubscribeEventsResponse
+ */
+export const SubscribeEventsResponse = new SubscribeEventsResponse$Type();
 /**
  * @generated ServiceType for protobuf service sui.rpc.v2.SubscriptionService
  */
@@ -90,4 +256,18 @@ export const SubscriptionService = new ServiceType('sui.rpc.v2.SubscriptionServi
 		I: SubscribeCheckpointsRequest,
 		O: SubscribeCheckpointsResponse,
 	},
+	{
+		name: 'SubscribeTransactions',
+		serverStreaming: true,
+		options: {},
+		I: SubscribeTransactionsRequest,
+		O: SubscribeTransactionsResponse,
+	},
+	{
+		name: 'SubscribeEvents',
+		serverStreaming: true,
+		options: {},
+		I: SubscribeEventsRequest,
+		O: SubscribeEventsResponse,
+	},
 ]);