@mysten/sui 2.28.0 → 2.30.0

package/docs/transactions/offline.md

@@ -2,69 +2,132 @@
 
 > Build transactions without a network connection
 
-Normally the SDK resolves object versions, estimates gas, and fills in other details by querying the
-network. For offline building of backend services, air-gapped signing, or pre-built transactions,
-you must provide this information yourself. See also the Sui documentation on
+Normally `build()` queries the network to resolve object versions, resolve intents like `tx.coin()`,
+fetch the gas price, estimate the gas budget, pick gas coins, and set an expiration when gas is paid
+from address balance. To build without a client, provide that information yourself. See also the Sui
+documentation on
 [offline signing](https://docs.sui.io/guides/developer/transactions/transaction-auth/offline-signing)
 for the protocol-level details.
 
-## Transactions without owned object inputs
+## Building only the transaction kind
 
-When your transaction only uses shared objects, party objects, and/or address balance withdrawals,
-there are no owned object versions to look up. Use `tx.withdrawal()` directly instead of `tx.coin()`
-or `coinWithBalance` because they require a client to resolve coin objects at build time.
+If the next step only needs the inputs and commands (for example, a sponsor or a backend that fills
+in gas), build with `onlyTransactionKind`. Sender, gas data, and expiration are left out:
 
 ```typescript
 
 const tx = new Transaction();
-
-// Use tx.withdrawal() + coin::redeem_funds to withdraw from address balance.
-// No coin object lookups needed — fully offline.
-const [coin] = tx.moveCall({
-	target: '0x2::coin::redeem_funds',
-	typeArguments: ['0x2::sui::SUI'],
-	arguments: [tx.withdrawal({ amount: 1_000_000_000 })],
+tx.moveCall({
+	target: '0xPackage::module::function',
+	arguments: [tx.pure.u64(100)],
 });
-tx.transferObjects([coin], '0xRecipientAddress');
 
-// Shared/party objects only need objectId + initialSharedVersion (both stable)
+const kindBytes = await tx.build({ onlyTransactionKind: true });
+```
+
+Inputs and intents still need to be resolved. Use full object references, `tx.withdrawal()`, or
+[`assumeSufficientAddressBalances`](#coin-and-balance-intents) so nothing needs a lookup.
+
+## Building full transaction bytes
+
+A full offline build needs the sender and all gas data:
+
+| Method            | Description                                                     |
+| ----------------- | --------------------------------------------------------------- |
+| `setSender()`     | The address executing the transaction                           |
+| `setGasPrice()`   | Reference gas price (query `getReferenceGasPrice()` beforehand) |
+| `setGasBudget()`  | Maximum gas to spend (in MIST). Estimating it requires a client |
+| `setGasPayment()` | Coin object references, or `[]` to pay gas from address balance |
+| `setGasOwner()`   | Only for sponsored transactions. Defaults to the sender         |
+
+### Paying gas from address balance
+
+With `setGasPayment([])`, gas is paid from the gas owner's SUI address balance. Nothing ties the
+transaction to a specific object version, so it also needs a `ValidDuring` expiration for replay
+protection:
+
+```typescript
+
+// Look these up before going offline
+const referenceGasPrice = 1000n;
+const currentEpoch = 100;
+const chainIdentifier = 'Base58ChainIdentifier'; // from getChainIdentifier()
+
+const tx = new Transaction();
+
+// FundsWithdrawal inputs contain the amount and type, so no object lookup is needed
 tx.moveCall({
-	target: '0xPackage::module::function',
-	arguments: [
-		tx.sharedObjectRef({
-			objectId: '0xSharedObjectId',
-			initialSharedVersion: '1',
-			mutable: true,
-		}),
-	],
+	target: '0x2::balance::send_funds',
+	typeArguments: ['0x2::sui::SUI'],
+	arguments: [tx.withdrawal({ amount: 1_000_000_000 }), tx.pure.address('0xRecipientAddress')],
 });
 
-// Required configuration for all offline builds
 tx.setSender('0xSenderAddress');
-tx.setGasPrice(1000); // query getReferenceGasPrice() beforehand, or use a known value
+tx.setGasPrice(referenceGasPrice);
 tx.setGasBudget(50_000_000);
-tx.setGasPayment([]); // empty array = pay gas from address balance
+tx.setGasPayment([]);
 
-// Expiration is required when there are no owned objects for gas or inputs
 tx.setExpiration({
 	ValidDuring: {
-		minEpoch: 100, // current epoch
-		maxEpoch: 101, // current epoch + 1
+		minEpoch: currentEpoch,
+		maxEpoch: currentEpoch + 1,
 		minTimestamp: null,
 		maxTimestamp: null,
-		chain: 'mainnet', // or 'testnet', 'devnet'
-		nonce: 0,
+		chain: chainIdentifier,
+		// Must be unique for each transaction in the validity window, including across restarts
+		nonce: await nonceStore.next(),
 	},
 });
 
-// Build without a client
 const bytes = await tx.build();
 ```
 
-This enables fully stateless construction. You only need the sender address, reference gas price,
-epoch, and chain identifier.
+Two otherwise-identical transactions with the same nonce have the same digest, and the second one is
+rejected as a duplicate. Use a counter that survives restarts, not a hard-coded value.
+
+The address balance needs to cover the gas budget on top of any withdrawals. Don't add the budget to
+the withdrawal amount.
+
+`{ Epoch: n }` expiration does not provide replay protection. Use `ValidDuring`.
 
-## Party objects
+### Paying gas with coin objects
+
+Gas coins need an exact version and digest. Other SUI can still come from address balance:
+
+```typescript
+
+const tx = new Transaction();
+tx.moveCall({
+	target: '0x2::balance::send_funds',
+	typeArguments: ['0x2::sui::SUI'],
+	arguments: [
+		tx.balance({ balance: 1_000_000, useGasCoin: false }),
+		tx.pure.address('0xRecipientAddress'),
+	],
+});
+
+tx.setSender('0xSenderAddress');
+tx.setGasPrice(1000);
+tx.setGasBudget(50_000_000);
+tx.setGasPayment([{ objectId: '0xGasCoinId', version: '3', digest: 'Base58GasCoinDigest' }]);
+
+// assumeSufficientAddressBalances resolves tx.balance() without a client (see below)
+const bytes = await tx.build({ assumeSufficientAddressBalances: true });
+```
+
+## Object inputs
+
+### Shared and party objects
+
+Shared objects only need `objectId` and `initialSharedVersion`, both of which are stable:
+
+```typescript
+tx.sharedObjectRef({
+	objectId: '0xSharedObjectId',
+	initialSharedVersion: '1',
+	mutable: true,
+});
+```
 
 Party objects are address-owned but consensus-versioned, with per-address permissions. They are
 referenced the same way as shared objects:
@@ -83,12 +146,11 @@ Key properties for offline building:
   becomes a party object
 - **Enable pipelining**: Submit multiple transactions on the same party object without waiting for
   each one to finalize
-- **Cannot be used for gas**: Use address balance for gas payment (`setGasPayment([])`)
+- **Cannot be used for gas**: Pay gas from address balance or with a SUI coin object
 
-## Transactions with owned object inputs
+### Owned and immutable objects
 
-When your transaction uses owned or immutable objects, you must provide the exact version and digest
-for each one:
+Owned and immutable objects need the exact version and digest:
 
 ```typescript
 
@@ -122,71 +184,58 @@ tx.moveCall({
 		}),
 	],
 });
-
-// Gas payment with specific coin objects
-tx.setGasPayment([{ objectId: '0xGasCoinId', version: '3', digest: 'jkl012...' }]);
-
-tx.setSender('0xSenderAddress');
-tx.setGasPrice(1000);
-tx.setGasBudget(50_000_000);
-
-const bytes = await tx.build();
 ```
 
-## Required configuration for all offline builds
+## Coin and balance intents
 
-Every offline-built transaction must have the following:
+`tx.coin()` and `tx.balance()` normally look up the sender's address balance and coin objects. Pass
+`assumeSufficientAddressBalances` to skip the lookups and withdraw from address balance instead:
 
-| Method            | Description                                                     |
-| ----------------- | --------------------------------------------------------------- |
-| `setSender()`     | The address executing the transaction                           |
-| `setGasPrice()`   | Reference gas price (query `getReferenceGasPrice()` beforehand) |
-| `setGasBudget()`  | Maximum gas to spend (in MIST)                                  |
-| `setGasPayment()` | Coin object references, or `[]` for address balance             |
+```typescript
 
-### Expiration
+const tx = new Transaction();
+tx.moveCall({
+	target: '0x2::balance::send_funds',
+	typeArguments: ['0xPackage::module::TOKEN'],
+	arguments: [
+		tx.balance({ type: '0xPackage::module::TOKEN', balance: 1_000_000 }),
+		tx.pure.address('0xRecipientAddress'),
+	],
+});
 
-Set an expiration when your transaction uses no owned objects for gas or inputs. This applies when
-you use address balances for gas (`setGasPayment([])`) with only shared and party object inputs:
+// The sender is still required, since the withdrawal comes from its address balance
+tx.setSender('0xSenderAddress');
 
-```typescript
-tx.setExpiration({
-	ValidDuring: {
-		minEpoch: 100, // current epoch
-		maxEpoch: 101, // typically current epoch + 1
-		minTimestamp: null,
-		maxTimestamp: null,
-		chain: 'mainnet',
-		nonce: 0, // increment for multiple transactions in the same epoch
-	},
+const kindBytes = await tx.build({
+	onlyTransactionKind: true,
+	assumeSufficientAddressBalances: true,
 });
 ```
 
-You can also use epoch-based expiration:
+> **Warning:** Nothing is checked. The transaction builds, then fails at execution if the address balance doesn't
+> cover it.
 
-```typescript
-tx.setExpiration({ Epoch: 100 });
-```
+SUI intents withdraw from address balance too, whether or not the transaction also uses `tx.gas`.
+This matches an online build when the address balance is sufficient. Mixing default and
+`useGasCoin: false` SUI intents in one transaction is still an error.
 
-> **Note:** When building with a client, the SDK sets expiration automatically. You only need the manual
-> configuration above for fully offline builds.
+On a full build, the option also sets an unset gas payment to `[]`, but only when nothing else needs
+a client, the transaction doesn't use `tx.gas`, and a `ValidDuring` or `Validity` expiration is
+already set. Sender, gas price, and gas budget still need to be provided. Once set, the empty
+payment is part of the transaction, the same as calling `setGasPayment([])`.
 
 ## Serialization
 
-### Building to bytes
+`toJSON()` resolves async thunks and intents but does not fill in gas or object versions. Pass
+`supportedIntents` to keep an intent for another system to resolve:
 
 ```typescript
-// Build to BCS bytes (Uint8Array) — fully offline, all data must be provided
-const bytes = await tx.build();
-
-// Build with a client — only makes network requests when there is unresolved data to look up
-const bytes = await tx.build({ client: grpcClient });
-```
+// Intents are resolved, so tx.coin() needs a client or assumeSufficientAddressBalances
+const json = await tx.toJSON({ assumeSufficientAddressBalances: true });
+const restored = Transaction.from(json);
 
-### Converting bytes back to a Transaction
-
-```typescript
-const tx = Transaction.from(bytes);
+// Or keep tx.coin() intents for the receiver to resolve
+const jsonWithIntents = await tx.toJSON({ supportedIntents: ['CoinWithBalance'] });
 ```
 
-This works with BCS byte arrays, base64-encoded strings, and JSON strings (from `toJSON()`).
+`Transaction.from()` accepts JSON strings, BCS bytes, and base64-encoded BCS.

package/package.json

@@ -3,7 +3,7 @@
   "author": "Mysten Labs <build@mystenlabs.com>",
   "description": "Sui TypeScript API",
   "homepage": "https://sdk.mystenlabs.com",
-  "version": "2.28.0",
+  "version": "2.30.0",
   "license": "Apache-2.0",
   "sideEffects": false,
   "files": [
@@ -151,7 +151,7 @@
     "typescript": "^7.0.2",
     "vite": "^8.2.1",
     "vite-tsconfig-paths": "^6.0.4",
-    "vitest": "^4.1.10",
+    "vitest": "^4.1.11",
     "wait-on": "^9.1.0"
   },
   "dependencies": {

package/src/client/core-resolver.ts

@@ -17,6 +17,7 @@ import { getPureBcsSchema, isTxContext } from '../transactions/serializer.js';
 import type { TransactionDataBuilder } from '../transactions/TransactionData.js';
 import { chunk } from '@mysten/utils';
 import type { BuildTransactionOptions } from '../transactions/index.js';
+import { transactionUsesGasCoin } from '../transactions/resolution-utils.js';
 
 // The maximum objects that can be fetched at once using multiGetObjects.
 const MAX_OBJECTS_PER_FETCH = 50;
@@ -54,19 +55,13 @@ export async function coreClientResolveTransactionPlugin(
 	next: () => Promise<void>,
 ) {
 	const client = getClient(options);
-
 	const needsGasPrice = !options.onlyTransactionKind && !transactionData.gasData.price;
 	const needsPayment = !options.onlyTransactionKind && !transactionData.gasData.payment;
 	const gasPayer = transactionData.gasData.owner ?? transactionData.sender;
 
-	let usesGasCoin = false;
+	const usesGasCoin = transactionUsesGasCoin(transactionData);
 	let withdrawals = 0n;
 
-	transactionData.mapArguments((arg) => {
-		if (arg.$kind === 'GasCoin') usesGasCoin = true;
-		return arg;
-	});
-
 	const normalizedGasPayer = gasPayer ? normalizeSuiAddress(gasPayer) : null;
 	for (const input of transactionData.inputs) {
 		if (input.$kind !== 'FundsWithdrawal' || !normalizedGasPayer) continue;

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/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/Transaction.ts

@@ -37,7 +37,6 @@ import {
 	coinWithBalance,
 	createBalance,
 } from './intents/CoinWithBalance.js';
-import type { ClientWithCoreApi } from '../client/core.js';
 
 export type TransactionObjectArgument =
 	| Exclude<InferInput<typeof ArgumentSchema>, { Input: unknown; type?: 'pure' }>
@@ -802,9 +801,7 @@ export class Transaction {
 
 	/** Derive transaction digest */
 	async getDigest(
-		options: {
-			client?: ClientWithCoreApi;
-		} = {},
+		options: Pick<BuildTransactionOptions, 'client' | 'assumeSufficientAddressBalances'> = {},
 	): Promise<string> {
 		await this.prepareForSerialization(options);
 		await this.#prepareBuild(options);