@mysten/sui 2.11.0 → 2.12.0

package/dist/zklogin/bcs.d.mts

@@ -1,31 +1,31 @@
-import * as _mysten_bcs817 from "@mysten/bcs";
+import * as _mysten_bcs1111 from "@mysten/bcs";
 import { InferBcsInput } from "@mysten/bcs";
 
 //#region src/zklogin/bcs.d.ts
-declare const zkLoginSignature: _mysten_bcs817.BcsStruct<{
-  inputs: _mysten_bcs817.BcsStruct<{
-    proofPoints: _mysten_bcs817.BcsStruct<{
-      a: _mysten_bcs817.BcsType<string[], Iterable<string> & {
+declare const zkLoginSignature: _mysten_bcs1111.BcsStruct<{
+  inputs: _mysten_bcs1111.BcsStruct<{
+    proofPoints: _mysten_bcs1111.BcsStruct<{
+      a: _mysten_bcs1111.BcsType<string[], Iterable<string> & {
         length: number;
       }, string>;
-      b: _mysten_bcs817.BcsType<string[][], Iterable<Iterable<string> & {
+      b: _mysten_bcs1111.BcsType<string[][], Iterable<Iterable<string> & {
         length: number;
       }> & {
         length: number;
       }, string>;
-      c: _mysten_bcs817.BcsType<string[], Iterable<string> & {
+      c: _mysten_bcs1111.BcsType<string[], Iterable<string> & {
         length: number;
       }, string>;
     }, string>;
-    issBase64Details: _mysten_bcs817.BcsStruct<{
-      value: _mysten_bcs817.BcsType<string, string, "string">;
-      indexMod4: _mysten_bcs817.BcsType<number, number, "u8">;
+    issBase64Details: _mysten_bcs1111.BcsStruct<{
+      value: _mysten_bcs1111.BcsType<string, string, "string">;
+      indexMod4: _mysten_bcs1111.BcsType<number, number, "u8">;
     }, string>;
-    headerBase64: _mysten_bcs817.BcsType<string, string, "string">;
-    addressSeed: _mysten_bcs817.BcsType<string, string, "string">;
+    headerBase64: _mysten_bcs1111.BcsType<string, string, "string">;
+    addressSeed: _mysten_bcs1111.BcsType<string, string, "string">;
   }, string>;
-  maxEpoch: _mysten_bcs817.BcsType<string, string | number | bigint, "u64">;
-  userSignature: _mysten_bcs817.BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
+  maxEpoch: _mysten_bcs1111.BcsType<string, string | number | bigint, "u64">;
+  userSignature: _mysten_bcs1111.BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
 }, string>;
 type ZkLoginSignature = InferBcsInput<typeof zkLoginSignature>;
 type ZkLoginSignatureInputs = ZkLoginSignature['inputs'];

package/dist/zklogin/bcs.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"bcs.d.mts","names":[],"sources":["../../src/zklogin/bcs.ts"],"sourcesContent":[],"mappings":";;;;cAMa,iCAAgB;;;MAAhB,CAAA,wBAgBX,CAAA,MAAA,EAAA,UAAA,CAAA,MAAA,CAAA,GAAA;;;;;;;;;;;;;;;;;;;;eAhB2B,wBAAA,WAAA,gBAAA,CAAA,UAAA,CAAA,MAAA,CAAA,EAAA,YAAA,CAAA;CAAA,EAAA,MAAA,CAAA;AAkBjB,KAAA,gBAAA,GAAmB,aAAqB,CAAA,OAAA,gBAAR,CAAA;AAChC,KAAA,sBAAA,GAAyB,gBAAA,CAAA,QAAgB,CAAA"}
+{"version":3,"file":"bcs.d.mts","names":[],"sources":["../../src/zklogin/bcs.ts"],"sourcesContent":[],"mappings":";;;;cAMa,kCAAgB;;;MAAhB,CAAA,yBAgBX,CAAA,MAAA,EAAA,UAAA,CAAA,MAAA,CAAA,GAAA;;;;;;;;;;;;;;;;;;;;eAhB2B,yBAAA,WAAA,gBAAA,CAAA,UAAA,CAAA,MAAA,CAAA,EAAA,YAAA,CAAA;CAAA,EAAA,MAAA,CAAA;AAkBjB,KAAA,gBAAA,GAAmB,aAAqB,CAAA,OAAA,gBAAR,CAAA;AAChC,KAAA,sBAAA,GAAyB,gBAAA,CAAA,QAAgB,CAAA"}

package/docs/clients/core.md

@@ -342,6 +342,21 @@ console.log(result.effects);
 console.log(result.balanceChanges);
 ```
 
+#### Disabling Checks
+
+By default, `simulateTransaction` runs with full transaction validation. For example when inspecting
+non-public or non-entry Move functions set `checksEnabled: false`:
+
+```typescript
+const result = await client.core.simulateTransaction({
+	transaction: transactionBytes,
+	checksEnabled: false,
+	include: {
+		commandResults: true,
+	},
+});
+```
+
 ### signAndExecuteTransaction
 
 Sign and execute a transaction in one step.

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

@@ -54,11 +54,27 @@ These JSON-RPC methods have direct replacements in the core API:
 | `multiGetObjects`            | `getObjects`                                      |
 | `getDynamicFields`           | `listDynamicFields`                               |
 | `getDynamicFieldObject`      | `getDynamicField`                                 |
-| `devInspectTransactionBlock` | `simulateTransaction`                             |
+| `devInspectTransactionBlock` | `simulateTransaction` with `checksEnabled: false` |
 | `dryRunTransactionBlock`     | `simulateTransaction`                             |
 | `getNormalizedMoveFunction`  | `getMoveFunction`                                 |
 | `getMoveFunctionArgTypes`    | `getMoveFunction`                                 |
 
+### Example: Migrating devInspectTransactionBlock
+
+```diff
+- const result = await jsonRpcClient.devInspectTransactionBlock({
+-   sender: '0xabc...',
+-   transactionBlock: tx,
+- });
+- const returnValues = result.results?.[0]?.returnValues;
++ const result = await client.core.simulateTransaction({
++   transaction: tx,
++   checksEnabled: false,
++   include: { commandResults: true },
++ });
++ const returnValues = result.commandResults?.[0]?.returnValues;
+```
+
 ### Example: Migrating getOwnedObjects
 
 ```diff

package/docs/utils/derived_objects.md

@@ -57,3 +57,24 @@ const key = bcsType.serialize({ value: 1 }).toBytes();
 // Derive the object ID for the key `DemoStruct { value: 1 }`.
 deriveObjectID('0xc0ffee', `0xc0ffee::demo::DemoStruct`, key);
 ```
+
+### Deriving with fieldless structs
+
+In Move, structs with no user-defined fields automatically get a `dummy_field: bool` injected by the
+compiler. This means their BCS encoding is not empty — it's a single `0x00` byte (the encoding of
+`false`). You can treat this as a constant.
+
+A real-world example is `0x2::coin_registry::CurrencyKey<T>`, which is a fieldless generic struct
+used to derive `Currency` objects from the coin registry (`0xc`) based on their type:
+
+```typescript
+// On-chain: `public struct CurrencyKey<phantom T>() has copy, store, drop`
+// The compiler injects `dummy_field: bool`, always `false`.
+const key = new Uint8Array([0]);
+
+const coinType = '0x2::sui::SUI';
+const currencyId = deriveObjectID('0xc', `0x2::coin_registry::CurrencyKey<${coinType}>`, key);
+```
+
+This applies to any struct with no fields — phantom type parameters don't add any BCS-encoded data,
+so the key is always `new Uint8Array([0])`.

package/package.json

@@ -3,7 +3,7 @@
   "author": "Mysten Labs <build@mystenlabs.com>",
   "description": "Sui TypeScript API",
   "homepage": "https://sdk.mystenlabs.com",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "license": "Apache-2.0",
   "sideEffects": false,
   "files": [
@@ -167,8 +167,8 @@
     "graphql": "^16.12.0",
     "poseidon-lite": "0.2.1",
     "valibot": "^1.2.0",
-    "@mysten/utils": "^0.3.1",
-    "@mysten/bcs": "^2.0.3"
+    "@mysten/bcs": "^2.0.3",
+    "@mysten/utils": "^0.3.1"
   },
   "scripts": {
     "clean": "rm -rf tsconfig.tsbuildinfo ./dist",

package/src/client/types.ts

@@ -442,6 +442,14 @@ export namespace SuiClientTypes {
 	> extends CoreClientMethodOptions {
 		transaction: Uint8Array | TransactionInstance;
 		include?: Include & SimulateTransactionInclude;
+		/**
+		 * When set to `false`, disables transaction validation checks during simulation.
+		 * This allows inspecting non-public/non-entry Move functions and other transactions
+		 * that would normally fail validation.
+		 *
+		 * Defaults to `true` (checks enabled).
+		 */
+		checksEnabled?: boolean;
 	}
 
 	export interface GetReferenceGasPriceOptions extends CoreClientMethodOptions {}

package/src/graphql/core.ts

@@ -406,6 +406,7 @@ export class GraphQLCoreClient extends CoreClient {
 					includeObjectTypes: options.include?.objectTypes ?? false,
 					includeCommandResults: options.include?.commandResults ?? false,
 					includeBcs: options.include?.bcs ?? false,
+					checksEnabled: options.checksEnabled ?? true,
 				},
 			},
 			(result) => result.simulateTransaction,

package/src/grpc/core.ts

@@ -44,6 +44,7 @@ import {
 	grpcTransactionToTransactionData,
 } from '../client/transaction-resolver.js';
 import { Value } from './proto/google/protobuf/struct.js';
+import { SimulateTransactionRequest_TransactionChecks } from './proto/sui/rpc/v2/transaction_execution_service.js';
 
 export interface GrpcCoreClientOptions extends CoreClientOptions {
 	client: SuiGrpcClient;
@@ -447,6 +448,10 @@ export class GrpcCoreClient extends CoreClient {
 				paths,
 			},
 			doGasSelection: false,
+			checks:
+				options.checksEnabled === false
+					? SimulateTransactionRequest_TransactionChecks.DISABLED
+					: SimulateTransactionRequest_TransactionChecks.ENABLED,
 		});
 
 		const transactionResult = parseTransaction(response.transaction!, options.include);

package/src/jsonRpc/core.ts

@@ -5,6 +5,8 @@ import { fromBase64, type InferBcsInput } from '@mysten/bcs';
 
 import { bcs, TypeTagSerializer } from '../bcs/index.js';
 import type {
+	DevInspectResults,
+	DryRunTransactionBlockResponse,
 	ExecutionStatus as JsonRpcExecutionStatus,
 	ObjectOwner,
 	SuiMoveAbilitySet,
@@ -356,14 +358,44 @@ export class JSONRpcCoreClient extends CoreClient {
 				})
 			: (options.transaction as Uint8Array);
 
-		const result = await this.#jsonRpcClient.dryRunTransactionBlock({
-			transactionBlock: transactionBytes,
-			signal: options.signal,
-		});
+		const sender = tx.getData().sender ?? normalizeSuiAddress('0x0');
+		const checksDisabled = options.checksEnabled === false;
+
+		let dryRunResult: DryRunTransactionBlockResponse | null = null;
+		try {
+			dryRunResult = await this.#jsonRpcClient.dryRunTransactionBlock({
+				transactionBlock: transactionBytes,
+				signal: options.signal,
+			});
+		} catch (e) {
+			if (!checksDisabled) {
+				throw e;
+			}
+		}
+
+		let devInspectResult: DevInspectResults | null = null;
+		if (options.include?.commandResults || checksDisabled) {
+			try {
+				devInspectResult = await this.#jsonRpcClient.devInspectTransactionBlock({
+					sender,
+					transactionBlock: tx,
+					signal: options.signal,
+				});
+			} catch {}
+		}
+
+		const dryRunFailed = !dryRunResult || dryRunResult.effects.status.status !== 'success';
+		const effectsSource =
+			checksDisabled && dryRunFailed && devInspectResult
+				? devInspectResult
+				: (dryRunResult ?? devInspectResult);
+		if (!effectsSource) {
+			throw new Error('simulateTransaction failed: no results from dryRun or devInspect');
+		}
 
 		const { effects, objectTypes } = parseTransactionEffectsJson({
-			effects: result.effects,
-			objectChanges: result.objectChanges,
+			effects: effectsSource.effects,
+			objectChanges: dryRunResult?.objectChanges ?? [],
 		});
 
 		const transactionData: SuiClientTypes.Transaction<Include> = {
@@ -391,15 +423,15 @@ export class JSONRpcCoreClient extends CoreClient {
 			bcs: (options.include?.bcs
 				? transactionBytes
 				: undefined) as SuiClientTypes.Transaction<Include>['bcs'],
-			balanceChanges: (options.include?.balanceChanges
-				? result.balanceChanges.map((change) => ({
+			balanceChanges: (options.include?.balanceChanges && dryRunResult
+				? dryRunResult.balanceChanges.map((change) => ({
 						coinType: normalizeStructTag(change.coinType),
 						address: parseOwnerAddress(change.owner)!,
 						amount: change.amount,
 					}))
 				: undefined) as SuiClientTypes.Transaction<Include>['balanceChanges'],
 			events: (options.include?.events
-				? (result.events?.map((event) => ({
+				? (effectsSource.events?.map((event) => ({
 						packageId: event.packageId,
 						module: event.transactionModule,
 						sender: event.sender,
@@ -411,26 +443,15 @@ export class JSONRpcCoreClient extends CoreClient {
 		};
 
 		let commandResults: SuiClientTypes.CommandResult[] | undefined;
-		if (options.include?.commandResults) {
-			try {
-				const sender = tx.getData().sender ?? normalizeSuiAddress('0x0');
-				const devInspectResult = await this.#jsonRpcClient.devInspectTransactionBlock({
-					sender,
-					transactionBlock: tx,
-					signal: options.signal,
-				});
-
-				if (devInspectResult.results) {
-					commandResults = devInspectResult.results.map((result) => ({
-						returnValues: (result.returnValues ?? []).map(([bytes]) => ({
-							bcs: new Uint8Array(bytes),
-						})),
-						mutatedReferences: (result.mutableReferenceOutputs ?? []).map(([, bytes]) => ({
-							bcs: new Uint8Array(bytes),
-						})),
-					}));
-				}
-			} catch {}
+		if (options.include?.commandResults && devInspectResult?.results) {
+			commandResults = devInspectResult.results.map((result) => ({
+				returnValues: (result.returnValues ?? []).map(([bytes]) => ({
+					bcs: new Uint8Array(bytes),
+				})),
+				mutatedReferences: (result.mutableReferenceOutputs ?? []).map(([, bytes]) => ({
+					bcs: new Uint8Array(bytes),
+				})),
+			}));
 		}
 
 		return effects.status.success

package/src/version.ts

@@ -3,5 +3,5 @@
 
 // This file is generated by genversion.mjs. Do not edit it directly.
 
-export const PACKAGE_VERSION = '2.11.0';
+export const PACKAGE_VERSION = '2.12.0';
 export const TARGETED_RPC_VERSION = '1.69.0';