fix(transport-webrtc): abort stream when datachannel send throws (#3469)

* test(transport-webrtc): reproduce datachannel send during state divergence

Triggers the JS-vs-native state divergence in node-datachannel polyfill by
closing the peer connection synchronously before send(), so the cached
readyState is still 'open' while the native channel is closed.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* fix(transport-webrtc): abort stream when datachannel send throws

channel.send can throw synchronously when the native libdatachannel
state diverges from the polyfill's cached readyState. Wrap the call
and abort the stream so the error surfaces as a transport failure
instead of going uncaught.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* test(transport-webrtc): skip datachannel send race test in browsers

The JS-vs-native state divergence is specific to the node-datachannel
polyfill; native browser WebRTC does not reproduce it. Also add
libdatachannel to the spell-check dictionary for the new fix comment.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* chore(transport-webrtc): shorten comments on send error fix

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: tabcat

packages/transport-webrtc/src/stream.ts

@@ -139,9 +139,15 @@ export class WebRTCStream extends AbstractStream {
 
     this.log.trace('sending message, channel state "%s"', this.channel.readyState)
 
-    // send message without copying data
-    for (const buf of data) {
-      this.channel.send(buf)
+    try {
+      // send message without copying data
+      for (const buf of data) {
+        this.channel.send(buf)
+      }
+    } catch (err: any) {
+      // channel.send can throw synchronously if the polyfill's cached readyState is stale
+      this.log.error('error sending datachannel message - %e', err)
+      this.abort(err)
     }
   }
 

packages/transport-webrtc/test/stream.spec.ts

@@ -5,13 +5,14 @@ import * as lengthPrefixed from 'it-length-prefixed'
 import { bytes } from 'multiformats'
 import { pEvent } from 'p-event'
 import { stubInterface } from 'sinon-ts'
+import { isNode, isElectronMain } from 'wherearewe'
 import { MAX_MESSAGE_SIZE, PROTOBUF_OVERHEAD } from '../src/constants.js'
 import { Message } from '../src/private-to-public/pb/message.js'
 import { createStream } from '../src/stream.js'
 import { RTCPeerConnection } from '../src/webrtc/index.js'
 import { receiveFinAck, receiveRemoteCloseWrite } from './util.ts'
 import type { WebRTCStream } from '../src/stream.js'
-import type { Stream } from '@libp2p/interface'
+import type { Stream, StreamCloseEvent } from '@libp2p/interface'
 
 describe('Max message size', () => {
   it(`sends messages smaller or equal to ${MAX_MESSAGE_SIZE} bytes in one`, async () => {
@@ -72,6 +73,69 @@ describe('Max message size', () => {
   })
 })
 
+describe('Datachannel send errors', () => {
+  let pcA: RTCPeerConnection
+  let pcB: RTCPeerConnection
+
+  afterEach(() => {
+    pcA?.close()
+    pcB?.close()
+  })
+
+  it('aborts the stream when underlying datachannel is closed mid-send', async function () {
+    // polyfill-specific race; native browser WebRTC doesn't exhibit it
+    if (!isNode && !isElectronMain) {
+      return this.skip()
+    }
+
+    // the node-datachannel polyfill's cached readyState updates on the next
+    // tick after onClosed fires, so closing the peer leaves a window where
+    // send() passes the guard and hits an already-closed native channel
+    pcA = new RTCPeerConnection()
+    pcB = new RTCPeerConnection()
+    const channelA = pcA.createDataChannel('test', { negotiated: true, id: 91 })
+    const channelB = pcB.createDataChannel('test', { negotiated: true, id: 91 })
+
+    pcA.onicecandidate = ({ candidate }) => {
+      if (candidate != null) {
+        pcB.addIceCandidate(candidate).catch(() => {})
+      }
+    }
+    pcB.onicecandidate = ({ candidate }) => {
+      if (candidate != null) {
+        pcA.addIceCandidate(candidate).catch(() => {})
+      }
+    }
+
+    await pcA.setLocalDescription(await pcA.createOffer())
+    await pcB.setRemoteDescription(pcA.localDescription as RTCSessionDescriptionInit)
+    await pcB.setLocalDescription(await pcB.createAnswer())
+    await pcA.setRemoteDescription(pcB.localDescription as RTCSessionDescriptionInit)
+
+    await Promise.all([
+      pEvent(channelA, 'open', { rejectionEvents: ['close', 'error'] }),
+      pEvent(channelB, 'open', { rejectionEvents: ['close', 'error'] })
+    ])
+
+    const webrtcStream = createStream({
+      channel: channelA,
+      direction: 'outbound',
+      closeTimeout: 1,
+      log: defaultLogger().forComponent('test')
+    })
+
+    pcA.close()
+    expect(channelA.readyState).to.equal('open')
+
+    const closeEventPromise = pEvent<'close', StreamCloseEvent>(webrtcStream, 'close')
+    webrtcStream.send(new Uint8Array([1, 2, 3, 4]))
+    const closeEvent = await closeEventPromise
+
+    expect(closeEvent.error).to.exist()
+    expect(webrtcStream.status).to.equal('aborted')
+  })
+})
+
 const TEST_MESSAGE = 'test_message'
 
 async function setup (): Promise<{ peerConnection: RTCPeerConnection, dataChannel: RTCDataChannel, stream: WebRTCStream }> {