@mysten/sui 2.22.0 → 2.23.1

package/docs/migrations/sui-2.0/json-rpc-migration.md

@@ -5,15 +5,16 @@
 This guide covers migrating from `SuiJsonRpcClient` to the new client APIs. The JSON-RPC API is
 being deprecated in favor of `SuiGrpcClient` and `SuiGraphQLClient`.
 
-> **Note:** We recommend using `SuiGrpcClient` for most operations and `SuiGraphQLClient` for complex queries
-> like filtering transactions and events.
+> **Note:** Use `SuiGrpcClient` for most operations, including filtering transactions and events with the core
+> query API. `SuiGraphQLClient` remains useful for complex queries that aren't covered by the core
+> API.
 
 ## Choosing a client
 
-| Client             | Best For                                                        |
-| ------------------ | --------------------------------------------------------------- |
-| `SuiGrpcClient`    | Most operations, SDK integrations, real-time data               |
-| `SuiGraphQLClient` | Complex queries, filtering transactions/events, historical data |
+| Client             | Best For                                                             |
+| ------------------ | -------------------------------------------------------------------- |
+| `SuiGrpcClient`    | Most operations, SDK integrations, queries, real-time data           |
+| `SuiGraphQLClient` | Complex queries not covered by the core API, like historical objects |
 
 ## Quick migration to gRPC
 
@@ -58,6 +59,58 @@ These JSON-RPC methods have direct replacements in the core API:
 | `dryRunTransactionBlock`     | `simulateTransaction`                             |
 | `getNormalizedMoveFunction`  | `getMoveFunction`                                 |
 | `getMoveFunctionArgTypes`    | `getMoveFunction`                                 |
