@meshconnect/uwc-core 2.6.0 → 2.7.0-snapshot.c392d3d

package/src/observability/telemetry.test.ts

@@ -867,6 +867,89 @@ describe('normalizeEvent', () => {
     expect(out.connectAttemptId).toBe('attempt-1')
   })
 
+  it('forwards a scrubbed providerReason on walletFailed', () => {
+    const out = normalizeEvent(
+      'walletFailed',
+      {
+        handoffId: 'h-1',
+        operation: 'sendTransaction',
+        durationMs: 1,
+        error: {
+          type: 'unknown',
+          message: 'An unknown RPC error occurred.',
+          providerReason:
+            'cancelled for 0x1234567890123456789012345678901234567890'
+        },
+        connectionMode: 'injected',
+        timedOut: false
+      },
+      SDK_SESSION,
+      NOW
+    )
+    expect(out.error?.providerReason).toContain('cancelled for ')
+    expect(out.error?.providerReason).not.toContain(
+      '1234567890123456789012345678901234567890'
+    )
+  })
+
+  it('redacts an address in a long providerReason before capping it', () => {
+    const address = '0x1234567890123456789012345678901234567890'
+    const out = normalizeEvent(
+      'walletFailed',
+      {
+        handoffId: 'h-1',
+        operation: 'sendTransaction',
+        durationMs: 1,
+        error: {
+          type: 'unknown',
+          message: 'An unknown RPC error occurred.',
+          // The address straddles the 500-character cap.
+          providerReason: `${'x'.repeat(480)} ${address}`
+        },
+        connectionMode: 'injected',
+        timedOut: false
+      },
+      SDK_SESSION,
+      NOW
+    )
+    expect(out.error?.providerReason).not.toContain('0x1234567890')
+    expect(out.error?.providerReason).toContain('0x[redacted-hex]')
+  })
+
+  it('omits providerReason from the record when the error has none', () => {
+    const out = normalizeEvent(
+      'walletFailed',
+      {
+        handoffId: 'h-1',
+        operation: 'sendTransaction',
+        durationMs: 1,
+        error: { type: 'unknown', message: 'failed' },
+        connectionMode: 'injected',
+        timedOut: false
+      },
+      SDK_SESSION,
+      NOW
+    )
+    expect(out.error).toEqual({ type: 'unknown', message: 'failed' })
+  })
+
+  it('forwards providerReason on the error event too', () => {
+    const out = normalizeEvent(
+      'error',
+      {
+        error: {
+          type: 'unknown',
+          message: 'failed',
+          providerReason: 'cancelled'
+        },
+        operation: 'sendTransaction'
+      },
+      SDK_SESSION,
+      NOW
+    )
+    expect(out.error?.providerReason).toBe('cancelled')
+  })
+
   it('does not expose a stray connectAttemptId on data-bearing non-connect events', () => {
     const out = normalizeEvent(
       'error',

package/src/observability/telemetry.ts

@@ -52,6 +52,20 @@ function capNetworkMismatch(
   }
 }
 
+/**
+ * Egress shape for a wallet error. `providerReason` is wallet-controlled text, so
+ * it gets the same scrubber as `message` and is omitted when absent.
+ */
+function toTelemetryError(error: WalletError): WalletError {
+  return {
+    type: error.type,
+    message: scrubMessage(error.message),
+    ...(error.providerReason
+      ? { providerReason: scrubMessage(error.providerReason) }
+      : {})
+  }
+}
+
 /**
  * A normalized, PII-safe telemetry record derived from a `UWCEventMap` event.
  *
@@ -109,6 +123,8 @@ export interface UWCTelemetryEvent {
   targetAlreadyActive?: boolean | undefined
   /** connect only: a `silentOnly` attempt — tells a silent restore from a tapped connect. */
   silentOnly?: boolean | undefined
+  /** connect only: how the connect network was chosen — explicit, detected, or catalog order. */
+  networkSelection?: 'explicit' | 'detected' | 'catalogOrder' | undefined
   /** Non-success outcomes: stringified error code when reliably known. */
   errorCode?: string | undefined
   /** Non-success outcomes: coarse cause bucket. `unknown` when not classifiable. */
@@ -434,7 +450,7 @@ function buildTelemetryEvent<K extends UWCEventName>(
       return {
         ...base,
         operation: d.operation,
-        error: { type: d.error.type, message: scrubMessage(d.error.message) },
+        error: toTelemetryError(d.error),
         // Telemetry-only classification — undefined for ordinary errors, set for
         // pre-wallet validation failures (e.g. no_common_network) that never
         // reach the handoff funnel.
@@ -459,7 +475,8 @@ function buildTelemetryEvent<K extends UWCEventName>(
         walletFlowType: d.walletFlowType,
         platform: d.platform,
         targetAlreadyActive: d.targetAlreadyActive,
-        silentOnly: d.silentOnly
+        silentOnly: d.silentOnly,
+        networkSelection: d.networkSelection
       }
     }
     case 'walletSucceeded': {
@@ -478,6 +495,7 @@ function buildTelemetryEvent<K extends UWCEventName>(
         timeoutMs: d.timeoutMs,
         targetAlreadyActive: d.targetAlreadyActive,
         silentOnly: d.silentOnly,
+        networkSelection: d.networkSelection,
         backgroundedMs: d.backgroundedMs,
         backgroundCount: d.backgroundCount,
         relayDropCount: d.relayDropCount,
@@ -500,12 +518,11 @@ function buildTelemetryEvent<K extends UWCEventName>(
         timeoutMs: d.timeoutMs,
         targetAlreadyActive: d.targetAlreadyActive,
         silentOnly: d.silentOnly,
+        networkSelection: d.networkSelection,
         errorCode: d.errorCode,
         failureKind: d.failureKind,
         source: d.source,
-        error: d.error
-          ? { type: d.error.type, message: scrubMessage(d.error.message) }
-          : undefined,
+        error: d.error ? toTelemetryError(d.error) : undefined,
         backgroundedMs: d.backgroundedMs,
         backgroundCount: d.backgroundCount,
         relayDropCount: d.relayDropCount
@@ -526,6 +543,7 @@ function buildTelemetryEvent<K extends UWCEventName>(
         timeoutMs: d.timeoutMs,
         targetAlreadyActive: d.targetAlreadyActive,
         silentOnly: d.silentOnly,
+        networkSelection: d.networkSelection,
         backgroundedMs: d.backgroundedMs,
         backgroundCount: d.backgroundCount,
         relayDropCount: d.relayDropCount
@@ -562,10 +580,11 @@ function buildTelemetryEvent<K extends UWCEventName>(
         timeoutMs: d.timeoutMs,
         targetAlreadyActive: d.targetAlreadyActive,
         silentOnly: d.silentOnly,
+        networkSelection: d.networkSelection,
         errorCode: d.errorCode,
         failureKind: d.failureKind,
         source: d.source,
-        error: { type: d.error.type, message: scrubMessage(d.error.message) },
+        error: toTelemetryError(d.error),
         backgroundedMs: d.backgroundedMs,
         backgroundCount: d.backgroundCount,
         relayDropCount: d.relayDropCount
@@ -609,7 +628,7 @@ function buildTelemetryEvent<K extends UWCEventName>(
         ...base,
         connectionMode: d.connectionMode,
         namespace: d.namespace,
-        error: { type: d.error.type, message: scrubMessage(d.error.message) }
+        error: toTelemetryError(d.error)
       }
     }
     case 'secondarySolanaConnectSkipped': {
@@ -651,7 +670,7 @@ function buildTelemetryEvent<K extends UWCEventName>(
         namespace: d.namespace,
         source: 'bridge',
         failureKind: 'bridge_error',
-        error: { type: d.error.type, message: scrubMessage(d.error.message) }
+        error: toTelemetryError(d.error)
       }
     }
     case 'relayError': {
@@ -663,7 +682,7 @@ function buildTelemetryEvent<K extends UWCEventName>(
         connectionMode: 'walletConnect',
         source: 'provider',
         failureKind: 'network_error',
-        error: { type: d.error.type, message: scrubMessage(d.error.message) }
+        error: toTelemetryError(d.error)
       }
     }
     case 'relayErrorCapped':
@@ -684,7 +703,7 @@ function buildTelemetryEvent<K extends UWCEventName>(
         connectionMode: 'walletConnect',
         source: 'provider',
         failureKind: 'client_init_failed',
-        error: { type: d.error.type, message: scrubMessage(d.error.message) }
+        error: toTelemetryError(d.error)
       }
     }
     case 'walletAccountChanged':

package/src/services/connection-service.test.ts

@@ -114,11 +114,11 @@ describe('ConnectionService', () => {
     const mockProvider = {
       supportedNetworkIds: ['eip155:1']
     }
-    const network = connectionService['validateAndDetermineNetwork'](
-      'eip155:1',
-      mockProvider as any
-    )
+    const { network, selection } = connectionService[
+      'validateAndDetermineNetwork'
+    ]('eip155:1', mockProvider as any, 'injected')
     expect(network).toEqual(networks[0])
+    expect(selection).toBe('explicit')
   })
 
   it('should throw error for unknown network', () => {
@@ -128,7 +128,8 @@ describe('ConnectionService', () => {
     expect(() => {
       connectionService['validateAndDetermineNetwork'](
         'eip155:8453',
-        mockProvider as any
+        mockProvider as any,
+        'injected'
       )
     }).toThrow('Network eip155:8453 is not in the configured networks')
   })
@@ -143,7 +144,8 @@ describe('ConnectionService', () => {
     try {
       connectionService['validateAndDetermineNetwork'](
         undefined,
-        mockProvider as any
+        mockProvider as any,
+        'injected'
       )
     } catch (e) {
       thrown = e
@@ -376,6 +378,44 @@ describe('ConnectionService', () => {
       expect(awaiting.namespace).toBe('eip155')
       expect(awaiting.chainId).toBe('eip155:1')
       expect(awaiting.handoffId).toBe(events[1].data.handoffId)
+      expect(awaiting.networkSelection).toBe('explicit')
+    })
+
+    it('auto-picks a detected namespace over an undetected first network (ONC-2110)', async () => {
+      networks.push({
+        ...networks[0],
+        id: 'tron:0x2b6653dc',
+        internalId: 2,
+        name: 'Tron',
+        namespace: 'tron',
+        networkType: 'tron'
+      } as Network)
+      // Trust mobile: catalog lists Tron first, but only EVM was detected.
+      wallets[0].extensionInjectedProvider = {
+        supportedNetworkIds: ['tron:0x2b6653dc', 'eip155:1'],
+        namespaceMetaData: {
+          tron: { injectedId: 'trustWallet.tronLink', installed: false },
+          eip155: { eip155Name: 'Trust Wallet', installed: true }
+        }
+      } as any
+      const awaiting = vi.fn()
+      eventManager.on('awaitingWallet', awaiting)
+      mockConnector.connect = vi.fn().mockResolvedValue({
+        networkId: 'eip155:1',
+        address: '0x1234',
+        availableAddresses: [{ address: '0x1234', networkId: 'eip155:1' }]
+      })
+
+      await connectionService.connect('injected', 'metamask')
+
+      expect(awaiting).toHaveBeenCalledWith(
+        expect.objectContaining({
+          chainId: 'eip155:1',
+          namespace: 'eip155',
+          networkSelection: 'detected'
+        })
+      )
+      expect(sessionManager.getSession().activeNetwork?.id).toBe('eip155:1')
     })
 
     it('emits one stable attempt ID per connect and a different ID for the next connect', async () => {

package/src/services/connection-service.ts

@@ -18,6 +18,11 @@ import { raceAbort } from '../utils/abort'
 import { generateId } from '../utils/id'
 import { instrumentHandoff } from '../observability/instrument-handoff'
 import { attachLifecycle } from '../observability/lifecycle-bridge'
+import {
+  DEFAULT_NAMESPACE_PRIORITY,
+  type NetworkSelection,
+  pickAutoNetwork
+} from './network-selection'
 
 export interface ServiceOptions {
   signal?: AbortSignal
@@ -87,7 +92,9 @@ export class ConnectionService {
     private usingIntegratedBrowser: boolean,
     private eventManager: EventManager,
     // Observational wallet-response deadline for the handoff timeout marker.
-    private walletResponseTimeoutMs: number
+    private walletResponseTimeoutMs: number,
+    /** Namespace preference for an auto-picked connect network — see `pickAutoNetwork`. */
+    private preferredNamespaces: readonly Namespace[] = DEFAULT_NAMESPACE_PRIORITY
   ) {}
 
   async connect(
@@ -104,7 +111,8 @@ export class ConnectionService {
     // connect() would spuriously abort (MFS-602).
     const wallet = this.findWallet(walletId)
     const provider = this.getProviderForMode(wallet, connectionMode)
-    const network = this.validateAndDetermineNetwork(networkId, provider)
+    const { network, selection: networkSelection } =
+      this.validateAndDetermineNetwork(networkId, provider, connectionMode)
     const connector = this.getConnector(connectionMode)
     // A silent-only connect is a promise never to open wallet UI. Only the
     // injected connector can keep it — WalletConnect / TON Connect always hand
@@ -176,7 +184,8 @@ export class ConnectionService {
           connectAttemptId,
           // Lets telemetry tell a silent restore from a tapped connect: both
           // succeed the same way, and only a miss carries a distinct failureKind.
-          silentOnly: options?.silentOnly === true
+          silentOnly: options?.silentOnly === true,
+          networkSelection
         },
         async handoffId => {
           // Publish this attempt's routing for the connector's step sink.
@@ -947,9 +956,11 @@ export class ConnectionService {
 
   private validateAndDetermineNetwork(
     networkId: NetworkId | undefined,
-    provider: SupportedProvider
-  ): Network {
+    provider: SupportedProvider,
+    connectionMode: ConnectionMode
+  ): { network: Network; selection: NetworkSelection } {
     let targetNetworkId: NetworkId
+    let selection: NetworkSelection = 'explicit'
 
     if (networkId) {
       // Check if networkId is in the configured networks
@@ -968,11 +979,16 @@ export class ConnectionService {
 
       targetNetworkId = networkId
     } else {
-      // Use the first supported network that exists in both wallet and configured networks
-      const supportedNetwork = provider.supportedNetworkIds.find(id =>
-        this.networks.some(n => n.id === id)
+      // No network named: prefer a namespace detection found installed (injected
+      // only), ranked by `preferredNamespaces`; otherwise the first supported
+      // network that is also configured (catalog order).
+      const picked = pickAutoNetwork(
+        provider,
+        this.networks,
+        connectionMode,
+        this.preferredNamespaces
       )
-      if (!supportedNetwork) {
+      if (!picked) {
         // The #1 production connection failure. Throw a typed, self-describing
         // error carrying both CAIP-2 id lists (non-PII) so telemetry can tell a
         // metadata gap from a client-config mistake — see NoCommonNetworkError.
@@ -981,7 +997,8 @@ export class ConnectionService {
           this.networks.map(n => n.id)
         )
       }
-      targetNetworkId = supportedNetwork
+      targetNetworkId = picked.networkId
+      selection = picked.selection
     }
 
     // Find and return the network object
@@ -991,7 +1008,7 @@ export class ConnectionService {
         `Network ${targetNetworkId} not found in configured networks`
       )
     }
-    return network
+    return { network, selection }
   }
 
   async disconnect(options?: ServiceOptions): Promise<void> {

package/src/services/index.ts

@@ -1,3 +1,4 @@
 export * from './connection-service'
+export * from './network-selection'
 export * from './signature-service'
 export * from './transaction-service'

package/src/services/network-selection.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'vitest'
+import type { Network, SupportedProvider } from '@meshconnect/uwc-types'
+import {
+  DEFAULT_NAMESPACE_PRIORITY,
+  pickAutoNetwork
+} from './network-selection'
+
+const network = (id: string, namespace: Network['namespace']): Network =>
+  ({
+    id,
+    internalId: 0,
+    name: id,
+    namespace,
+    logoUrl: '',
+    networkType: 'evm',
+    nativeCurrency: { name: '', symbol: '', decimals: 18 }
+  }) as Network
+
+const NETWORKS = [
+  network('eip155:1', 'eip155'),
+  network('eip155:81457', 'eip155'),
+  network('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp', 'solana'),
+  network('tron:0x2b6653dc', 'tron'),
+  network('tvm:-239', 'tvm')
+]
+
+/** An injected provider whose namespaces carry detection's `installed` flag. */
+const injected = (
+  supportedNetworkIds: string[],
+  installed: Partial<Record<'eip155' | 'solana' | 'tron' | 'tvm', boolean>>
+): SupportedProvider =>
+  ({
+    supportedNetworkIds,
+    namespaceMetaData: {
+      eip155: { eip155Name: 'W', installed: installed.eip155 },
+      solana: { walletStandardName: 'W', installed: installed.solana },
+      tron: { injectedId: 'w.tron', installed: installed.tron },
+      tvm: { jsBridgeKey: 'w', installed: installed.tvm }
+    }
+  }) as unknown as SupportedProvider
+
+describe('pickAutoNetwork', () => {
+  it('skips an undetected first network (Trust mobile: Tron first, not injected)', () => {
+    const provider = injected(
+      [
+        'tron:0x2b6653dc',
+        'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        'eip155:1'
+      ],
+      { eip155: true, solana: true, tron: false, tvm: true }
+    )
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'injected',
+        DEFAULT_NAMESPACE_PRIORITY
+      )
+    ).toEqual({ networkId: 'eip155:1', selection: 'detected' })
+  })
+
+  it('keeps catalog order within a namespace', () => {
+    const provider = injected(['eip155:81457', 'eip155:1'], { eip155: true })
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'injected',
+        DEFAULT_NAMESPACE_PRIORITY
+      )?.networkId
+    ).toBe('eip155:81457')
+  })
+
+  it('honours a caller-supplied namespace preference', () => {
+    const provider = injected(
+      ['eip155:1', 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'],
+      { eip155: true, solana: true }
+    )
+    expect(
+      pickAutoNetwork(provider, NETWORKS, 'injected', ['solana', 'eip155'])
+    ).toEqual({
+      networkId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      selection: 'detected'
+    })
+  })
+
+  it('ranks a namespace missing from the preference list last', () => {
+    const provider = injected(['tvm:-239', 'tron:0x2b6653dc'], {
+      tvm: true,
+      tron: true
+    })
+    expect(
+      pickAutoNetwork(provider, NETWORKS, 'injected', ['tron'])?.networkId
+    ).toBe('tron:0x2b6653dc')
+  })
+
+  it('falls back to catalog order when nothing was detected (e.g. before detection)', () => {
+    const provider = injected(['tron:0x2b6653dc', 'eip155:1'], {})
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'injected',
+        DEFAULT_NAMESPACE_PRIORITY
+      )
+    ).toEqual({ networkId: 'tron:0x2b6653dc', selection: 'catalogOrder' })
+  })
+
+  it('leaves non-injected modes on catalog order even with installed flags', () => {
+    const provider = injected(['tron:0x2b6653dc', 'eip155:1'], {
+      eip155: true
+    })
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'walletConnect',
+        DEFAULT_NAMESPACE_PRIORITY
+      )
+    ).toEqual({ networkId: 'tron:0x2b6653dc', selection: 'catalogOrder' })
+  })
+
+  it('ignores supported networks that are not configured', () => {
+    const provider = injected(
+      ['eip155:999', 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'],
+      {
+        eip155: true,
+        solana: true
+      }
+    )
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'injected',
+        DEFAULT_NAMESPACE_PRIORITY
+      )?.networkId
+    ).toBe('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')
+  })
+
+  it('returns undefined when no supported network is configured', () => {
+    const provider = injected(['eip155:999'], { eip155: true })
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'injected',
+        DEFAULT_NAMESPACE_PRIORITY
+      )
+    ).toBeUndefined()
+  })
+})

package/src/services/network-selection.ts

@@ -0,0 +1,86 @@
+import type {
+  ConnectionMode,
+  Namespace,
+  Network,
+  NetworkId,
+  SupportedProvider
+} from '@meshconnect/uwc-types'
+
+/**
+ * Default namespace preference for an auto-picked connect network (no
+ * `networkId` passed): EVM first, then Solana, Tron, TON, Bitcoin. A caller
+ * policy, not a correctness rule — override it with `UWCConfig.preferredNamespaces`.
+ * Same order as the namespace unions used across the connectors.
+ */
+export const DEFAULT_NAMESPACE_PRIORITY: readonly Namespace[] = [
+  'eip155',
+  'solana',
+  'tron',
+  'tvm',
+  'bip122'
+]
+
+/**
+ * How the connect network was chosen, surfaced on the hand-off telemetry:
+ * - `explicit` — the caller passed a `networkId`.
+ * - `detected` — auto-picked among namespaces whose injected provider was
+ *   detected, ranked by the namespace preference, catalog order breaking ties.
+ * - `catalogOrder` — legacy pick: the first configured network in the wallet's
+ *   `supportedNetworkIds` (non-injected modes, or nothing detected yet).
+ */
+export type NetworkSelection = 'explicit' | 'detected' | 'catalogOrder'
+
+function isNamespaceInstalled(
+  provider: SupportedProvider,
+  namespace: Namespace
+): boolean {
+  if (!('namespaceMetaData' in provider)) return false
+  const meta = provider.namespaceMetaData[
+    namespace as keyof typeof provider.namespaceMetaData
+  ] as { installed?: boolean } | undefined
+  return meta?.installed === true
+}
+
+/**
+ * Picks the network for a connect that named none. Candidates are the wallet's
+ * `supportedNetworkIds` that are also configured, in catalog order.
+ *
+ * For an injected connect where detection marked at least one candidate's
+ * namespace installed, only installed namespaces are eligible (connecting on an
+ * undetected namespace can only fail — e.g. Trust mobile has no
+ * `trustWallet.tronLink`), ranked by `preferredNamespaces`, catalog order
+ * breaking ties. Every other case keeps the legacy first-candidate pick, so
+ * WalletConnect / TON Connect and pre-detection connects are unchanged.
+ * Returns `undefined` when no candidate exists (the caller throws).
+ */
+export function pickAutoNetwork(
+  provider: SupportedProvider,
+  networks: readonly Network[],
+  connectionMode: ConnectionMode,
+  preferredNamespaces: readonly Namespace[]
+): { networkId: NetworkId; selection: NetworkSelection } | undefined {
+  const candidates = provider.supportedNetworkIds
+    .map(id => networks.find(n => n.id === id))
+    .filter((n): n is Network => n !== undefined)
+  const first = candidates[0]
+  if (!first) return undefined
+
+  if (connectionMode === 'injected') {
+    const installed = candidates.filter(n =>
+      isNamespaceInstalled(provider, n.namespace)
+    )
+    if (installed.length > 0) {
+      const rank = (namespace: Namespace) => {
+        const index = preferredNamespaces.indexOf(namespace)
+        return index === -1 ? preferredNamespaces.length : index
+      }
+      // Array.prototype.sort is stable, so equal ranks keep catalog order.
+      const [best] = [...installed].sort(
+        (a, b) => rank(a.namespace) - rank(b.namespace)
+      )
+      if (best) return { networkId: best.id, selection: 'detected' }
+    }
+  }
+
+  return { networkId: first.id, selection: 'catalogOrder' }
+}

package/src/services/transaction-service.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { TransactionService } from './transaction-service'
 import { SessionManager } from '../managers/session-manager'
 import { EventManager } from '../managers/event-manager'
+import { WalletConnectorError } from '../../../types/src'
 import type {
   ConnectionMode,
   Connector,
@@ -211,6 +212,30 @@ describe('TransactionService.sendTransaction', () => {
     expect(events).toEqual(['awaitingWallet', 'walletRejected'])
   })
 
+  it("carries the wallet's own reason onto walletFailed and the thrown error", async () => {
+    connectSession()
+    const failures: { error: { providerReason?: string } }[] = []
+    eventManager.on('walletFailed', d => failures.push(d))
+    vi.mocked(mockConnector.sendTransaction!).mockRejectedValueOnce(
+      new WalletConnectorError({
+        type: 'unknown',
+        message: 'An unknown RPC error occurred.',
+        providerReason: 'cancelled'
+      })
+    )
+
+    const error = await transactionService
+      .sendTransaction(request)
+      .catch((e: unknown) => e)
+
+    expect(error).toMatchObject({ providerReason: 'cancelled' })
+    expect(events).toEqual(['awaitingWallet', 'walletFailed'])
+    expect(failures[0]?.error).toMatchObject({
+      type: 'unknown',
+      providerReason: 'cancelled'
+    })
+  })
+
   it('tonConnect enters the funnel with the connector resolving its own provider', async () => {
     connectors.set('tonConnect', mockConnector)
     connectSession('tonConnect', walletWithoutProviders)