@mysten/sui 2.27.1 → 2.29.0

package/src/bcs/transactions.ts

@@ -188,6 +188,7 @@ export const EndOfEpochTransactionKind = bcs.enum('EndOfEpochTransactionKind', {
 	DisplayRegistryCreate: null,
 	AddressAliasStateCreate: null,
 	WriteAccumulatorStorageCost: WriteAccumulatorStorageCost,
+	ForwardingAddressRegistryCreate: null,
 });
 
 // Rust: crates/sui-types/src/transaction.rs

package/src/bcs/types.ts

@@ -126,10 +126,19 @@ type ValidDuring = {
 	nonce: number;
 };
 
+type AllowedProposers = {
+	epoch: number | string;
+	proposers: number[];
+};
+
+type Validity = ValidDuring & {
+	allowedProposers: { None: null } | { Some: AllowedProposers };
+};
+
 /**
  * TransactionExpiration
  *
  * Indications the expiration time for a transaction.
  */
 export type TransactionExpiration =
-	{ None: null } | { Epoch: number } | { ValidDuring: ValidDuring };
+	{ None: null } | { Epoch: number } | { ValidDuring: ValidDuring } | { Validity: Validity };

package/src/client/transaction-resolver.ts

@@ -4,6 +4,10 @@
 import { fromBase64, toBase64 } from '@mysten/bcs';
 
 import type { bcs } from '../bcs/index.js';
+import {
+	assertAllowedProposersNotEmpty,
+	assertAllowedProposersStrictlyIncreasing,
+} from '../bcs/bcs.js';
 import { TransactionDataBuilder } from '../transactions/TransactionData.js';
 import type {
 	CallArg,
@@ -23,6 +27,18 @@ import type { Argument } from '../grpc/proto/sui/rpc/v2/argument.js';
 import { Argument_ArgumentKind } from '../grpc/proto/sui/rpc/v2/argument.js';
 import { Transaction } from '../transactions/Transaction.js';
 
+function millisecondsToGrpcTimestamp(value: string | number) {
+	const milliseconds = BigInt(value);
+	return {
+		seconds: milliseconds / 1000n,
+		nanos: Number(milliseconds % 1000n) * 1_000_000,
+	};
+}
+
+function grpcTimestampToMilliseconds(timestamp: { seconds: bigint; nanos: number }) {
+	return (timestamp.seconds * 1000n + BigInt(Math.floor(timestamp.nanos / 1_000_000))).toString();
+}
+
 /**
  * Converts CallArg (TypeScript internal format) to gRPC Input format
  */
@@ -263,14 +279,36 @@ export function transactionDataToGrpcTransaction(data: TransactionData): GrpcTra
 				kind: TransactionExpiration_TransactionExpirationKind.EPOCH,
 				epoch: BigInt(data.expiration.Epoch),
 			};
-		} else if (data.expiration.$kind === 'ValidDuring') {
-			const validDuring = data.expiration.ValidDuring;
+		} else if (data.expiration.$kind === 'ValidDuring' || data.expiration.$kind === 'Validity') {
+			const validity =
+				data.expiration.$kind === 'ValidDuring'
+					? data.expiration.ValidDuring
+					: data.expiration.Validity;
+			const allowedProposers =
+				data.expiration.$kind === 'Validity' ? data.expiration.Validity.allowedProposers : null;
 			transaction.expiration = {
-				kind: TransactionExpiration_TransactionExpirationKind.VALID_DURING,
-				minEpoch: validDuring.minEpoch != null ? BigInt(validDuring.minEpoch) : undefined,
-				epoch: validDuring.maxEpoch != null ? BigInt(validDuring.maxEpoch) : undefined,
-				chain: validDuring.chain,
-				nonce: validDuring.nonce,
+				kind:
+					data.expiration.$kind === 'ValidDuring'
+						? TransactionExpiration_TransactionExpirationKind.VALID_DURING
+						: TransactionExpiration_TransactionExpirationKind.VALIDITY,
+				minEpoch: validity.minEpoch != null ? BigInt(validity.minEpoch) : undefined,
+				epoch: validity.maxEpoch != null ? BigInt(validity.maxEpoch) : undefined,
+				minTimestamp:
+					validity.minTimestamp != null
+						? millisecondsToGrpcTimestamp(validity.minTimestamp)
+						: undefined,
+				maxTimestamp:
+					validity.maxTimestamp != null
+						? millisecondsToGrpcTimestamp(validity.maxTimestamp)
+						: undefined,
+				chain: validity.chain,
+				nonce: validity.nonce,
+				allowedProposers: allowedProposers
+					? {
+							epoch: BigInt(allowedProposers.epoch),
+							proposers: assertAllowedProposersStrictlyIncreasing(allowedProposers.proposers),
+						}
+					: undefined,
 			};
 		}
 	}