+| `queryTransactionBlocks`     | `listTransactions`                                |
+| `queryEvents`                | `listEvents`                                      |
+
+> **Note:** The query methods (`listTransactions` and `listEvents`) behave identically on every client,
+> including `SuiJsonRpcClient`. See [Core API query methods](/sui/clients/core#query-methods) for
+> details.
+
+### Example: Migrating queryTransactionBlocks
+
+```diff
+- const result = await jsonRpcClient.queryTransactionBlocks({
+-   filter: { FromAddress: '0xabc...' },
+-   options: { showEffects: true },
+-   limit: 10,
+- });
+- const digests = result.data.map((tx) => tx.digest);
++ const result = await client.core.listTransactions({
++   filter: { sender: '0xabc...' },
++   include: { effects: true },
++   limit: 10,
++ });
++ const digests = result.transactions.map(
++   (tx) => (tx.Transaction ?? tx.FailedTransaction).digest,
++ );
+```
+
+The core API filters map to the JSON-RPC `TransactionFilter` variants:
+
+| JSON-RPC filter                                                      | Core API filter predicate                                                                                       |
+| -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `FromAddress`                                                        | `sender`                                                                                                        |
+| `MoveFunction`                                                       | `function`                                                                                                      |
+| `ToAddress` / `FromOrToAddress` / `ChangedObject` / `AffectedObject` | No core equivalent. Use raw [gRPC](/sui/clients/grpc#ledger-service) or [GraphQL](/sui/clients/graphql) queries |
+
+### Example: Migrating queryEvents
+
+```diff
+- const result = await jsonRpcClient.queryEvents({
+-   query: { MoveEventType: '0x2::coin::CoinCreated' },
+-   limit: 10,
+-   order: 'descending',
+- });
++ const result = await client.core.listEvents({
++   filter: { eventType: '0x2::coin::CoinCreated' },
++   limit: 10,
++   order: 'descending',
++ });
+```
+
+The JSON-RPC `EventFilter` variants map to `sender`, `emitModule` (replaces `MoveModule` /
+`MoveEventModule`), and `eventType` (replaces `MoveEventType`). Each returned event includes its
+ledger position (`checkpoint`, `transactionDigest`, and `eventIndex`).
 
 ### Example: Migrating devInspectTransactionBlock
 
@@ -95,6 +148,7 @@ These JSON-RPC methods can be replaced by calling gRPC service clients directly:
 | JSON-RPC Method                     | gRPC Service Replacement                                         |
 | ----------------------------------- | ---------------------------------------------------------------- |
 | `getCheckpoint`                     | `ledgerService.getCheckpoint`                                    |
+| `getCheckpoints`                    | `ledgerService.listCheckpoints`                                  |
 | `getLatestCheckpointSequenceNumber` | `ledgerService.getServiceInfo` (read `checkpointHeight`)         |
 | `getCurrentEpoch`                   | `ledgerService.getEpoch` (omit `epoch` for the current)          |
 | `getLatestSuiSystemState`           | `ledgerService.getEpoch` with `system_state` in the read mask    |
@@ -108,10 +162,10 @@ These JSON-RPC methods can be replaced by calling gRPC service clients directly:
 | `resolveNameServiceAddress`         | `nameService.lookupName`                                         |
 | `resolveNameServiceNames`           | `nameService.reverseLookupName`                                  |
 
-> **Warning:** `getCheckpoints` and `getEpochs` (paginated listings) have no gRPC equivalent — use the
-> `checkpoints` / `epochs` GraphQL queries instead. `getValidatorsApy` also has no replacement:
-> there is no canonical definition of validator APY, so it must be computed client-side from
-> validator exchange rates (see [Validator APY](#validator-apy) below).
+> **Warning:** `getEpochs` (paginated listing) has no gRPC equivalent. Use the `epochs` GraphQL query instead.
+> `getValidatorsApy` also has no replacement: there is no canonical definition of validator APY, so
+> it must be computed client-side from validator exchange rates (see [Validator APY](#validator-apy)
+> below).
 
 ### Example: using gRPC service clients
 
@@ -167,16 +221,53 @@ const { response: address } = await client.nameService.lookupName({
 });
 ```
 
+## Methods replaced by gRPC subscriptions
+
+Replace the deprecated JSON-RPC websocket subscriptions with the gRPC `subscriptionService`, which
+provides filtered, real-time streams:
+
+| JSON-RPC Method        | gRPC Service Replacement                    |
+| ---------------------- | ------------------------------------------- |
+| `subscribeTransaction` | `subscriptionService.subscribeTransactions` |
+| `subscribeEvent`       | `subscriptionService.subscribeEvents`       |
+
+```typescript
+const stream = client.subscriptionService.subscribeEvents({
+	filter: {
+		terms: [
+			{
+				literals: [
+					{
+						negated: false,
+						predicate: {
+							oneofKind: 'eventType',
+							eventType: { eventType: '0x2::coin::CoinCreated' },
+						},
+					},
+				],
+			},
+		],
+	},
+	readMask: { paths: ['event_type', 'contents', 'json', 'checkpoint', 'transaction_digest'] },
+});
+
+for await (const frame of stream.responses) {
+	if (frame.event) {
+		console.log(frame.event.eventType, frame.event.json);
+	}
+}
+```
+
+Subscriptions always begin at the current tip of the chain. To recover events you missed between
+subscriptions, replay the gap with `client.core.listEvents` using the same filter.
+
 ## Methods requiring GraphQL
 
 Some JSON-RPC methods don't have gRPC equivalents and require using `SuiGraphQLClient` instead:
 
 | JSON-RPC Method             | GraphQL Alternative                                       |
 | --------------------------- | --------------------------------------------------------- |
-| `queryTransactionBlocks`    | `transactions` query                                      |
 | `multiGetTransactionBlocks` | `multiGetTransactionEffects` query                        |
-| `queryEvents`               | `events` query                                            |
-| `getCheckpoints`            | `checkpoints` query                                       |
 | `getEpochs`                 | `epochs` query                                            |
 | `getCoinMetadata`           | `coinMetadata` query (or gRPC `stateService.getCoinInfo`) |
 | `getTotalSupply`            | `coinMetadata` query (or gRPC `stateService.getCoinInfo`) |
@@ -197,94 +288,6 @@ const graphqlClient = new SuiGraphQLClient({
 });
 ```
 
-### Querying transactions
-
-Replace `queryTransactionBlocks` with a GraphQL query:
-
-```typescript
-const result = await graphqlClient.query({
-	query: `
-    query QueryTransactions($sender: SuiAddress, $first: Int, $after: String) {
-      transactions(
-        first: $first
-        after: $after
-        filter: { sentAddress: $sender }
-      ) {
-        pageInfo {
-          hasNextPage
-          endCursor
-        }
-        nodes {
-          digest
-          effects {
-            status
-            epoch { epochId }
-          }
-        }
-      }
-    }
-  `,
-	variables: {
-		sender: '0xabc...',
-		first: 10,
-	},
-});
-```
-
-**Available transaction filters:**
-
-- `sentAddress`: Filter by sender address
-- `affectedAddress`: Filter by any address involved in the transaction
-- `affectedObject`: Filter by object ID that was affected
-- `function`: Filter by Move function called (for example, `0x2::coin::transfer`)
-- `kind`: Filter by transaction kind (`SYSTEM` or `PROGRAMMABLE`)
-- `atCheckpoint` / `beforeCheckpoint` / `afterCheckpoint` - Filter by checkpoint
-
-### Querying events
-
-Replace `queryEvents` with a GraphQL query:
-
-```typescript
-const result = await graphqlClient.query({
-	query: `
-    query QueryEvents($type: String, $first: Int, $after: String) {
-      events(
-        first: $first
-        after: $after
-        filter: { type: $type }
-      ) {
-        pageInfo {
-          hasNextPage
-          endCursor
-        }
-        nodes {
-          transactionModule {
-            package { address }
-            name
-          }
-          sender { address }
-          contents {
-            type { repr }
-            bcs
-          }
-        }
-      }
-    }
-  `,
-	variables: {
-		type: '0x2::coin::CoinCreated',
-		first: 10,
-	},
-});
-```
-
-**Available event filters:**
-
-- `type`: Filter by event type (package, package::module, or full type)
-- `module`: Filter by emitting module
-- `sender`: Filter by transaction sender
-- `atCheckpoint` / `beforeCheckpoint` / `afterCheckpoint`: Filter by checkpoint
-
 ### Fetching multiple transactions
 
 Replace `multiGetTransactionBlocks` with a GraphQL query:

package/package.json

@@ -3,7 +3,7 @@
   "author": "Mysten Labs <build@mystenlabs.com>",
   "description": "Sui TypeScript API",
   "homepage": "https://sdk.mystenlabs.com",
-  "version": "2.22.0",
+  "version": "2.23.1",
   "license": "Apache-2.0",
   "sideEffects": false,
   "files": [
@@ -167,7 +167,7 @@
     "gql.tada": "^1.10.1",
     "graphql": "^16.14.2",
     "poseidon-lite": "0.2.1",
-    "valibot": "^1.4.1",
+    "valibot": "^1.4.2",
     "@mysten/bcs": "^2.1.0",
     "@mysten/utils": "^0.4.0"
   },

package/src/bcs/bcs.ts

@@ -228,13 +228,6 @@ export const ProgrammableTransaction = bcs.struct('ProgrammableTransaction', {
 	commands: bcs.vector(Command),
 });
 
-export const TransactionKind = bcs.enum('TransactionKind', {
-	ProgrammableTransaction: ProgrammableTransaction,
-	ChangeEpoch: null,
-	Genesis: null,
-	ConsensusCommitPrologue: null,
-});
-
 // Rust: crates/sui-types/src/transaction.rs
 export const ValidDuring = bcs.struct('ValidDuring', {
 	minEpoch: bcs.option(bcs.u64()),
@@ -265,17 +258,6 @@ export const GasData = bcs.struct('GasData', {
 	budget: bcs.u64(),
 });
 
-export const TransactionDataV1 = bcs.struct('TransactionDataV1', {
-	kind: TransactionKind,
-	sender: Address,
-	gasData: GasData,
-	expiration: TransactionExpiration,
-});
-
-export const TransactionData = bcs.enum('TransactionData', {
-	V1: TransactionDataV1,
-});
-
 export const IntentScope = bcs.enum('IntentScope', {
 	TransactionData: null,
 	TransactionEffects: null,
@@ -341,15 +323,6 @@ export const base64String = bcs.byteVector().transform({
 	output: (val) => toBase64(new Uint8Array(val)),
 });
 
-export const SenderSignedTransaction = bcs.struct('SenderSignedTransaction', {
-	intentMessage: IntentMessage(TransactionData),
-	txSignatures: bcs.vector(base64String),
-});
-
-export const SenderSignedData = bcs.vector(SenderSignedTransaction, {
-	name: 'SenderSignedData',
-});
-
 export const PasskeyAuthenticator = bcs.struct('PasskeyAuthenticator', {
 	authenticatorData: bcs.byteVector(),
 	clientDataJson: bcs.string(),

package/src/bcs/index.ts

@@ -30,19 +30,21 @@ import {
 	ProgrammableMoveCall,
 	ProgrammableTransaction,
 	PublicKey,
-	SenderSignedData,
-	SenderSignedTransaction,
 	SharedObjectRef,
 	StructTag,
 	SuiObjectRef,
-	TransactionData,
-	TransactionDataV1,
 	TransactionExpiration,
-	TransactionKind,
 	TypeOrigin,
 	TypeTag,
 	UpgradeInfo,
 } from './bcs.js';
+import {
+	SenderSignedData,
+	SenderSignedTransaction,
+	TransactionData,
+	TransactionDataV1,
+	TransactionKind,
+} from './transactions.js';
 import { TransactionEffects } from './effects.js';
 
 export type { TypeTag } from './types.js';

package/src/bcs/transactions.ts

@@ -0,0 +1,226 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@mysten/bcs';
+
+import {
+	Address,
+	base64String,
+	Data,
+	GasData,
+	IntentMessage,
+	ObjectDigest,
+	Owner,
+	ProgrammableTransaction,
+	TransactionExpiration,
+	TypeTag,
+} from './bcs.js';
+
+// Rust: crates/sui-types/src/transaction.rs
+export const ChangeEpoch = bcs.struct('ChangeEpoch', {
+	epoch: bcs.u64(),
+	protocolVersion: bcs.u64(),
+	storageCharge: bcs.u64(),
+	computationCharge: bcs.u64(),
+	storageRebate: bcs.u64(),
+	nonRefundableStorageFee: bcs.u64(),
+	epochStartTimestampMs: bcs.u64(),
+	systemPackages: bcs.vector(
+		bcs.tuple([bcs.u64(), bcs.vector(bcs.byteVector()), bcs.vector(Address)]),
+	),
+});
+
+// Rust: crates/sui-types/src/transaction.rs
+export const GenesisObject = bcs.enum('GenesisObject', {
+	RawObject: bcs.struct('RawObject', {
+		data: Data,
+		owner: Owner,
+	}),
+});
+
+// Rust: crates/sui-types/src/transaction.rs
+export const GenesisTransaction = bcs.struct('GenesisTransaction', {
+	objects: bcs.vector(GenesisObject),
+});
+
+// Rust: crates/sui-types/src/messages_consensus.rs
+export const ConsensusCommitPrologue = bcs.struct('ConsensusCommitPrologue', {
+	epoch: bcs.u64(),
+	round: bcs.u64(),
+	commitTimestampMs: bcs.u64(),
+});
+
+// Rust: crates/sui-types/src/messages_consensus.rs
+export const ConsensusCommitPrologueV2 = bcs.struct('ConsensusCommitPrologueV2', {
+	epoch: bcs.u64(),
+	round: bcs.u64(),
+	commitTimestampMs: bcs.u64(),
+	consensusCommitDigest: ObjectDigest,
+});
+
+// Rust: crates/sui-types/src/messages_consensus.rs
+export const ConsensusDeterminedVersionAssignments = bcs.enum(
+	'ConsensusDeterminedVersionAssignments',
+	{
+		CancelledTransactions: bcs.vector(
+			bcs.tuple([ObjectDigest, bcs.vector(bcs.tuple([Address, bcs.u64()]))]),
+		),
+		CancelledTransactionsV2: bcs.vector(
+			bcs.tuple([
+				ObjectDigest,
+				bcs.vector(bcs.tuple([bcs.tuple([Address, bcs.u64()]), bcs.u64()])),
+			]),
+		),
+	},
+);
+
+// Rust: crates/sui-types/src/messages_consensus.rs
+export const ConsensusCommitPrologueV3 = bcs.struct('ConsensusCommitPrologueV3', {
+	epoch: bcs.u64(),
+	round: bcs.u64(),
+	subDagIndex: bcs.option(bcs.u64()),
+	commitTimestampMs: bcs.u64(),
+	consensusCommitDigest: ObjectDigest,
+	consensusDeterminedVersionAssignments: ConsensusDeterminedVersionAssignments,
+});
+
+// Rust: crates/sui-types/src/messages_consensus.rs
+export const ConsensusCommitPrologueV4 = bcs.struct('ConsensusCommitPrologueV4', {
+	epoch: bcs.u64(),
+	round: bcs.u64(),
+	subDagIndex: bcs.option(bcs.u64()),
+	commitTimestampMs: bcs.u64(),
+	consensusCommitDigest: ObjectDigest,
+	consensusDeterminedVersionAssignments: ConsensusDeterminedVersionAssignments,
+	additionalStateDigest: ObjectDigest,
+});
+
+// Rust: crates/sui-types/src/authenticator_state.rs
+export const ActiveJwk = bcs.struct('ActiveJwk', {
+	jwkId: bcs.struct('JwkId', {
+		iss: bcs.string(),
+		kid: bcs.string(),
+	}),
+	jwk: bcs.struct('JWK', {
+		kty: bcs.string(),
+		e: bcs.string(),
+		n: bcs.string(),
+		alg: bcs.string(),
+	}),
+	epoch: bcs.u64(),
+});
+
+// Rust: crates/sui-types/src/transaction.rs
+export const AuthenticatorStateUpdate = bcs.struct('AuthenticatorStateUpdate', {
+	epoch: bcs.u64(),
+	round: bcs.u64(),
+	newActiveJwks: bcs.vector(ActiveJwk),
+	authenticatorObjInitialSharedVersion: bcs.u64(),
+});
+
+// Rust: crates/sui-types/src/transaction.rs
+export const RandomnessStateUpdate = bcs.struct('RandomnessStateUpdate', {
+	epoch: bcs.u64(),
+	randomnessRound: bcs.u64(),
+	randomBytes: bcs.byteVector(),
+	randomnessObjInitialSharedVersion: bcs.u64(),
+});
+
+// Rust: crates/sui-types/src/transaction.rs
+export const AuthenticatorStateExpire = bcs.struct('AuthenticatorStateExpire', {
+	minEpoch: bcs.u64(),
+	authenticatorObjInitialSharedVersion: bcs.u64(),
+});
+
+// Rust: crates/sui-types/src/execution.rs
+export const ExecutionTimeObservationKey = bcs.enum('ExecutionTimeObservationKey', {
+	MoveEntryPoint: bcs.struct('MoveEntryPoint', {
+		package: Address,
+		module: bcs.string(),
+		function: bcs.string(),
+		typeArguments: bcs.vector(TypeTag),
+	}),
+	TransferObjects: null,
+	SplitCoins: null,
+	MergeCoins: null,
+	Publish: null,
+	MakeMoveVec: null,
+	Upgrade: null,
+});
+
+// Rust: crates/sui-types/src/transaction.rs
+export const StoredExecutionTimeObservations = bcs.enum('StoredExecutionTimeObservations', {
+	V1: bcs.vector(
+		bcs.tuple([
+			ExecutionTimeObservationKey,
+			bcs.vector(
+				bcs.tuple([
+					// AuthorityName (BLS public key bytes)
+					bcs.byteVector(),
+					bcs.struct('Duration', {
+						secs: bcs.u64(),
+						nanos: bcs.u32(),
+					}),
+				]),
+			),
+		]),
+	),
+});
+
+// Rust: crates/sui-types/src/transaction.rs
+export const WriteAccumulatorStorageCost = bcs.struct('WriteAccumulatorStorageCost', {
+	storageCost: bcs.u64(),
+});
+
+// Rust: crates/sui-types/src/transaction.rs
+export const EndOfEpochTransactionKind = bcs.enum('EndOfEpochTransactionKind', {
+	ChangeEpoch: ChangeEpoch,
+	AuthenticatorStateCreate: null,
+	AuthenticatorStateExpire: AuthenticatorStateExpire,
+	RandomnessStateCreate: null,
+	DenyListStateCreate: null,
+	// ChainIdentifier (the genesis checkpoint digest)
+	BridgeStateCreate: ObjectDigest,
+	BridgeCommitteeInit: bcs.u64(),
+	StoreExecutionTimeObservations: StoredExecutionTimeObservations,
+	AccumulatorRootCreate: null,
+	CoinRegistryCreate: null,
+	DisplayRegistryCreate: null,
+	AddressAliasStateCreate: null,
+	WriteAccumulatorStorageCost: WriteAccumulatorStorageCost,
+});
+
+// Rust: crates/sui-types/src/transaction.rs
+export const TransactionKind = bcs.enum('TransactionKind', {
+	ProgrammableTransaction: ProgrammableTransaction,
+	ChangeEpoch: ChangeEpoch,
+	Genesis: GenesisTransaction,
+	ConsensusCommitPrologue: ConsensusCommitPrologue,
+	AuthenticatorStateUpdate: AuthenticatorStateUpdate,
+	EndOfEpochTransaction: bcs.vector(EndOfEpochTransactionKind),
+	RandomnessStateUpdate: RandomnessStateUpdate,
+	ConsensusCommitPrologueV2: ConsensusCommitPrologueV2,
+	ConsensusCommitPrologueV3: ConsensusCommitPrologueV3,
+	ConsensusCommitPrologueV4: ConsensusCommitPrologueV4,
+	ProgrammableSystemTransaction: ProgrammableTransaction,
+});
+
+export const TransactionDataV1 = bcs.struct('TransactionDataV1', {
+	kind: TransactionKind,
+	sender: Address,
+	gasData: GasData,
+	expiration: TransactionExpiration,
+});
+
+export const TransactionData = bcs.enum('TransactionData', {
+	V1: TransactionDataV1,
+});
+
+export const SenderSignedTransaction = bcs.struct('SenderSignedTransaction', {
+	intentMessage: IntentMessage(TransactionData),
+	txSignatures: bcs.vector(base64String),
+});
+
+export const SenderSignedData = bcs.vector(SenderSignedTransaction, {
+	name: 'SenderSignedData',
+});

package/src/client/address-balance-transaction-expiration.ts

@@ -0,0 +1,53 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { TransactionDataBuilder } from '../transactions/TransactionData.js';
+import type { TransactionData } from '../transactions/data/internal.js';
+import type { ClientWithCoreApi } from './core.js';
+
+export async function setAddressBalanceTransactionExpirationFromSimulatedEpoch({
+	transactionData,
+	client,
+	epoch,
+	originalTransactionData,
+	isTransactionKindOnly,
+	doGasSelection,
+}: {
+	transactionData: TransactionDataBuilder;
+	client: ClientWithCoreApi;
+	epoch: string | number | bigint | null | undefined;
+	originalTransactionData: TransactionData;
+	isTransactionKindOnly: boolean;
+	doGasSelection: boolean;
+}) {
+	if (
+		isTransactionKindOnly ||
+		doGasSelection ||
+		originalTransactionData.expiration ||
+		originalTransactionData.gasData.payment?.length !== 0
+	) {
+		return;
+	}
+
+	if (transactionData.expiration && transactionData.expiration.$kind !== 'None') {
+		return;
+	}
+
+	const [{ chainIdentifier }, systemStateResult] = await Promise.all([
+		client.core.getChainIdentifier(),
+		epoch == null ? client.core.getCurrentSystemState() : null,
+	]);
+	const currentEpoch = BigInt(epoch ?? systemStateResult!.systemState.epoch);
+
+	transactionData.expiration = {
+		$kind: 'ValidDuring',
+		ValidDuring: {
+			minEpoch: String(currentEpoch),
+			maxEpoch: String(currentEpoch + 1n),
+			minTimestamp: null,
+			maxTimestamp: null,
+			chain: chainIdentifier,
+			nonce: (Math.random() * 0x100000000) >>> 0,
+		},
+	};
+}

package/src/client/core-resolver.ts

@@ -169,7 +169,11 @@ async function setGasBudget(
 			},
 		}),
 		include: { effects: true },
-	});
+		// The empty payment above is a placeholder for budget estimation, not a real address
+		// balance payment, so the server must simulate with a mocked gas coin rather than
+		// selecting gas. gRPC and GraphQL support this option, and JSON-RPC always mocks gas.
+		doGasSelection: false,
+	} as SuiClientTypes.SimulateTransactionOptions<{ effects: true }> & { doGasSelection: boolean });
 
 	if (simulateResult.$kind === 'FailedTransaction') {
 		const executionError = simulateResult.FailedTransaction.status.error ?? undefined;

package/src/client/core.ts

@@ -112,6 +112,14 @@ export abstract class CoreClient extends BaseClient implements SuiClientTypes.Tr
 		options: SuiClientTypes.ListDynamicFieldsOptions,
 	): Promise<SuiClientTypes.ListDynamicFieldsResponse>;
 
+	abstract listTransactions<Include extends SuiClientTypes.TransactionInclude = {}>(
+		options: SuiClientTypes.ListTransactionsOptions<Include>,
+	): Promise<SuiClientTypes.ListTransactionsResponse<Include>>;
+
+	abstract listEvents(
+		options: SuiClientTypes.ListEventsOptions,
+	): Promise<SuiClientTypes.ListEventsResponse>;
+
 	abstract resolveTransactionPlugin(): TransactionPlugin;
 
 	abstract verifyZkLoginSignature(