node-rtc-connection 1.0.19 → 2.0.5

package/types/ice/ice-agent.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @file ice-agent.ts
+ * @description A small but RFC 8445-compliant ICE agent for a single data
+ * component, with browser-compatible connectivity checks and TURN relay.
+ * @module ice/ice-agent
+ *
+ * Responsibilities:
+ *  - Gather UDP host candidates, server-reflexive (srflx) candidates via STUN,
+ *    and relay candidates via TURN (RFC 5766 ALLOCATE).
+ *  - Send/answer STUN Binding connectivity checks carrying USERNAME,
+ *    MESSAGE-INTEGRITY (keyed by the remote/local ice-pwd), PRIORITY, the
+ *    ICE-CONTROLLING/CONTROLLED role attribute, and USE-CANDIDATE.
+ *  - Nominate a candidate pair and expose it as the selected path.
+ *  - Demultiplex inbound datagrams per RFC 7983: STUN (first byte 0-3) is
+ *    handled internally; everything else (DTLS records, first byte 20-63) is
+ *    emitted as 'data' for the upper stack.
+ *
+ * Each local candidate carries a `transport` with a uniform interface so the
+ * connectivity-check and data paths are identical whether the candidate is a
+ * host socket or a TURN relay:
+ *   transport.send(buf, remoteAddress, remotePort)
+ *   transport.onMessage = (buf, {address, port}) => ...
+ */
+import { EventEmitter } from 'events';
+/** Remote info accompanying an inbound datagram. */
+interface RemoteInfo {
+    address: string;
+    port: number;
+}
+/**
+ * Uniform transport abstraction shared by host sockets and TURN relays.
+ */
+interface Transport {
+    kind: string;
+    send(buf: Buffer, address: string, port: number): void;
+    onMessage: ((msg: Buffer, rinfo: RemoteInfo) => void) | null;
+    close(): void;
+}
+/** A local ICE candidate. */
+interface LocalCandidate {
+    foundation: string;
+    component: number;
+    protocol: string;
+    priority: number;
+    address: string;
+    port: number;
+    type: string;
+    transport: Transport;
+    sdp: string;
+}
+/** A remote ICE candidate (parsed from an a=candidate line or object). */
+interface RemoteCandidate {
+    address: string;
+    port: number;
+    priority?: number;
+    type?: string;
+}
+/** A candidate pair under connectivity checking. */
+interface CandidatePair {
+    key?: string;
+    local: {
+        transport: Transport;
+    } & Partial<LocalCandidate>;
+    remote: {
+        address: string;
+        port: number;
+    } & Partial<RemoteCandidate>;
+    state?: string;
+    nominated?: boolean;
+}
+/** Description of a single ICE server entry. */
+interface IceServer {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+}
+/** Options accepted by {@link IceAgent#gather}. */
+interface GatherOptions {
+    iceServers?: IceServer[];
+    iceTransportPolicy?: 'all' | 'relay';
+}
+/** Parsed query parameters from a STUN/TURN URL. */
+type IceServerParams = Record<string, string | true>;
+/** Result of {@link parseIceServerUrl}. */
+interface ParsedIceServerUrl {
+    scheme: string;
+    protocol: string;
+    host: string;
+    port: number;
+    transport: string;
+    params: IceServerParams;
+}
+/** Options accepted by the {@link IceAgent} constructor. */
+interface IceAgentOptions {
+    role: 'controlling' | 'controlled';
+    localUfrag: string;
+    localPwd: string;
+}
+/**
+ * Compute an ICE candidate priority (RFC 8445 §5.1.2.1).
+ */
+declare function candidatePriority(type: string, localPref?: number, componentId?: number): number;
+/**
+ * Parse a STUN/TURN server URL: (stun|turn|turns):host[:port][?key=val&...].
+ * Query parameters are returned in `params`; a flag without a value (e.g.
+ * "?secure") is recorded as `true`, an empty value ("?transport=") as "".
+ * @param {string} url
+ * @returns {{scheme:string, protocol:string, host:string, port:number,
+ *            transport:string, params:Object}|null} null if the URL is invalid.
+ */
+declare function parseIceServerUrl(url: string): ParsedIceServerUrl | null;
+declare class IceAgent extends EventEmitter {
+    #private;
+    role: 'controlling' | 'controlled';
+    localUfrag: string;
+    localPwd: string;
+    remoteUfrag: string | null;
+    remotePwd: string | null;
+    /**
+     * @param {Object} opts
+     * @param {'controlling'|'controlled'} opts.role
+     * @param {string} opts.localUfrag
+     * @param {string} opts.localPwd
+     */
+    constructor(opts: IceAgentOptions);
+    /**
+     * Gather candidates. Host candidates always; srflx/relay when iceServers are
+     * given. With iceTransportPolicy 'relay', only relay candidates are kept.
+     * @param {Object} [opts]
+     * @param {Array<{urls:string|string[],username?:string,credential?:string}>} [opts.iceServers]
+     * @param {'all'|'relay'} [opts.iceTransportPolicy='all']
+     */
+    gather(opts?: GatherOptions): Promise<void>;
+    getLocalCandidates(): LocalCandidate[];
+    /** Set remote ICE credentials (from the peer's SDP). */
+    setRemoteCredentials(ufrag: string, pwd: string): void;
+    /**
+     * Add a remote candidate (parsed from an a=candidate line or object).
+     * @param {{address:string, port:number, priority?:number, type?:string}} cand
+     */
+    addRemoteCandidate(cand: RemoteCandidate): void;
+    /** Begin connectivity checks (call once remote creds + candidates exist). */
+    start(): void;
+    /**
+     * Send application (DTLS) data over the selected path.
+     * @param {Buffer} data
+     */
+    send(data: Buffer): void;
+    getSelectedPair(): CandidatePair | null;
+    /** Type of the selected local candidate ('host'|'srflx'|'relay'|'prflx'). */
+    getSelectedCandidateType(): string | null | undefined;
+    close(): void;
+}
+export { IceAgent, candidatePriority, parseIceServerUrl };