@@ -529,13 +567,45 @@ export function grpcTransactionToTransactionData(grpcTx: GrpcTransaction): Trans
 					ValidDuring: {
 						minEpoch: grpcTx.expiration.minEpoch?.toString() ?? null,
 						maxEpoch: grpcTx.expiration.epoch?.toString() ?? null,
-						minTimestamp: null,
-						maxTimestamp: null,
+						minTimestamp: grpcTx.expiration.minTimestamp
+							? grpcTimestampToMilliseconds(grpcTx.expiration.minTimestamp)
+							: null,
+						maxTimestamp: grpcTx.expiration.maxTimestamp
+							? grpcTimestampToMilliseconds(grpcTx.expiration.maxTimestamp)
+							: null,
+						chain: grpcTx.expiration.chain ?? '',
+						nonce: grpcTx.expiration.nonce ?? 0,
+					},
+				};
+				break;
+			case TransactionExpiration_TransactionExpirationKind.VALIDITY:
+				expiration = {
+					$kind: 'Validity',
+					Validity: {
+						minEpoch: grpcTx.expiration.minEpoch?.toString() ?? null,
+						maxEpoch: grpcTx.expiration.epoch?.toString() ?? null,
+						minTimestamp: grpcTx.expiration.minTimestamp
+							? grpcTimestampToMilliseconds(grpcTx.expiration.minTimestamp)
+							: null,
+						maxTimestamp: grpcTx.expiration.maxTimestamp
+							? grpcTimestampToMilliseconds(grpcTx.expiration.maxTimestamp)
+							: null,
 						chain: grpcTx.expiration.chain ?? '',
 						nonce: grpcTx.expiration.nonce ?? 0,
+						allowedProposers: grpcTx.expiration.allowedProposers
+							? {
+									epoch: grpcTx.expiration.allowedProposers.epoch?.toString() ?? '0',
+									proposers: assertAllowedProposersNotEmpty(
+										grpcTx.expiration.allowedProposers.proposers,
+									),
+								}
+							: null,
 					},
 				};
 				break;
+			default:
+				// Leaving `expiration` null here would drop a restriction the server did send.
+				throw new Error(`Unknown transaction expiration kind: ${grpcTx.expiration.kind}`);
 		}
 	}
 

package/src/grpc/client.ts

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { GrpcWebOptions } from '@protobuf-ts/grpcweb-transport';
-import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
 import { TransactionExecutionServiceClient } from './proto/sui/rpc/v2/transaction_execution_service.client.js';
 import { LedgerServiceClient } from './proto/sui/rpc/v2/ledger_service.client.js';
 import { MovePackageServiceClient } from './proto/sui/rpc/v2/move_package_service.client.js';
@@ -19,6 +18,7 @@ import { fromBase64, toBase64 } from '@mysten/utils';
 import { NameServiceClient } from './proto/sui/rpc/v2/name_service.client.js';
 import { ForkingServiceClient } from './proto/sui/forking/v1alpha/forking_service.client.js';
 import type { TransactionPlugin } from '../transactions/index.js';
