@mysten/sui 2.22.1 → 2.23.1

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.1",
+  "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/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(

package/src/client/query-filters.ts

@@ -0,0 +1,195 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { normalizeSuiAddress } from '../utils/sui-types.js';
+import type { SuiClientTypes } from './types.js';
+
+export interface ResolvedPagination {
+	descending: boolean;
+	after: string | undefined;
+	before: string | undefined;
+	limit: number;
+}
+
+/**
+ * Default page size applied when `limit` is omitted, so every transport
+ * requests the same page size instead of falling back to differing server
+ * defaults.
+ */
+const DEFAULT_PAGE_SIZE = 50;
+
+/**
+ * Validates pagination bounds and resolves the traversal direction.
+ *
+ * `after` and `before` are exclusive ledger-position bounds. Until every
+ * transport can combine bounds freely, a query accepts at most one bound, and
+ * the bound must match the traversal direction (`after` implies ascending,
+ * `before` implies descending).
+ */
+export function resolvePagination(options: {
+	after?: string | null;
+	before?: string | null;
+	order?: 'ascending' | 'descending';
+	limit?: number;
+}): ResolvedPagination {
+	if (options.after != null && options.before != null) {
+		throw new Error('Only one of `after` or `before` may be provided');
+	}
+
+	const descending = options.order ? options.order === 'descending' : options.before != null;
+
+	if (options.after != null && descending) {
+		throw new Error('`after` can not be combined with descending queries');
+	}
+
+	if (options.before != null && !descending) {
+		throw new Error('`before` can not be combined with ascending queries');
+	}
+
+	return {
+		descending,
+		after: options.after ?? undefined,
+		before: options.before ?? undefined,
+		limit: options.limit ?? DEFAULT_PAGE_SIZE,
+	};
+}
+
+export type ResolvedTransactionFilter =
+	| { $kind: 'sender'; sender: string }
+	| { $kind: 'function'; package: string; module?: string; function?: string };
+
+/**
+ * Validates that a transaction query's filter supports pagination bounds.
+ *
+ * Function filters can only be paginated when fully qualified, since JSON-RPC
+ * rejects cursors on package- or module-level `MoveFunction` filters.
+ */
+export function validateTransactionQuery(
+	filter: ResolvedTransactionFilter | undefined,
+	pagination: ResolvedPagination,
+): void {
+	if (
+		filter?.$kind === 'function' &&
+		(pagination.after != null || pagination.before != null) &&
+		(!filter.module || !filter.function)
+	) {
+		throw new Error(
+			'Paginating transactions filtered by function requires a fully qualified `package::module::function`',
+		);
+	}
+}
+
+export type ResolvedEventFilter =
+	| { $kind: 'sender'; sender: string }
+	| { $kind: 'emitModule'; package: string; module: string }
+	| { $kind: 'eventTypeModule'; package: string; module: string }
+	| { $kind: 'eventType'; eventType: string };
+
+/**
+ * Validates a transaction filter and resolves any MVR names it contains.
+ *
+ * Every transport resolves filters through this function so that validation
+ * errors and MVR handling are identical across clients.
+ */
+export async function resolveTransactionFilter(
+	mvr: SuiClientTypes.MvrMethods,
+	filter: SuiClientTypes.TransactionFilter,
+	signal?: AbortSignal,
+): Promise<ResolvedTransactionFilter> {
+	assertSinglePredicate(filter, ['sender', 'function'], 'transaction');
+
+	if (filter.sender != null) {
+		return { $kind: 'sender', sender: normalizeSuiAddress(filter.sender) };
+	}
+
+	const [pkg, module, fn, ...rest] = filter.function!.split('::');
+
+	if (!pkg || rest.length > 0 || module === '' || fn === '') {
+		throw new Error(
+			`Invalid function filter "${filter.function}": expected "package", "package::module", or "package::module::function"`,
+		);
+	}
+
+	return {
+		$kind: 'function',
+		package: normalizeSuiAddress((await mvr.resolvePackage({ package: pkg, signal })).package),
+		module,
+		function: fn,
+	};
+}
+
+/**
+ * Validates an event filter and resolves any MVR names it contains.
+ *
+ * `emitModule` must name a module (`package::module`), and `eventType` must be
+ * at least module-qualified (`package::module` or a full type). Every transport
+ * resolves filters through this function so that validation errors and MVR
+ * handling are identical across clients.
+ */
+export async function resolveEventFilter(
+	mvr: SuiClientTypes.MvrMethods,
+	filter: SuiClientTypes.EventFilter,
+	signal?: AbortSignal,
+): Promise<ResolvedEventFilter> {
+	assertSinglePredicate(filter, ['sender', 'emitModule', 'eventType'], 'event');
+
+	if (filter.sender != null) {
+		return { $kind: 'sender', sender: normalizeSuiAddress(filter.sender) };
+	}
+
+	if (filter.emitModule != null) {
+		const [pkg, module, ...rest] = filter.emitModule.split('::');
+
+		if (!pkg || !module || rest.length > 0) {
+			throw new Error(
+				`Invalid emitModule filter "${filter.emitModule}": expected "package::module"`,
+			);
+		}
+
+		return {
+			$kind: 'emitModule',
+			package: normalizeSuiAddress((await mvr.resolvePackage({ package: pkg, signal })).package),
+			module,
+		};
+	}
+
+	const eventType = filter.eventType!;
+	const segments = eventType.split('::');
+
+	if (segments.length === 2 && segments.every((segment) => segment !== '')) {
+		return {
+			$kind: 'eventTypeModule',
+			package: normalizeSuiAddress(
+				(await mvr.resolvePackage({ package: segments[0], signal })).package,
+			),
+			module: segments[1],
+		};
+	}
+
+	if (segments.length < 3 || segments.some((segment) => segment === '')) {
+		throw new Error(
+			`Invalid eventType filter "${eventType}": expected "package::module" or a fully qualified type name`,
+		);
+	}
+
+	return {
+		$kind: 'eventType',
+		eventType: (await mvr.resolveType({ type: eventType, signal })).type,
+	};
+}
+
+function assertSinglePredicate(
+	filter: Record<string, unknown>,
+	predicates: string[],
+	kind: string,
+): void {
+	const present = predicates.filter((predicate) => filter[predicate] != null);
+
+	if (present.length !== 1) {
+		throw new Error(
+			`A ${kind} filter must specify exactly one of ${predicates.join(', ')}${
+				present.length ? ` (got ${present.join(', ')})` : ''
+			}`,
+		);
+	}
+}