@mysten/sui 2.16.3 → 2.18.0

package/docs/transactions/signing-and-execution.md

@@ -0,0 +1,401 @@
+# Signing and Execution
+
+> Sign transactions and execute them on the Sui network
+
+Once you've built a transaction, you need to sign it and submit it to the network. For background on
+how transaction signing and finality work at the protocol level, see the Sui documentation on
+[transaction lifecycle](https://docs.sui.io/concepts/transactions/transaction-lifecycle) and
+[transaction auth](https://docs.sui.io/concepts/transactions/transaction-auth).
+
+## Simulating transactions
+
+Use `simulateTransaction` to dry-run a transaction without executing it. This is useful for
+estimating gas costs, checking return values, and validating transactions before executing.
+
+```typescript
+
+const grpcClient = new SuiGrpcClient({
+	network: 'mainnet',
+	baseUrl: 'https://fullnode.mainnet.sui.io:443',
+});
+
+const result = await grpcClient.simulateTransaction({
+	transaction: tx,
+	include: {
+		effects: true,
+		balanceChanges: true,
+		commandResults: true,
+	},
+});
+
+if (result.$kind === 'FailedTransaction') {
+	console.error('Simulation failed:', result.FailedTransaction.status.error?.message);
+} else {
+	console.log('Balance changes:', result.Transaction.balanceChanges);
+	console.log('Command results:', result.commandResults);
+}
+```
+
+### `include` options
+
+The `include` parameter controls what data is returned from the simulation. All fields are optional
+and default to `false`:
+
+| Field            | Description                                                                            |
+| ---------------- | -------------------------------------------------------------------------------------- |
+| `effects`        | Execution effects: created, mutated, and deleted objects, gas usage                    |
+| `events`         | Move events emitted during execution                                                   |
+| `balanceChanges` | Token balance changes for each affected address and coin type                          |
+| `objectTypes`    | Map of object ID to type string for all changed objects                                |
+| `transaction`    | The full transaction data (sender, commands, gas config)                               |
+| `bcs`            | Raw BCS-encoded transaction bytes                                                      |
+| `commandResults` | BCS-encoded return values and mutated references from each command _(simulation only)_ |
+
+The `commandResults` field is unique to simulation. It is not available on `executeTransaction`.
+Each entry contains `returnValues` and `mutatedReferences`, both as BCS-encoded `Uint8Array` values
+that you can decode with the [BCS library](/bcs).
+
+## With a keypair (backend or scripts)
+
+The simplest approach. The keypair signs the transaction and submits it to the network in one call:
+
+```typescript
+
+const keypair = Ed25519Keypair.fromSecretKey('suiprivkey1...');
+const grpcClient = new SuiGrpcClient({
+	network: 'mainnet',
+	baseUrl: 'https://fullnode.mainnet.sui.io:443',
+});
+
+const result = await keypair.signAndExecuteTransaction({
+	transaction: tx,
+	client: grpcClient,
+});
+```
+
+`fromSecretKey` accepts a Bech32-encoded private key (`suiprivkey1...`) or a raw 32-byte
+`Uint8Array`. You can also use `Ed25519Keypair.deriveKeypair(mnemonic)` to derive from a mnemonic
+phrase.
+
+This method automatically sets the sender to the keypair's address, builds the transaction, signs
+it, and executes it. The result includes the transaction data and effects by default.
+
+Available keypair types:
+
+- `Ed25519Keypair` from `@mysten/sui/keypairs/ed25519`
+- `Secp256k1Keypair` from `@mysten/sui/keypairs/secp256k1`
+- `Secp256r1Keypair` from `@mysten/sui/keypairs/secp256r1`
+- `PasskeyKeypair` from `@mysten/sui/keypairs/passkey`
+
+## With dapp-kit (React frontend)
+
+In a React app, use the `useSignAndExecuteTransaction` hook. The user's connected wallet signs and
+submits the transaction:
+
+```tsx
+
+function SendButton() {
+	const { mutate: signAndExecute } = useSignAndExecuteTransaction();
+
+	function handleClick() {
+		const tx = new Transaction();
+		// ... build your transaction ...
+
+		signAndExecute(
+			{ transaction: tx },
+			{
+				onSuccess: (result) => {
+					console.log('Transaction digest:', result.digest);
+				},
+				onError: (error) => {
+					console.error('Transaction failed:', error);
+				},
+			},
+		);
+	}
+
+	return <button onClick={handleClick}>Send</button>;
+}
+```
+
+See the [dapp-kit documentation](/dapp-kit) for full setup instructions.
+
+## Sign without executing
+
+Sometimes you need the signature without immediately executing, such as for multi-sig, sponsored
+transactions, or delayed execution.
+
+### With a keypair
+
+```typescript
+// Build the transaction bytes first
+tx.setSender(keypair.toSuiAddress());
+const bytes = await tx.build({ client: grpcClient });
+
+// Sign the bytes
+const { signature } = await keypair.signTransaction(bytes);
+```
+
+### With dapp-kit
+
+```tsx
+
+function SignButton() {
+	const { mutate: signTransaction } = useSignTransaction();
+
+	function handleClick() {
+		const tx = new Transaction();
+		// ... build your transaction ...
+
+		signTransaction(
+			{ transaction: tx },
+			{
+				onSuccess: ({ bytes, signature }) => {
+					// Send bytes + signature to your backend, sponsor, etc.
+				},
+			},
+		);
+	}
+
+	return <button onClick={handleClick}>Sign</button>;
+}
+```
+
+## Manual execution
+
+When you already have the transaction bytes and signature(s), execute directly through the client:
+
+```typescript
+const result = await grpcClient.executeTransaction({
+	transaction: bytes, // Uint8Array
+	signatures: [signature], // string[]
+	include: {
+		effects: true,
+		events: true,
+		balanceChanges: true,
+		objectTypes: true,
+	},
+});
+```
+
+The `include` parameter controls what data is returned with the result:
+
+| Field            | Description                                              |
+| ---------------- | -------------------------------------------------------- |
+| `transaction`    | The full transaction data (sender, commands, gas)        |
+| `effects`        | Execution effects (created, mutated, or deleted objects) |
+| `events`         | Move events emitted during execution                     |
+| `balanceChanges` | Token balance changes for each affected address          |
+| `objectTypes`    | Map of object ID to type for changed objects             |
+| `bcs`            | Raw BCS bytes of the transaction                         |
+
+## Observing results
+
+### Checking success or failure
+
+Every transaction result is a discriminated union. Always check which variant you received:
+
+```typescript
+const result = await keypair.signAndExecuteTransaction({
+	transaction: tx,
+	client: grpcClient,
+});
+
+if (result.$kind === 'FailedTransaction') {
+	const { status } = result.FailedTransaction;
+	console.error('Transaction failed:', status.error?.message);
+} else {
+	console.log('Transaction succeeded:', result.Transaction.digest);
+}
+```
+
+You can also use the shorthand:
+
+```typescript
+const tx = result.Transaction ?? result.FailedTransaction;
+if (!tx.status.success) {
+	throw new Error(`Failed: ${tx.status.error?.message}`);
+}
+```
+
+### Waiting for indexing
+
+After a transaction executes, read APIs (like `getBalance` or `getObject`) might not immediately
+show the effects. You must also wait before executing a subsequent transaction that depends on
+objects created or modified by the first one. Use `waitForTransaction` to ensure consistency:
+
+```typescript
+const result = await keypair.signAndExecuteTransaction({
+	transaction: tx,
+	client: grpcClient,
+});
+
+// Wait for the transaction to be indexed
+await grpcClient.waitForTransaction({ result });
+
+// Now reads will reflect the transaction's effects
+const { balance } = await grpcClient.getBalance({ owner: myAddress });
+```
+
+You can also wait by digest:
+
+```typescript
+await grpcClient.waitForTransaction({ digest: result.Transaction.digest });
+```
+
+## Gas configuration
+
+Every Sui transaction costs gas. The SDK handles gas automatically in most cases. It sets the gas
+price, estimates the budget, and selects how to pay. You only need to configure gas explicitly for
+special cases.
+
+### Defaults
+
+When you don't configure gas explicitly, the SDK:
+
+1. **Gas price**: Uses the network's reference gas price
+2. **Gas budget**: Simulates the transaction and uses the result to set an appropriate budget
+3. **Gas payment**: Uses address balances, falling back to coin objects when the balance is below
+   the budget
+
+For most transactions, the defaults work well and you don't need to change anything.
+
+### Explicit gas settings
+
+```typescript
+// Override the reference gas price
+tx.setGasPrice(1500);
+
+// Override the simulated budget (in MIST)
+tx.setGasBudget(50_000_000);
+```
+
+### Gas payment with coin objects
+
+Specify exactly which coins to use for gas. The system merges these coins into a single gas coin
+before execution:
+
+```typescript
+tx.setGasPayment([
+	{ objectId: '0xCoin1', version: '1', digest: 'abc...' },
+	{ objectId: '0xCoin2', version: '2', digest: 'def...' },
+]);
+```
+
+The coins you provide must not overlap with any object inputs in your transaction.
+
+### Gas payment with address balance
+
+To pay gas from your address balance instead of coin objects, pass an empty array:
+
+```typescript
+tx.setGasPayment([]);
+```
+
+This is particularly useful for [offline building](./offline) and
+[sponsored transactions](#sponsored-transactions), because there are no coin object versions to look
+up or coordinate.
+
+### The gas coin (`tx.gas`)
+
+`tx.gas` references the coin used for gas payment. You can split SUI from it, merge coins into it,
+or transfer it to another address:
+
+```typescript
+const [coin] = tx.splitCoins(tx.gas, [1_000_000_000]);
+tx.transferObjects([coin], '0xRecipientAddress');
+```
+
+> **Warning:** `tx.gas` only works when gas is paid from coin objects. If gas is paid from address balances
+> (through `setGasPayment([])`), `tx.gas` is not available. Use [`tx.coin()`](./coins-and-balances)
+> instead, which works in both cases.
+
+## Sponsored transactions
+
+In a sponsored transaction, someone other than the sender pays for gas. There are two flows
+depending on whether gas is paid from coin objects or address balances.
+
+### Coin-based sponsorship
+
+The traditional flow where the sponsor provides specific gas coin objects:
+
+```typescript
+// 1. User builds transaction kind bytes (no gas info)
+const tx = new Transaction();
+// ... add commands ...
+const kindBytes = await tx.build({ client: grpcClient, onlyTransactionKind: true });
+
+// 2. Sponsor wraps with gas info
+const sponsoredTx = Transaction.fromKind(kindBytes);
+sponsoredTx.setSender(userAddress);
+sponsoredTx.setGasOwner(sponsorAddress);
+sponsoredTx.setGasPayment(sponsorGasCoins);
+
+// 3. Build the full transaction
+const fullBytes = await sponsoredTx.build({ client: grpcClient });
+
+// 4. Both parties sign
+const { signature: userSignature } = await userKeypair.signTransaction(fullBytes);
+const { signature: sponsorSignature } = await sponsorKeypair.signTransaction(fullBytes);
+
+// 5. Execute with both signatures
+const result = await grpcClient.executeTransaction({
+	transaction: fullBytes,
+	signatures: [userSignature, sponsorSignature],
+});
+```
+
+> **Warning:** The user must wait for the sponsor to set gas coins before signing, because gas coins are part of
+> the signed transaction data.
+
+### Address balance sponsorship
+
+When the sponsor pays from their address balance instead of specific coins, the flow is simpler
+because there are no coin object references to coordinate:
+
+```typescript
+// 1. User builds and signs the transaction first
+const tx = new Transaction();
+tx.setSender(userAddress);
+tx.setGasOwner(sponsorAddress);
+tx.setGasPayment([]); // empty array = use address balance for gas
+// ... add commands ...
+
+const bytes = await tx.build({ client: grpcClient });
+const { signature: userSignature } = await userKeypair.signTransaction(bytes);
+
+// 2. Sponsor signs (can happen asynchronously)
+const { signature: sponsorSignature } = await sponsorKeypair.signTransaction(bytes);
+
+// 3. Either party executes
+const result = await grpcClient.executeTransaction({
+	transaction: bytes,
+	signatures: [userSignature, sponsorSignature],
+});
+```
+
+The key advantage: the sender can sign before the sponsor, enabling simpler async flows. No need to
+coordinate gas coin selection.
+
+### Sending tokens in sponsored transactions
+
+When building sponsored transactions, set `useGasCoin: false` so the SDK doesn't try to split the
+gas coin (which belongs to the sponsor):
+
+```typescript
+
+const tx = new Transaction();
+
+// Send to address balance (preferred)
+tx.moveCall({
+	target: '0x2::balance::send_funds',
+	typeArguments: ['0x2::sui::SUI'],
+	arguments: [
+		tx.balance({ balance: 1_000_000_000n, useGasCoin: false }),
+		tx.pure.address('0xRecipientAddress'),
+	],
+});
+
+// Or send as a coin object
+tx.transferObjects([tx.coin({ balance: 1_000_000_000, useGasCoin: false })], '0xRecipientAddress');
+```

package/package.json

@@ -3,7 +3,7 @@
   "author": "Mysten Labs <build@mystenlabs.com>",
   "description": "Sui TypeScript API",
   "homepage": "https://sdk.mystenlabs.com",
-  "version": "2.16.3",
+  "version": "2.18.0",
   "license": "Apache-2.0",
   "sideEffects": false,
   "files": [
@@ -131,45 +131,45 @@
     "access": "public"
   },
   "devDependencies": {
-    "@0no-co/graphqlsp": "^1.15.2",
-    "@graphql-codegen/add": "^6.0.0",
-    "@graphql-codegen/cli": "^6.1.1",
-    "@graphql-codegen/typed-document-node": "^6.1.5",
-    "@graphql-codegen/typescript": "5.0.7",
-    "@graphql-codegen/typescript-document-nodes": "5.0.7",
-    "@graphql-codegen/typescript-operations": "^5.0.7",
-    "@grpc/grpc-js": "^1.13.3",
+    "@0no-co/graphqlsp": "^1.17.0",
+    "@graphql-codegen/add": "^7.0.1",
+    "@graphql-codegen/cli": "^7.1.2",
+    "@graphql-codegen/typed-document-node": "^7.0.3",
+    "@graphql-codegen/typescript": "6.0.2",
+    "@graphql-codegen/typescript-document-nodes": "6.0.1",
+    "@graphql-codegen/typescript-operations": "^6.0.3",
+    "@grpc/grpc-js": ">=1.14.4",
     "@parcel/watcher": "^2.5.4",
     "@protobuf-ts/grpc-transport": "^2.11.1",
-    "@types/node": "^25.0.8",
+    "@types/node": "^25.9.3",
     "@types/tmp": "^0.2.6",
     "cross-env": "^10.1.0",
     "graphql-config": "^5.1.5",
-    "msw": "^2.12.7",
-    "tmp": "^0.2.5",
+    "msw": "^2.14.6",
+    "tmp": "^0.2.7",
     "ts-retry-promise": "^0.8.1",
-    "typescript": "^5.9.3",
-    "vite": "^8.0.5",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16",
     "vite-tsconfig-paths": "^6.0.4",
-    "vitest": "^4.0.17",
-    "wait-on": "^9.0.3"
+    "vitest": "^4.1.8",
+    "wait-on": "^9.0.10"
   },
   "dependencies": {
     "@graphql-typed-document-node/core": "^3.2.0",
-    "@noble/curves": "^2.0.1",
-    "@noble/hashes": "^2.0.1",
+    "@noble/curves": "^2.2.0",
+    "@noble/hashes": "^2.2.0",
     "@protobuf-ts/grpcweb-transport": "^2.11.1",
     "@protobuf-ts/runtime": "^2.11.1",
     "@protobuf-ts/runtime-rpc": "^2.11.1",
-    "@scure/base": "^2.0.0",
-    "@scure/bip32": "^2.0.1",
-    "@scure/bip39": "^2.0.1",
-    "gql.tada": "^1.9.0",
-    "graphql": "^16.12.0",
+    "@scure/base": "^2.2.0",
+    "@scure/bip32": "^2.2.0",
+    "@scure/bip39": "^2.2.0",
+    "gql.tada": "^1.10.1",
+    "graphql": "^16.14.2",
     "poseidon-lite": "0.2.1",
-    "valibot": "^1.2.0",
-    "@mysten/bcs": "^2.0.5",
-    "@mysten/utils": "^0.3.3"
+    "valibot": "^1.4.1",
+    "@mysten/utils": "^0.4.0",
+    "@mysten/bcs": "^2.1.0"
   },
   "scripts": {
     "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
@@ -178,7 +178,7 @@
     "codegen:version": "node genversion.mjs",
     "codegen:grpc": "rm -rf src/grpc/proto && mkdir src/grpc/proto && pnpm codegen:grpc-protoc && pnpm codegen:grpc-header && pnpm codegen:grpc-extensions && pnpm codegen:grpc-types",
     "codegen:grpc-types": "tsx scripts/generate-grpc-types.ts",
-    "codegen:grpc-protoc": "protoc --ts_out ./src/grpc/proto --ts_opt force_server_none --ts_opt optimize_code_size --ts_opt ts_nocheck -I ../../../sui-apis/proto -I ../../../sui-apis/proto ../../../sui-apis/proto/sui/rpc/v2/*.proto ../../../sui-apis/proto/google/*/*.proto",
+    "codegen:grpc-protoc": "protoc --ts_out ./src/grpc/proto --ts_opt force_server_none --ts_opt optimize_code_size --ts_opt ts_nocheck -I ../../../sui-apis/proto -I ../../../sui/crates/sui-fork/proto ../../../sui-apis/proto/sui/rpc/v2/*.proto ../../../sui-apis/proto/google/*/*.proto ../../../sui/crates/sui-fork/proto/sui/forking/v1alpha/*.proto",
     "codegen:grpc-header": "find src/grpc/proto -type f -exec sh -c 'echo \"// Copyright (c) Mysten Labs, Inc.\\n// SPDX-License-Identifier: Apache-2.0\\n\" | cat - {} > temp && mv temp {}' \\;",
     "codegen:grpc-extensions": "find src/grpc/proto -name '*.ts' | xargs sed -i '' -E 's/from \"(\\.[^\"]+)\"/from \"\\1.js\"/g'",
     "build": "rm -rf dist && node genversion.mjs && tsc --noEmit && tsdown",

package/src/graphql/generated/queries.ts

@@ -1991,6 +1991,14 @@ export type Input = {
   ix?: Maybe<Scalars['Int']['output']>;
 };
 
+/** An enum that specifies the intent scope for signature verification. */
+export enum IntentScope {
+  /** Indicates that the bytes are to be parsed as a personal message. */
+  PersonalMessage = 'PERSONAL_MESSAGE',
+  /** Indicates that the bytes are to be parsed as transaction data bytes. */
+  TransactionData = 'TRANSACTION_DATA'
+}
+
 /** Information used by a package to link to a specific version of its dependency. */
 export type Linkage = {
   __typename?: 'Linkage';
@@ -3706,7 +3714,9 @@ export type Query = {
   /** The network's genesis checkpoint digest (uniquely identifies the network), Base58-encoded. */
   chainIdentifier: Scalars['String']['output'];
   /**
-   * Fetch a checkpoint by its sequence number, or the latest checkpoint if no sequence number is provided.
+   * Fetch a checkpoint by its sequence number or digest, or the latest checkpoint if neither is provided.
+   *
+   * It is an error to specify both `sequenceNumber` and `digest`.
    *
    * Returns `null` if the checkpoint does not exist in the store, either because it never existed or because it was pruned.
    */
@@ -3882,6 +3892,22 @@ export type Query = {
    * Fails if the type is malformed, returns `null` if a type mentioned does not exist.
    */
   type?: Maybe<MoveType>;
+  /**
+   * Verify a signature is from the given `author`.
+   *
+   * Supports all signature types: Ed25519, Secp256k1, Secp256r1, MultiSig, ZkLogin, and
+   * Passkey.
+   *
+   * Returns successfully if the signature is valid. If the signature is invalid, returns an
+   * error with the reason for the failure.
+   *
+   * - `message` is either a serialized personal message or `TransactionData`, Base64-encoded.
+   * - `signature` is a serialized signature, also Base64-encoded.
+   * - `intentScope` indicates whether `message` is to be parsed as a personal message or
+   * `TransactionData`.
+   * - `author` is the signer's address.
+   */
+  verifySignature?: Maybe<SignatureVerifyResult>;
   /**
    * Verify a zkLogin signature is from the given `author`.
    *
@@ -3891,6 +3917,7 @@ export type Query = {
    * - `signature` is a serialized zkLogin signature, also Base64-encoded.
    * - `intentScope` indicates whether `bytes` are to be parsed as a personal message or `TransactionData`.
    * - `author` is the signer's address.
+   * @deprecated Use `verifySignature` instead, which supports all signature types.
    */
   verifyZkLoginSignature?: Maybe<ZkLoginVerifyResult>;
 };
@@ -3905,6 +3932,7 @@ export type QueryAddressArgs = {
 
 
 export type QueryCheckpointArgs = {
+  digest?: InputMaybe<Scalars['String']['input']>;
   sequenceNumber?: InputMaybe<Scalars['UInt53']['input']>;
 };
 
@@ -4084,6 +4112,14 @@ export type QueryTypeArgs = {
 };
 
 
+export type QueryVerifySignatureArgs = {
+  author: Scalars['SuiAddress']['input'];
+  intentScope: IntentScope;
+  message: Scalars['Base64']['input'];
+  signature: Scalars['Base64']['input'];
+};
+
+
 export type QueryVerifyZkLoginSignatureArgs = {
   author: Scalars['SuiAddress']['input'];
   bytes: Scalars['Base64']['input'];
@@ -4308,6 +4344,13 @@ export type SharedInput = {
 /** The structured details of a signature, varying by scheme. */
 export type SignatureScheme = Ed25519Signature | MultisigSignature | PasskeySignature | Secp256K1Signature | Secp256R1Signature | ZkLoginSignature;
 
+/** The result of signature verification. */
+export type SignatureVerifyResult = {
+  __typename?: 'SignatureVerifyResult';
+  /** Whether the signature was verified successfully. */
+  success?: Maybe<Scalars['Boolean']['output']>;
+};
+
 /** The result of simulating a transaction, including the predicted effects. */
 export type SimulationResult = {
   __typename?: 'SimulationResult';
@@ -4435,6 +4478,8 @@ export type TransactionEffects = {
   transaction?: Maybe<Transaction>;
   /** The unchanged consensus-managed objects that were referenced by this transaction. */
   unchangedConsensusObjects?: Maybe<UnchangedConsensusObjectConnection>;
+  /** The schema version of the effects struct. */
+  version?: Maybe<Scalars['Int']['output']>;
 };
 
 

package/src/graphql/generated/schema.graphql

@@ -1808,6 +1808,20 @@ type Input {
 }
 
 
+"""
+An enum that specifies the intent scope for signature verification.
+"""
+enum IntentScope {
+	"""
+	Indicates that the bytes are to be parsed as transaction data bytes.
+	"""
+	TRANSACTION_DATA
+	"""
+	Indicates that the bytes are to be parsed as a personal message.
+	"""
+	PERSONAL_MESSAGE
+}
+
 """
 Arbitrary JSON data.
 """
@@ -3486,11 +3500,13 @@ type Query {
 	"""
 	chainIdentifier: String!
 	"""
-	Fetch a checkpoint by its sequence number, or the latest checkpoint if no sequence number is provided.
+	Fetch a checkpoint by its sequence number or digest, or the latest checkpoint if neither is provided.
+	
+	It is an error to specify both `sequenceNumber` and `digest`.
 	
 	Returns `null` if the checkpoint does not exist in the store, either because it never existed or because it was pruned.
 	"""
-	checkpoint(sequenceNumber: UInt53): Checkpoint
+	checkpoint(sequenceNumber: UInt53, digest: String): Checkpoint
 	"""
 	Paginate checkpoints in the network, optionally bounded to checkpoints in the given epoch.
 	"""
@@ -3681,6 +3697,22 @@ type Query {
 	"""
 	type(type: String!): MoveType
 	"""
+	Verify a signature is from the given `author`.
+	
+	Supports all signature types: Ed25519, Secp256k1, Secp256r1, MultiSig, ZkLogin, and
+	Passkey.
+	
+	Returns successfully if the signature is valid. If the signature is invalid, returns an
+	error with the reason for the failure.
+	
+	- `message` is either a serialized personal message or `TransactionData`, Base64-encoded.
+	- `signature` is a serialized signature, also Base64-encoded.
+	- `intentScope` indicates whether `message` is to be parsed as a personal message or
+	`TransactionData`.
+	- `author` is the signer's address.
+	"""
+	verifySignature(message: Base64!, signature: Base64!, intentScope: IntentScope!, author: SuiAddress!): SignatureVerifyResult
+	"""
 	Verify a zkLogin signature is from the given `author`.
 	
 	Returns successfully if the signature is valid. If the signature is invalid, returns an error with the reason for the failure.
@@ -3690,7 +3722,7 @@ type Query {
 	- `intentScope` indicates whether `bytes` are to be parsed as a personal message or `TransactionData`.
 	- `author` is the signer's address.
 	"""
-	verifyZkLoginSignature(bytes: Base64!, signature: Base64!, intentScope: ZkLoginIntentScope!, author: SuiAddress!): ZkLoginVerifyResult
+	verifyZkLoginSignature(bytes: Base64!, signature: Base64!, intentScope: ZkLoginIntentScope!, author: SuiAddress!): ZkLoginVerifyResult @deprecated(reason: "Use `verifySignature` instead, which supports all signature types.")
 }
 
 """
@@ -3976,6 +4008,16 @@ The structured details of a signature, varying by scheme.
 """
 union SignatureScheme = Ed25519Signature | Secp256K1Signature | Secp256R1Signature | MultisigSignature | ZkLoginSignature | PasskeySignature
 
+"""
+The result of signature verification.
+"""
+type SignatureVerifyResult {
+	"""
+	Whether the signature was verified successfully.
+	"""
+	success: Boolean
+}
+
 """
 The result of simulating a transaction, including the predicted effects.
 """
@@ -4194,6 +4236,10 @@ type TransactionEffects {
 	The unchanged consensus-managed objects that were referenced by this transaction.
 	"""
 	unchangedConsensusObjects(first: Int, after: String, last: Int, before: String): UnchangedConsensusObjectConnection
+	"""
+	The schema version of the effects struct.
+	"""
+	version: Int
 }
 
 input TransactionFilter {