package/types/ice/stun-message.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @file stun-message.ts
+ * @description STUN message codec for ICE connectivity checks (RFC 5389 / 8445).
+ * @module ice/stun-message
+ *
+ * Unlike the server-oriented stun-client.js (binding/allocate), this builds and
+ * validates the connectivity-check messages browsers require: USERNAME,
+ * MESSAGE-INTEGRITY (HMAC-SHA1 keyed by the peer's ice-pwd), FINGERPRINT
+ * (CRC-32 of the message Xored with 0x5354554e), PRIORITY, ICE-CONTROLLING/
+ * ICE-CONTROLLED, and USE-CANDIDATE.
+ */
+export declare const MAGIC_COOKIE = 554869826;
+export declare const METHOD: Readonly<{
+    BINDING: 1;
+}>;
+export declare const CLASS: Readonly<{
+    REQUEST: 0;
+    INDICATION: 16;
+    SUCCESS: 256;
+    ERROR: 272;
+}>;
+export declare const MSG_TYPE: Readonly<{
+    BINDING_REQUEST: 1;
+    BINDING_SUCCESS: 257;
+    BINDING_ERROR: 273;
+}>;
+export declare const ATTR: Readonly<{
+    MAPPED_ADDRESS: 1;
+    USERNAME: 6;
+    MESSAGE_INTEGRITY: 8;
+    ERROR_CODE: 9;
+    XOR_MAPPED_ADDRESS: 32;
+    PRIORITY: 36;
+    USE_CANDIDATE: 37;
+    FINGERPRINT: 32808;
+    ICE_CONTROLLED: 32809;
+    ICE_CONTROLLING: 32810;
+}>;
+/** A single STUN attribute pending serialization. */
+interface StunAttribute {
+    type: number;
+    value: Buffer;
+}
+/** Shape of a parsed STUN message. */
+export interface ParsedStunMessage {
+    type: number;
+    transactionId: Buffer;
+    attrs: Map<number, Buffer>;
+    raw: Buffer;
+}
+export declare function crc32(buf: Buffer): number;
+/**
+ * @class StunMessageBuilder
+ * @description Incrementally builds a STUN message, then appends
+ * MESSAGE-INTEGRITY and FINGERPRINT with the correct length pre-computation.
+ */
+export declare class StunMessageBuilder {
+    #private;
+    type: number;
+    transactionId: Buffer;
+    attrs: StunAttribute[];
+    constructor(type: number, transactionId?: Buffer);
+    addAttr(type: number, value: Buffer): this;
+    addUsername(username: string): this;
+    addPriority(priority: number): this;
+    addIceControlling(tieBreaker: Buffer): this;
+    addIceControlled(tieBreaker: Buffer): this;
+    addUseCandidate(): this;
+    addXorMappedAddress(address: string, port: number): this;
+    /**
+     * Finalize the message, appending MESSAGE-INTEGRITY (keyed by `password`)
+     * and FINGERPRINT. Both require the header length to include the attribute
+     * being computed, per RFC 5389 §15.4 / §15.5.
+     * @param {string} [password] - ICE password for MESSAGE-INTEGRITY
+     * @returns {Buffer}
+     */
+    build(password?: string): Buffer;
+}
+/**
+ * Parse a STUN message. Returns null if not a STUN message.
+ * @param {Buffer} msg
+ * @returns {null|{type:number,transactionId:Buffer,attrs:Map<number,Buffer>,raw:Buffer}}
+ */
+export declare function parse(msg: Buffer): ParsedStunMessage | null;
+/**
+ * Verify the MESSAGE-INTEGRITY of a parsed message against a password.
+ * @param {Buffer} msg - raw message
+ * @param {string} password
+ * @returns {boolean}
+ */
+export declare function verifyIntegrity(msg: Buffer, password: string): boolean;
+export {};

package/types/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview node-rtc-connection - WebRTC DataChannel implementation for Node.js
+ *
+ * A from-scratch, pure-Node.js implementation of WebRTC peer connections and
+ * data channels (no native dependencies). Interoperates with browsers.
+ *
+ * This implementation focuses on DataChannel functionality without media streams.
+ * Features:
+ * - ICE (Interactive Connectivity Establishment), RFC 8445
+ * - STUN/TURN support for NAT traversal
+ * - DTLS 1.2 encryption (RFC 6347)
+ * - SCTP over DTLS + DCEP for data channels (RFC 8831 / 8832)
+ * - W3C-compatible RTCPeerConnection / RTCDataChannel API
+ *
+ * @license MIT
+ * @author nmhung1210
+ */
+import ByteBufferQueue from './foundation/ByteBufferQueue';
+import RTCError from './foundation/RTCError';
+import RTCIceCandidate from './ice/RTCIceCandidate';
+import RTCCertificate from './dtls/RTCCertificate';
+import { RTCDataChannel, RTCDataChannelState } from './datachannel/RTCDataChannel';
+import { RTCSessionDescription, RTCSdpType } from './sdp/RTCSessionDescription';
+import { RTCPeerConnection, RTCSignalingState, RTCIceGatheringState, RTCPeerConnectionState } from './peerconnection/RTCPeerConnection';
+export { ByteBufferQueue, RTCError, RTCIceCandidate, RTCCertificate, RTCDataChannel, RTCDataChannelState, RTCSessionDescription, RTCSdpType, RTCPeerConnection, RTCSignalingState, RTCIceGatheringState, RTCPeerConnectionState, };
+export declare const version: string;
+export type { RTCDataChannelInit } from './datachannel/RTCDataChannel';
+export type { RTCSessionDescriptionInit } from './sdp/RTCSessionDescription';
+export type { TransportStackOptions } from './transport-stack';

package/types/peerconnection/RTCPeerConnection.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @file RTCPeerConnection.ts
+ * @description WebRTC peer connection driving a real ICE/DTLS/SCTP/DCEP stack.
+ * @module peerconnection/RTCPeerConnection
+ *
+ * This orchestrates signaling (offer/answer + ICE candidate trickle) on top of
+ * src/transport-stack.ts, which implements the actual on-the-wire protocols.
+ * It interoperates with browser RTCPeerConnection for data channels.
+ */
+import { EventEmitter } from 'events';
+import RTCCertificate from '../dtls/RTCCertificate';
+import { RTCSessionDescription, RTCSessionDescriptionInit } from '../sdp/RTCSessionDescription';
+import { RTCDataChannel, RTCDataChannelInit } from '../datachannel/RTCDataChannel';
+import { TransportStack } from '../transport-stack';
+/** Configuration accepted by {@link RTCPeerConnection}. */
+export interface RTCConfiguration {
+    iceServers?: unknown[];
+    iceTransportPolicy?: 'all' | 'relay';
+    certificates?: RTCCertificate[];
+}
+export declare const RTCSignalingState: Readonly<{
+    STABLE: "stable";
+    HAVE_LOCAL_OFFER: "have-local-offer";
+    HAVE_REMOTE_OFFER: "have-remote-offer";
+    HAVE_LOCAL_PRANSWER: "have-local-pranswer";
+    HAVE_REMOTE_PRANSWER: "have-remote-pranswer";
+    CLOSED: "closed";
+}>;
+export declare const RTCIceGatheringState: Readonly<{
+    NEW: "new";
+    GATHERING: "gathering";
+    COMPLETE: "complete";
+}>;
+export declare const RTCPeerConnectionState: Readonly<{
+    NEW: "new";
+    CONNECTING: "connecting";
+    CONNECTED: "connected";
+    DISCONNECTED: "disconnected";
+    FAILED: "failed";
+    CLOSED: "closed";
+}>;
+export declare class RTCPeerConnection extends EventEmitter {
+    #private;
+    constructor(configuration?: RTCConfiguration);
+    createDataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel;
+    createOffer(): Promise<RTCSessionDescription>;
+    createAnswer(): Promise<RTCSessionDescription>;
+    setLocalDescription(description?: RTCSessionDescriptionInit | RTCSessionDescription): Promise<void>;
+    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidateInit | string): Promise<void>;
+    getConfiguration(): RTCConfiguration;
+    setConfiguration(configuration: RTCConfiguration): void;
+    close(): void;
+    get signalingState(): string;
+    get iceGatheringState(): string;
+    get iceConnectionState(): string;
+    get connectionState(): string;
+    get localDescription(): RTCSessionDescription | null;
+    get remoteDescription(): RTCSessionDescription | null;
+    get currentLocalDescription(): RTCSessionDescription | null;
+    get currentRemoteDescription(): RTCSessionDescription | null;
+    get pendingLocalDescription(): RTCSessionDescription | null;
+    get pendingRemoteDescription(): RTCSessionDescription | null;
+    get canTrickleIceCandidates(): boolean;
+    get sctp(): TransportStack['sctp'];
+}
+/** ICE candidate init shape (subset of the W3C dictionary). */
+interface RTCIceCandidateInit {
+    candidate: string;
+    sdpMid?: string;
+    sdpMLineIndex?: number;
+    usernameFragment?: string;
+}
+export {};