+import { GrpcWebFetchTransport } from './transport.js';
 
 interface SuiGrpcTransportOptions extends GrpcWebOptions {
 	transport?: never;
@@ -157,9 +157,17 @@ export class SuiGrpcClient extends BaseClient implements SuiClientTypes.Transpor
 
 	constructor(options: SuiGrpcClientOptions) {
 		super({ network: options.network });
-		const transport =
-			options.transport ??
-			new GrpcWebFetchTransport({ baseUrl: options.baseUrl, fetchInit: options.fetchInit });
+		const {
+			network: _network,
+			mvr: _mvr,
+			// Not forwarded: every Core API call passes its own `signal`, which would overwrite it.
+			abort: _abort,
+			transport: providedTransport,
+			...transportOptions
+		} = options as SuiGrpcClientOptions & SuiGrpcTransportOptions & { transport?: RpcTransport };
+
+		// A caller-supplied transport is used as given. See ./transport.ts for the default.
+		const transport = providedTransport ?? new GrpcWebFetchTransport(transportOptions);
 		this.transactionExecutionService = new TransactionExecutionServiceClient(transport);
 		this.ledgerService = new LedgerServiceClient(transport);
 		this.stateService = new StateServiceClient(transport);

package/src/grpc/core.ts

@@ -69,24 +69,28 @@ import {
 	validateTransactionQuery,
 } from '../client/query-filters.js';
 import { toGrpcEventFilter, toGrpcTransactionFilter } from './filters.js';
+import { hasDecodedStatusMessage } from './transport.js';
 
 export interface GrpcCoreClientOptions extends CoreClientOptions {
 	client: SuiGrpcClient;
 }
 
 function isNameServiceResolutionMiss(error: unknown): boolean {
-	if (!(error instanceof RpcError)) return false;
-	if (error.code === GrpcStatusCode[GrpcStatusCode.NOT_FOUND]) return true;
-	if (error.code !== GrpcStatusCode[GrpcStatusCode.RESOURCE_EXHAUSTED]) return false;
-
-	try {
-		// The gRPC service currently reports expired names as RESOURCE_EXHAUSTED without a
-		// structured reason. grpc-web URI-encodes status messages, so decode before matching while
-		// preserving unrelated RESOURCE_EXHAUSTED failures such as capacity limits.
-		return decodeURIComponent(error.message) === 'name has expired';
-	} catch {
-		return false;
-	}
+	// Read by shape, so an error from another copy of runtime-rpc is still recognised.
+	if (typeof error !== 'object' || error === null) return false;
+
+	const { code, message } = error as { code?: unknown; message?: unknown };
+	if (typeof code !== 'string' || typeof message !== 'string') return false;
+
+	if (code === GrpcStatusCode[GrpcStatusCode.NOT_FOUND]) return true;
+	if (code !== GrpcStatusCode[GrpcStatusCode.RESOURCE_EXHAUSTED]) return false;
+
+	// The service reports an expired name as RESOURCE_EXHAUSTED with no structured reason, so match
+	// the status text and leave other RESOURCE_EXHAUSTED failures alone. A transport this package did
+	// not build leaves `grpc-message` encoded, hence the second form.
+	if (message === 'name has expired') return true;
+
+	return !hasDecodedStatusMessage(error) && message === 'name%20has%20expired';
 }
 
 export class GrpcCoreClient extends CoreClient {
@@ -987,9 +991,9 @@ export class GrpcCoreClient extends CoreClient {
 				});
 				response = result.response;
 			} catch (error) {
-				// https://github.com/timostamm/protobuf-ts/pull/739
+				// The transport owns the status text. See ./transport.ts.
 				if (error instanceof Error && error.message) {
-					throw new SimulationError(decodeURIComponent(error.message), { cause: error });
+					throw new SimulationError(error.message, { cause: error });
 				}
 				throw error;
 			}

package/src/grpc/index.ts

@@ -23,10 +23,14 @@ export type {
 } from './client.js';
 export type { GrpcCoreClientOptions } from './core.js';
 
-// Re-export transports and types so users can configure custom transports
-// without adding @protobuf-ts/* as direct dependencies.
-export { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+// Subclasses `@protobuf-ts/grpcweb-transport`'s transport to fix its error handling.
+export { GrpcWebFetchTransport } from './transport.js';
+
+// Re-exported so users can configure a transport, and narrow and code the errors it produces,
+// without adding @protobuf-ts/* as a dependency.
+export { GrpcStatusCode } from '@protobuf-ts/grpcweb-transport';
 export type { GrpcWebOptions } from '@protobuf-ts/grpcweb-transport';
+export { RpcError } from '@protobuf-ts/runtime-rpc';
 export type { RpcTransport } from '@protobuf-ts/runtime-rpc';
 
 // Export all gRPC proto types as a namespace

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

@@ -727,6 +727,14 @@ export enum CommandArgumentError_CommandArgumentErrorKind {
 	 * @generated from protobuf enum value: INVALID_REFERENCE_ARGUMENT = 19;
 	 */
 	INVALID_REFERENCE_ARGUMENT = 19,
+	/**
+	 * Invalid usage of TxContext in the function signature. TxContext can only be used by
+	 * reference, `&TxContext` or `&mut TxContext`. If used mutably, it must be the only
+	 * TxContext parameter, and TxContext can never be returned from a Move call.
+	 *
+	 * @generated from protobuf enum value: INVALID_TX_CONTEXT = 20;
+	 */
+	INVALID_TX_CONTEXT = 20,
 }
 /**
  * An error with upgrading a package.

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

@@ -145,6 +145,13 @@ export interface TransactionExpiration {
 	 * @generated from protobuf field: optional uint32 nonce = 7;
 	 */
 	nonce?: number;
+	/**
+	 * The validators allowed to propose this transaction in consensus. Only set when `kind`
+	 * is `VALIDITY`. Leave unset to let any validator propose the transaction.
+	 *
+	 * @generated from protobuf field: optional sui.rpc.v2.AllowedProposers allowed_proposers = 8;
+	 */
+	allowedProposers?: AllowedProposers;
 }
 /**
  * @generated from protobuf enum sui.rpc.v2.TransactionExpiration.TransactionExpirationKind
@@ -181,6 +188,40 @@ export enum TransactionExpiration_TransactionExpirationKind {
 	 * @generated from protobuf enum value: VALID_DURING = 3;
 	 */
 	VALID_DURING = 3,
+	/**
+	 * Everything in VALID_DURING, plus a restriction on which validators may
+	 * propose the transaction in consensus.
+	 *
+	 * @generated from protobuf enum value: VALIDITY = 4;
+	 */
+	VALIDITY = 4,
+}
+/**
+ * The validators allowed to propose a transaction in consensus.
+ *
+ * Proposal by any other validator is byzantine behavior and invalidates the whole block.
+ *
+ * @generated from protobuf message sui.rpc.v2.AllowedProposers
+ */
+export interface AllowedProposers {
+	/**
+	 * The epoch whose committee `proposers` indexes into.
+	 *
+	 * Committee indices are only meaningful against one committee, so a set recorded for any
+	 * other epoch is ignored and the transaction is treated as naming no proposers.
+	 *
+	 * @generated from protobuf field: optional uint64 epoch = 1;
+	 */
+	epoch?: bigint;
+	/**
+	 * Committee indices of the allowed proposers, strictly increasing and non-empty.
+	 *
+	 * An empty list names no validator and is rejected; omit `allowed_proposers` entirely to
+	 * let any validator propose the transaction.
+	 *
+	 * @generated from protobuf field: repeated uint32 proposers = 2;
+	 */
+	proposers: number[];
 }
 /**
  * Transaction type.
@@ -1314,6 +1355,7 @@ class TransactionExpiration$Type extends MessageType<TransactionExpiration> {
 			{ no: 5, name: 'max_timestamp', kind: 'message', T: () => Timestamp },
 			{ no: 6, name: 'chain', kind: 'scalar', opt: true, T: 9 /*ScalarType.STRING*/ },
 			{ no: 7, name: 'nonce', kind: 'scalar', opt: true, T: 13 /*ScalarType.UINT32*/ },
