@mysten/sui 2.28.0 → 2.29.0

package/dist/transactions/data/v2.d.mts

@@ -1,12 +1,12 @@
 import { EnumInputShape } from "@mysten/bcs";
-import * as valibot1337 from "valibot";
+import * as valibot0 from "valibot";
 import { GenericSchema, InferOutput } from "valibot";
 
 //#region src/transactions/data/v2.d.ts
-declare const SerializedTransactionDataV2Schema: valibot1337.ObjectSchema<{
-  readonly version: valibot1337.LiteralSchema<2, undefined>;
-  readonly sender: valibot1337.NullishSchema<valibot1337.SchemaWithPipe<readonly [valibot1337.StringSchema<undefined>, valibot1337.TransformAction<string, string>, valibot1337.CheckAction<string, undefined>]>, undefined>;
-  readonly expiration: valibot1337.NullishSchema<GenericSchema<EnumInputShape<{
+declare const SerializedTransactionDataV2Schema: valibot0.ObjectSchema<{
+  readonly version: valibot0.LiteralSchema<2, undefined>;
+  readonly sender: valibot0.NullishSchema<valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<undefined>, valibot0.TransformAction<string, string>, valibot0.CheckAction<string, undefined>]>, undefined>;
+  readonly expiration: valibot0.NullishSchema<GenericSchema<EnumInputShape<{
     None: true;
     Epoch: string | number;
     ValidDuring: {
@@ -30,17 +30,17 @@ declare const SerializedTransactionDataV2Schema: valibot1337.ObjectSchema<{
       nonce: number;
     };
   }>>, undefined>;
-  readonly gasData: valibot1337.ObjectSchema<{
-    readonly budget: valibot1337.NullableSchema<valibot1337.SchemaWithPipe<readonly [valibot1337.UnionSchema<[valibot1337.StringSchema<undefined>, valibot1337.SchemaWithPipe<readonly [valibot1337.NumberSchema<undefined>, valibot1337.IntegerAction<number, undefined>]>], undefined>, valibot1337.CheckAction<string | number, "Invalid u64">]>, undefined>;
-    readonly price: valibot1337.NullableSchema<valibot1337.SchemaWithPipe<readonly [valibot1337.UnionSchema<[valibot1337.StringSchema<undefined>, valibot1337.SchemaWithPipe<readonly [valibot1337.NumberSchema<undefined>, valibot1337.IntegerAction<number, undefined>]>], undefined>, valibot1337.CheckAction<string | number, "Invalid u64">]>, undefined>;
-    readonly owner: valibot1337.NullableSchema<valibot1337.SchemaWithPipe<readonly [valibot1337.StringSchema<undefined>, valibot1337.TransformAction<string, string>, valibot1337.CheckAction<string, undefined>]>, undefined>;
-    readonly payment: valibot1337.NullableSchema<valibot1337.ArraySchema<valibot1337.ObjectSchema<{
-      readonly objectId: valibot1337.SchemaWithPipe<readonly [valibot1337.StringSchema<undefined>, valibot1337.TransformAction<string, string>, valibot1337.CheckAction<string, undefined>]>;
-      readonly version: valibot1337.SchemaWithPipe<readonly [valibot1337.UnionSchema<[valibot1337.StringSchema<undefined>, valibot1337.SchemaWithPipe<readonly [valibot1337.NumberSchema<undefined>, valibot1337.IntegerAction<number, undefined>]>], undefined>, valibot1337.CheckAction<string | number, "Invalid u64">]>;
-      readonly digest: valibot1337.StringSchema<undefined>;
+  readonly gasData: valibot0.ObjectSchema<{
+    readonly budget: valibot0.NullableSchema<valibot0.SchemaWithPipe<readonly [valibot0.UnionSchema<[valibot0.StringSchema<undefined>, valibot0.SchemaWithPipe<readonly [valibot0.NumberSchema<undefined>, valibot0.IntegerAction<number, undefined>]>], undefined>, valibot0.CheckAction<string | number, "Invalid u64">]>, undefined>;
+    readonly price: valibot0.NullableSchema<valibot0.SchemaWithPipe<readonly [valibot0.UnionSchema<[valibot0.StringSchema<undefined>, valibot0.SchemaWithPipe<readonly [valibot0.NumberSchema<undefined>, valibot0.IntegerAction<number, undefined>]>], undefined>, valibot0.CheckAction<string | number, "Invalid u64">]>, undefined>;
+    readonly owner: valibot0.NullableSchema<valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<undefined>, valibot0.TransformAction<string, string>, valibot0.CheckAction<string, undefined>]>, undefined>;
+    readonly payment: valibot0.NullableSchema<valibot0.ArraySchema<valibot0.ObjectSchema<{
+      readonly objectId: valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<undefined>, valibot0.TransformAction<string, string>, valibot0.CheckAction<string, undefined>]>;
+      readonly version: valibot0.SchemaWithPipe<readonly [valibot0.UnionSchema<[valibot0.StringSchema<undefined>, valibot0.SchemaWithPipe<readonly [valibot0.NumberSchema<undefined>, valibot0.IntegerAction<number, undefined>]>], undefined>, valibot0.CheckAction<string | number, "Invalid u64">]>;
+      readonly digest: valibot0.StringSchema<undefined>;
     }, undefined>, undefined>, undefined>;
   }, undefined>;
-  readonly inputs: valibot1337.ArraySchema<GenericSchema<EnumInputShape<{
+  readonly inputs: valibot0.ArraySchema<GenericSchema<EnumInputShape<{
     Object: EnumInputShape<{
       ImmOrOwnedObject: {
         objectId: string;
@@ -85,7 +85,7 @@ declare const SerializedTransactionDataV2Schema: valibot1337.ObjectSchema<{
       };
     };
   }>>, undefined>;
-  readonly commands: valibot1337.ArraySchema<GenericSchema<EnumInputShape<{
+  readonly commands: valibot0.ArraySchema<GenericSchema<EnumInputShape<{
     MoveCall: {
       package: string;
       module: string;
@@ -184,7 +184,7 @@ declare const SerializedTransactionDataV2Schema: valibot1337.ObjectSchema<{
       };
     };
   }>>, undefined>;
-  readonly digest: valibot1337.OptionalSchema<valibot1337.NullableSchema<valibot1337.StringSchema<undefined>, undefined>, undefined>;
+  readonly digest: valibot0.OptionalSchema<valibot0.NullableSchema<valibot0.StringSchema<undefined>, undefined>, undefined>;
 }, undefined>;
 type SerializedTransactionDataV2 = InferOutput<typeof SerializedTransactionDataV2Schema>;
 //#endregion

package/dist/transactions/data/v2.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"v2.d.mts","names":[],"sources":["../../../src/transactions/data/v2.ts"],"mappings":";;;;;cAqJa,iCAAA,cAAiC,YAAA;EAAA,kBAQ5C,WAAA,CAAA,aAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEU,2BAAA,GAA8B,WAAA,QAAmB,iCAAA"}
+{"version":3,"file":"v2.d.mts","names":[],"sources":["../../../src/transactions/data/v2.ts"],"mappings":";;;;;cAqJa,iCAAA,WAAiC,YAAA;EAAA,kBAQ5C,QAAA,CAAA,aAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEU,2BAAA,GAA8B,WAAA,QAAmB,iCAAA"}

package/dist/version.mjs

@@ -1,5 +1,5 @@
 //#region src/version.ts
-const PACKAGE_VERSION = "2.28.0";
+const PACKAGE_VERSION = "2.29.0";
 
 //#endregion
 export { PACKAGE_VERSION };

package/dist/version.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"version.mjs","names":[],"sources":["../src/version.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n// This file is generated by genversion.mjs. Do not edit it directly.\n\nexport const PACKAGE_VERSION = '2.28.0';\n"],"mappings":";AAKA,MAAa,kBAAkB"}
+{"version":3,"file":"version.mjs","names":[],"sources":["../src/version.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n// This file is generated by genversion.mjs. Do not edit it directly.\n\nexport const PACKAGE_VERSION = '2.29.0';\n"],"mappings":";AAKA,MAAa,kBAAkB"}

package/dist/zklogin/bcs.d.mts

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

package/docs/clients/grpc.md

@@ -55,16 +55,39 @@ console.log(transaction.digest, result.protoJson);
 
 ## Transport options
 
-By default, `SuiGrpcClient` uses `GrpcWebFetchTransport` from
-[protobuf-ts](https://github.com/timostamm/protobuf-ts), which works in browsers and Node.js through
-the Fetch API. The `GrpcWebFetchTransport` class, `GrpcWebOptions` type, and `RpcTransport` type are
-re-exported from `@mysten/sui/grpc`, so you can configure a transport without adding
-`@protobuf-ts/*` as a direct dependency.
+By default, `SuiGrpcClient` uses `GrpcWebFetchTransport`, which works in browsers and Node.js
+through the Fetch API. `@mysten/sui/grpc` exports it alongside the `GrpcWebOptions` and
+`RpcTransport` types, and the `RpcError` class and `GrpcStatusCode` enum that gRPC failures use, so
+you can configure a transport and handle its errors without adding `@protobuf-ts/*` as a direct
+dependency.
+
+That class extends the transport of the same name from
+[protobuf-ts](https://github.com/timostamm/protobuf-ts) and fixes two defects in it:
+
+- It decodes status messages, rather than delivering them as `Object%20not%20found:%200x1`.
+- It codes a call that an abort ended from the reason the abort carried: `DEADLINE_EXCEEDED` for an
+  `AbortSignal.timeout`, the status on a reason carrying one, and `CANCELLED` otherwise. Upstream
+  reports all but a standard `AbortError` cancellation as `INTERNAL`.
+
+Build custom transports from this class. `SuiGrpcClient` uses a transport you pass it as given.
 
 ### gRPC-web transport (default)
 
-The default transport uses the gRPC-web protocol over HTTP/1.1 or HTTP/2. Pass
-`GrpcWebFetchTransport` options to customize it:
+The default transport uses the gRPC-web protocol over HTTP/1.1 or HTTP/2. `SuiGrpcClient` passes the
+`GrpcWebOptions` it is given to the transport it builds, so most configuration needs no transport of
+your own. The one exception is `abort`: Core API calls each carry their own signal, so a client-wide
+one is not forwarded.
+
+```typescript
+
+const client = new SuiGrpcClient({
+	network: 'testnet',
+	baseUrl: 'https://your-custom-grpc-endpoint.com',
+	format: 'binary', // default is 'text' (base64-encoded)
+});
+```
+
+Build the transport yourself to share one between clients, or to subclass it:
 
 ```typescript
 
@@ -228,6 +251,7 @@ const result = parseGrpcTransactionResponse(response.transaction!, {
 | `parseGrpcTransactionResponse`                            | Raw `ExecutedTransaction` to the unified result shape |
 | `parseGrpcSimulateTransactionResponse`                    | Raw simulation response to the unified result shape   |
 | `GrpcWebFetchTransport`, `GrpcWebOptions`, `RpcTransport` | Configuring a [transport](#transport-options)         |
+| `RpcError`, `GrpcStatusCode`                              | Narrowing and coding gRPC failures                    |
 | `SuiGrpcClientOptions`, `GrpcTransactionInclude`, …       | Typing your own wrappers around the client            |
 | `isSuiGrpcClient`                                         | Type guard for narrowing an unknown client            |
 

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.29.0",
   "license": "Apache-2.0",
   "sideEffects": false,
   "files": [

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

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