package/types/sctp/association.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @file association.ts
+ * @description Minimal SCTP association over a datagram channel (DTLS), scoped
+ * to the WebRTC data channel profile (RFC 8831).
+ * @module sctp/association
+ *
+ * Implements the four-way INIT/INIT-ACK/COOKIE-ECHO/COOKIE-ACK setup, DATA
+ * transmit/receive with TSN tracking and SACK, ordered and unordered delivery,
+ * and reassembly of fragmented user messages. Congestion control is
+ * intentionally simple (stop-and-go style with a generous rwnd) which is
+ * adequate for control/data-channel traffic and interoperates with usrsctp
+ * (the stack browsers use).
+ *
+ * The association rides on top of a reliable-ish datagram pipe provided by
+ * DTLS; SCTP still provides framing, ordering, multiplexing and ack'ing.
+ */
+import { EventEmitter } from 'events';
+declare const SCTP_PORT = 5000;
+declare const STATE: Readonly<{
+    CLOSED: "closed";
+    COOKIE_WAIT: "cookie-wait";
+    COOKIE_ECHOED: "cookie-echoed";
+    ESTABLISHED: "established";
+}>;
+type StateValue = (typeof STATE)[keyof typeof STATE];
+/** Options for constructing an {@link SctpAssociation}. */
+export interface SctpAssociationOptions {
+    /** the DTLS client initiates SCTP (RFC 8831) */
+    isClient?: boolean;
+}
+/** A complete user message surfaced via the 'message' event. */
+export interface SctpMessage {
+    streamId: number;
+    ppid: number;
+    data: Buffer;
+}
+/**
+ * @class SctpAssociation
+ * @extends EventEmitter
+ *
+ * Events:
+ *  - 'established'             association is up
+ *  - 'message' ({streamId, ppid, data})  a complete user message arrived
+ *  - 'output' (Buffer)         an SCTP packet to hand to DTLS
+ *  - 'close'
+ */
+declare class SctpAssociation extends EventEmitter {
+    #private;
+    isClient: boolean;
+    state: StateValue;
+    /**
+     * @param {Object} opts
+     * @param {boolean} opts.isClient - the DTLS client initiates SCTP (RFC 8831)
+     */
+    constructor(opts?: SctpAssociationOptions);
+    /** Start the association (client sends INIT). */
+    start(): void;
+    /**
+     * Feed an inbound SCTP packet (decrypted from DTLS).
+     * @param {Buffer} packet
+     */
+    receivePacket(packet: Buffer): void;
+    /**
+     * Send a user message on a stream.
+     * @param {number} streamId
+     * @param {number} ppid
+     * @param {Buffer} data
+     * @param {Object} [opts]
+     * @param {boolean} [opts.unordered=false]
+     */
+    sendData(streamId: number, ppid: number, data: Buffer, opts?: {
+        unordered?: boolean;
+    }): void;
+    /** Gracefully close the association. */
+    shutdown(): void;
+}
+export { SctpAssociation, STATE, SCTP_PORT };

