@mysten/sui 2.27.1 → 2.28.0

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/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({

package/src/version.ts

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