+			{ no: 8, name: 'allowed_proposers', kind: 'message', T: () => AllowedProposers },
 		]);
 	}
 }
@@ -1322,6 +1364,32 @@ class TransactionExpiration$Type extends MessageType<TransactionExpiration> {
  */
 export const TransactionExpiration = new TransactionExpiration$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class AllowedProposers$Type extends MessageType<AllowedProposers> {
+	constructor() {
+		super('sui.rpc.v2.AllowedProposers', [
+			{
+				no: 1,
+				name: 'epoch',
+				kind: 'scalar',
+				opt: true,
+				T: 4 /*ScalarType.UINT64*/,
+				L: 0 /*LongType.BIGINT*/,
+			},
+			{
+				no: 2,
+				name: 'proposers',
+				kind: 'scalar',
+				repeat: 1 /*RepeatType.PACKED*/,
+				T: 13 /*ScalarType.UINT32*/,
+			},
+		]);
+	}
+}
+/**
+ * @generated MessageType for protobuf message sui.rpc.v2.AllowedProposers
+ */
+export const AllowedProposers = new AllowedProposers$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class TransactionKind$Type extends MessageType<TransactionKind> {
 	constructor() {
 		super('sui.rpc.v2.TransactionKind', [

package/src/grpc/transport.ts

@@ -0,0 +1,160 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { GrpcStatusCode } from '@protobuf-ts/grpcweb-transport';
+import { GrpcWebFetchTransport as UpstreamGrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import type {
+	MethodInfo,
+	RpcOptions,
+	ServerStreamingCall,
+	UnaryCall,
+} from '@protobuf-ts/runtime-rpc';
+import { RpcError } from '@protobuf-ts/runtime-rpc';
+
+// A failed call rejects four promises with the same error, so it is only decoded once. Registered
+// globally so another installed copy of this package sees the same marker.
+const MESSAGE_DECODED = Symbol.for('@mysten/sui/grpc/decoded-status-message');
+
+// `grpc-message` is percent-encoded on the wire and the upstream transport does not decode it:
+// https://github.com/timostamm/protobuf-ts/pull/739
+function decodeGrpcStatusMessage(message: string): string {
+	if (!message.includes('%')) return message;
+
+	try {
+		return decodeURIComponent(message);
+	} catch {
+		return message;
+	}
+}
+
+function markStatusMessageRead(error: RpcError): boolean {
+	if (MESSAGE_DECODED in error) return false;
+	Object.defineProperty(error, MESSAGE_DECODED, { value: true, configurable: true });
+
+	return true;
+}
+
+function decodeStatusMessageOnce(error: RpcError): void {
+	if (markStatusMessageRead(error)) error.message = decodeGrpcStatusMessage(error.message);
+}
+
+/** Whether this package's transport decoded the error's status text. */
+export function hasDecodedStatusMessage(error: object): boolean {
+	return MESSAGE_DECODED in error;
+}
+
+// An abort reason is arbitrary, and reading a property on it runs code the caller wrote. A read
+// that throws counts as absent, so one bad accessor does not decide the status.
+function readProperty(value: unknown, key: 'code' | 'name' | 'message'): unknown {
+	if (typeof value !== 'object' || value === null) return undefined;
+
+	try {
+		return (value as Record<string, unknown>)[key];
+	} catch {
+		return undefined;
+	}
+}
+
+// The reason is read by shape, since another copy of runtime-rpc or another realm fails
+// `instanceof`. `AbortSignal.timeout` aborts with a `TimeoutError`.
+function abortStatus(reason: unknown): string {
+	const code = readProperty(reason, 'code');
+
+	// A status name maps to a number; `in` would also match the enum's reverse mapping.
+	if (
+		typeof code === 'string' &&
+		typeof GrpcStatusCode[code as keyof typeof GrpcStatusCode] === 'number'
+	) {
+		return code;
+	}
+
+	return readProperty(reason, 'name') === 'TimeoutError'
+		? GrpcStatusCode[GrpcStatusCode.DEADLINE_EXCEEDED]
+		: GrpcStatusCode[GrpcStatusCode.CANCELLED];
+}
+
+// The transport reuses the abort reason's message, so matching it says the text is local. A fetch
+// that substitutes its own error (node-fetch) gives text of its own, which holds nothing to decode.
+// The reason is never coerced: a symbol or a throwing hook would throw here.
+function isAbortReasonText(message: string, reason: unknown): boolean {
+	if (typeof reason === 'string') return message === reason;
+
+	const reasonMessage = readProperty(reason, 'message');
+
+	return typeof reasonMessage === 'string' && message === reasonMessage;
+}
+
+// Rewritten in place, so every promise a call rejects surfaces the same error. Only the two codes
+// upstream uses for an abort are re-coded; a failure that raced the abort is relabelled with it.
+function normalizeGrpcError(error: unknown, signal: AbortSignal | undefined): void {
+	try {
+		normalize(error, signal);
+	} catch {
+		// Never an unhandled rejection from a discarded handler: the call reports what it was going
+		// to report.
+	}
+}
+
+function normalize(error: unknown, signal: AbortSignal | undefined): void {
+	if (!(error instanceof RpcError)) return;
+
+	if (
+		signal?.aborted &&
+		(error.code === GrpcStatusCode[GrpcStatusCode.INTERNAL] ||
+			error.code === GrpcStatusCode[GrpcStatusCode.CANCELLED])
+	) {
+		error.code = abortStatus(signal.reason);
+
+		// Text the abort reason supplied is local and holds nothing to decode; anything else came off
+		// the wire, even though the abort is what the caller sees. Settled here for the other promises
+		// the call rejects, which no longer match the codes above.
+		if (isAbortReasonText(error.message, signal.reason)) markStatusMessageRead(error);
+		else decodeStatusMessageOnce(error);
+
+		return;
+	}
+
+	decodeStatusMessageOnce(error);
+}
+
+function normalizeRejections(promises: Promise<unknown>[], signal: AbortSignal | undefined) {
+	for (const promise of promises) {
+		// Registered before the call is returned, so it runs before the consumer's own await.
+		promise.then(undefined, (error: unknown) => normalizeGrpcError(error, signal));
+	}
+}
+
+/**
+ * `GrpcWebFetchTransport` from `@protobuf-ts/grpcweb-transport`, subclassed to decode status
+ * messages and to code an aborted call from its reason rather than as `INTERNAL`.
+ *
+ * `SuiGrpcClient` builds one by default. A transport imported from `@protobuf-ts/grpcweb-transport`
+ * keeps that package's behaviour.
+ */
+export class GrpcWebFetchTransport extends UpstreamGrpcWebFetchTransport {
+	override unary<I extends object, O extends object>(
+		method: MethodInfo<I, O>,
+		input: I,
+		options: RpcOptions,
+	): UnaryCall<I, O> {
+		const call = super.unary(method, input, options);
+
+		normalizeRejections([call.headers, call.response, call.status, call.trailers], options.abort);
+
+		return call;
+	}
+
+	override serverStreaming<I extends object, O extends object>(
+		method: MethodInfo<I, O>,
+		input: I,
+		options: RpcOptions,
+	): ServerStreamingCall<I, O> {
+		const call = super.serverStreaming(method, input, options);
+
+		// A finite stream is often read through `responses` without awaiting `status`.
+		call.responses.onError((error) => normalizeGrpcError(error, options.abort));
+		normalizeRejections([call.headers, call.status, call.trailers], options.abort);
+
+		return call;
+	}
+}

package/src/transactions/data/internal.ts

@@ -343,10 +343,29 @@ export const ValidDuringSchema = object({
 });
 export type ValidDuring = InferOutput<typeof ValidDuringSchema>;
 
+// Rust: crates/sui-types/src/transaction.rs
+export const AllowedProposersSchema = object({
+	epoch: JsonU64,
+	// Shared by `setExpiration` and `restore`, so this can only carry the invariant true on both.
+	proposers: pipe(
+		array(U32),
+		check((proposers) => proposers.length > 0, 'Allowed proposers must not be empty'),
+	),
+});
+export type AllowedProposers = InferOutput<typeof AllowedProposersSchema>;
+
+// Rust: crates/sui-types/src/transaction.rs
+export const ValiditySchema = object({
+	...ValidDuringSchema.entries,
+	allowedProposers: nullable(AllowedProposersSchema),
+});
+export type Validity = InferOutput<typeof ValiditySchema>;
+
 export const TransactionExpiration = safeEnum({
 	None: literal(true),
 	Epoch: JsonU64,
 	ValidDuring: ValidDuringSchema,
+	Validity: ValiditySchema,
 });
 
 export type TransactionExpiration = InferOutput<typeof TransactionExpiration>;

package/src/transactions/data/v1.ts

@@ -26,7 +26,14 @@ import {
 
 import { TypeTagSerializer } from '../../bcs/index.js';
 import type { StructTag as StructTagType, TypeTag as TypeTagType } from '../../bcs/types.js';
-import { JsonU64, ObjectID, safeEnum, TransactionDataSchema } from './internal.js';
+import {
+	JsonU64,
+	ObjectID,
+	safeEnum,
+	TransactionDataSchema,
+	ValidDuringSchema,
+	ValiditySchema,
+} from './internal.js';
 import type { Argument, ArgumentSchema, TransactionData } from './internal.js';
 
 export const ObjectRef = object({
@@ -65,11 +72,52 @@ const TransactionInput = union([
 	}),
 ]);
 
+// Carried here rather than collapsed to `{ None: true }`, which silently dropped the expiration
+// (and its allowed proposers) from a `serialize()` -> `from()` round trip before signing.
 const TransactionExpiration = union([
 	object({ Epoch: pipe(number(), integer()) }),
 	object({ None: nullable(literal(true)) }),
+	object({ ValidDuring: ValidDuringSchema }),
+	object({ Validity: ValiditySchema }),
 ]);
 
+function expirationToV1(
+	expiration: TransactionData['expiration'],
+): InferOutput<typeof TransactionExpiration> | null {
+	if (!expiration) return null;
+
+	switch (expiration.$kind) {
+		case 'Epoch':
+			return { Epoch: Number(expiration.Epoch) };
+		case 'ValidDuring':
+			return { ValidDuring: expiration.ValidDuring };
+		case 'Validity':
+			return { Validity: expiration.Validity };
+		case 'None':
+			return { None: true };
+		default:
+			// Representing a new variant here is not optional: this fails to compile without it.
+			expiration satisfies never;
+			throw new Error(`Unknown transaction expiration: ${JSON.stringify(expiration)}`);
+	}
+}
+
+function expirationFromV1(
+	expiration: SerializedTransactionDataV1['expiration'],
+): InferInput<typeof TransactionDataSchema>['expiration'] {
+	if (!expiration) return null;
+	if ('Epoch' in expiration) return { Epoch: expiration.Epoch };
+	if ('ValidDuring' in expiration) return { ValidDuring: expiration.ValidDuring };
+	if ('Validity' in expiration) return { Validity: expiration.Validity };
+	if ('None' in expiration) return { None: true };
+
+	// `restore` does not validate v1 payloads against the schema, so this is the only place an
+	// unrecognised expiration can be caught rather than silently becoming `{ None: true }`.
+	throw new Error(
+		`Unknown transaction expiration in v1 transaction data: ${Object.keys(expiration).join(', ')}`,
+	);
+}
+
 const StringEncodedBigint = pipe(
 	union([number(), string(), bigint()]),
 	check((val) => {
@@ -267,12 +315,7 @@ export function serializeV1TransactionData(
 	return {
 		version: 1,
 		sender: transactionData.sender ?? undefined,
-		expiration:
-			transactionData.expiration?.$kind === 'Epoch'
-				? { Epoch: Number(transactionData.expiration.Epoch) }
-				: transactionData.expiration
-					? { None: true }
-					: null,
+		expiration: expirationToV1(transactionData.expiration),
 		gasConfig: {
 			owner: transactionData.gasData.owner ?? undefined,
 			budget: transactionData.gasData.budget ?? undefined,
@@ -373,11 +416,7 @@ export function transactionDataFromV1(data: SerializedTransactionDataV1): Transa
 	return parse(TransactionDataSchema, {
 		version: 2,
 		sender: data.sender ?? null,
-		expiration: data.expiration
-			? 'Epoch' in data.expiration
-				? { Epoch: data.expiration.Epoch }
-				: { None: true }
-			: null,
+		expiration: expirationFromV1(data.expiration),
 		gasData: {
 			owner: data.gasConfig.owner ?? null,
 			budget: data.gasConfig.budget?.toString() ?? null,

package/src/transactions/data/v2.ts

@@ -29,6 +29,7 @@ import {
 	ObjectRefSchema,
 	SuiAddress,
 	ValidDuringSchema,
+	ValiditySchema,
 } from './internal.js';
 import type { Simplify } from '@mysten/utils';
 
@@ -143,6 +144,7 @@ const TransactionExpiration = enumUnion({
 	None: literal(true),
 	Epoch: JsonU64,
 	ValidDuring: ValidDuringSchema,
+	Validity: ValiditySchema,
 });
 
 export const SerializedTransactionDataV2Schema = object({