package/types/sctp/chunks.d.ts

@@ -0,0 +1,200 @@
+/**
+ * @file chunks.ts
+ * @description SCTP common header and chunk encode/parse (RFC 4960 + RFC 8260
+ * for I-DATA is NOT used; classic DATA only). Scoped to the WebRTC profile.
+ * @module sctp/chunks
+ */
+export declare const CHUNK_TYPE: Readonly<{
+    DATA: 0;
+    INIT: 1;
+    INIT_ACK: 2;
+    SACK: 3;
+    HEARTBEAT: 4;
+    HEARTBEAT_ACK: 5;
+    ABORT: 6;
+    SHUTDOWN: 7;
+    SHUTDOWN_ACK: 8;
+    ERROR: 9;
+    COOKIE_ECHO: 10;
+    COOKIE_ACK: 11;
+    SHUTDOWN_COMPLETE: 14;
+    FORWARD_TSN: 192;
+}>;
+export declare const PARAM_TYPE: Readonly<{
+    HEARTBEAT_INFO: 1;
+    STATE_COOKIE: 7;
+    UNRECOGNIZED_PARAM: 8;
+    COOKIE_PRESERVATIVE: 9;
+    SUPPORTED_ADDR_TYPES: 11;
+    FORWARD_TSN_SUPPORTED: 49152;
+    SUPPORTED_EXTENSIONS: 32776;
+}>;
+export declare const PPID: Readonly<{
+    DCEP: 50;
+    STRING: 51;
+    BINARY: 53;
+    STRING_EMPTY: 56;
+    BINARY_EMPTY: 57;
+    STRING_PARTIAL: 54;
+    BINARY_PARTIAL: 52;
+}>;
+export interface CommonHeader {
+    srcPort: number;
+    dstPort: number;
+    verificationTag: number;
+    checksum: number;
+}
+export interface ParsedChunk {
+    type: number;
+    flags: number;
+    length: number;
+    body: Buffer;
+}
+export interface ParsedParam {
+    type: number;
+    length: number;
+    value: Buffer;
+}
+export interface InitBodyParams {
+    initiateTag: number;
+    a_rwnd: number;
+    outStreams: number;
+    inStreams: number;
+    initialTSN: number;
+}
+export interface ParsedInitBody {
+    initiateTag: number;
+    a_rwnd: number;
+    outStreams: number;
+    inStreams: number;
+    initialTSN: number;
+    params: ParsedParam[];
+}
+export interface DataBodyParams {
+    tsn: number;
+    streamId: number;
+    streamSeq: number;
+    ppid: number;
+    userData: Buffer;
+    unordered?: boolean;
+    beginning?: boolean;
+    ending?: boolean;
+}
+export interface EncodedDataBody {
+    flags: number;
+    body: Buffer;
+}
+export interface ParsedDataBody {
+    unordered: boolean;
+    beginning: boolean;
+    ending: boolean;
+    tsn: number;
+    streamId: number;
+    streamSeq: number;
+    ppid: number;
+    userData: Buffer;
+}
+export interface SackBodyParams {
+    cumulativeTSNAck: number;
+    a_rwnd: number;
+    gapBlocks?: Array<[number, number]>;
+    dupTSNs?: number[];
+}
+export interface ParsedSackBody {
+    cumulativeTSNAck: number;
+    a_rwnd: number;
+    gapBlocks: Array<[number, number]>;
+    dupTSNs: number[];
+}
+/** Round a length up to the next 4-byte boundary. */
+export declare function pad4(n: number): number;
+/**
+ * Encode the 12-byte SCTP common header (checksum left as 0; filled by crc32c).
+ * @param {number} srcPort
+ * @param {number} dstPort
+ * @param {number} verificationTag
+ * @returns {Buffer}
+ */
+export declare function encodeCommonHeader(srcPort: number, dstPort: number, verificationTag: number): Buffer;
+/**
+ * Parse the common header.
+ * @param {Buffer} packet
+ * @returns {{srcPort:number,dstPort:number,verificationTag:number,checksum:number}}
+ */
+export declare function parseCommonHeader(packet: Buffer): CommonHeader;
+/**
+ * Wrap a chunk body with the 4-byte chunk header, padded to 4 bytes.
+ * @param {number} type
+ * @param {number} flags
+ * @param {Buffer} body
+ * @returns {Buffer}
+ */
+export declare function encodeChunk(type: number, flags: number, body: Buffer): Buffer;
+/**
+ * Parse all chunks out of an SCTP packet (after the 12-byte common header).
+ * @param {Buffer} packet
+ * @returns {Array<{type:number,flags:number,length:number,body:Buffer}>}
+ */
+export declare function parseChunks(packet: Buffer): ParsedChunk[];
+/**
+ * Encode a TLV parameter, padded to 4 bytes.
+ * @param {number} type
+ * @param {Buffer} value
+ * @returns {Buffer}
+ */
+export declare function encodeParam(type: number, value: Buffer): Buffer;
+/**
+ * Parse TLV parameters from a buffer.
+ * @param {Buffer} buf
+ * @returns {Array<{type:number,length:number,value:Buffer}>}
+ */
+export declare function parseParams(buf: Buffer): ParsedParam[];
+/**
+ * Build an INIT or INIT_ACK fixed body (without parameters).
+ * @param {Object} p
+ * @param {number} p.initiateTag
+ * @param {number} p.a_rwnd - advertised receiver window
+ * @param {number} p.outStreams
+ * @param {number} p.inStreams
+ * @param {number} p.initialTSN
+ * @returns {Buffer}
+ */
+export declare function encodeInitBody({ initiateTag, a_rwnd, outStreams, inStreams, initialTSN }: InitBodyParams): Buffer;
+/**
+ * Parse an INIT/INIT_ACK body.
+ * @param {Buffer} body
+ * @returns {{initiateTag:number,a_rwnd:number,outStreams:number,inStreams:number,initialTSN:number,params:Array}}
+ */
+export declare function parseInitBody(body: Buffer): ParsedInitBody;
+/**
+ * Encode a DATA chunk body (RFC 4960 §3.3.1).
+ * @param {Object} p
+ * @param {number} p.tsn
+ * @param {number} p.streamId
+ * @param {number} p.streamSeq
+ * @param {number} p.ppid
+ * @param {Buffer} p.userData
+ * @returns {{flags:number, body:Buffer}}
+ */
+export declare function encodeDataBody({ tsn, streamId, streamSeq, ppid, userData, unordered, beginning, ending }: DataBodyParams): EncodedDataBody;
+/**
+ * Parse a DATA chunk body.
+ * @param {number} flags
+ * @param {Buffer} body
+ */
+export declare function parseDataBody(flags: number, body: Buffer): ParsedDataBody;
+/**
+ * Encode a SACK chunk body (cumulative ack only, no gap/dup for simplicity but
+ * gap blocks supported via params).
+ * @param {Object} p
+ * @param {number} p.cumulativeTSNAck
+ * @param {number} p.a_rwnd
+ * @param {Array<[number,number]>} [p.gapBlocks] - [start,end] offsets from cumAck+1
+ * @param {Array<number>} [p.dupTSNs]
+ * @returns {Buffer}
+ */
+export declare function encodeSackBody({ cumulativeTSNAck, a_rwnd, gapBlocks, dupTSNs }: SackBodyParams): Buffer;
+/**
+ * Parse a SACK chunk body.
+ */
+export declare function parseSackBody(body: Buffer): ParsedSackBody;

package/types/sctp/crc32c.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file crc32c.ts
+ * @description CRC-32C (Castagnoli) checksum for SCTP packets (RFC 4960 App. B,
+ * polynomial 0x1EDC6F41), reflected input/output, used with the SCTP-specific
+ * byte ordering described in RFC 4960 §6.8 / RFC 3309.
+ * @module sctp/crc32c
+ */
+/**
+ * Compute the raw reflected CRC-32C over a buffer.
+ * @returns unsigned 32-bit
+ */
+export declare function crc32c(buf: Buffer): number;
+/**
+ * Insert the SCTP checksum into a packet. The checksum field (bytes 8..11 of
+ * the common header) is zeroed, the CRC computed over the whole packet, then
+ * written back in little-endian byte order (RFC 4960 §6.8, RFC 3309).
+ * @param packet - full SCTP packet (header + chunks)
+ * @returns the same packet, checksum filled in
+ */
+export declare function applyChecksum(packet: Buffer): Buffer;
+/**
+ * Validate the checksum of a received SCTP packet.
+ */
+export declare function verifyChecksum(packet: Buffer): boolean;