@blockcast/mmt-transport 0.2.0

package/src/driad-discovery.ts

@@ -0,0 +1,193 @@
+/**
+ * @blockcast/transport - DRIAD Discovery (RFC 8777)
+ *
+ * DRIAD (DNS Reverse IP AMT Discovery) discovers AMT relays based on the
+ * **source address**, NOT the multicast group. The source network operator
+ * configures DNS records for their source IPs to advertise which AMT relay(s)
+ * can tunnel their traffic.
+ *
+ * Example: For source 69.25.95.10 sending to group 232.0.0.1:
+ *   Query: 10.95.25.69.amt.in-addr.arpa (source-based, NOT group-based)
+ */
+
+import type { DRIADRelay } from "./types.js";
+
+/**
+ * DRIAD (DNS Reverse IP AMT Discovery) - RFC 8777
+ * Discovers AMT relays based on source address via DNS lookups
+ */
+export class DRIADDiscovery {
+	private cache = new Map<string, DRIADRelay[]>();
+	private cacheExpiry = 300_000; // 5 minutes
+
+	/**
+	 * Discover AMT relays for a multicast source address (RFC 8777)
+	 *
+	 * @param source - The multicast source IP address (NOT the group!)
+	 * @returns Array of discovered AMT relays that can tunnel traffic from this source
+	 */
+	async discoverRelays(source: string): Promise<DRIADRelay[]> {
+		// Check cache first
+		const cached = this.cache.get(source);
+		if (cached) {
+			return cached;
+		}
+
+		try {
+			// Convert source to DRIAD format (reversed octets)
+			const reversedSource = source.split(".").reverse().join(".");
+			const queryDomain = `${reversedSource}.amt.in-addr.arpa`;
+
+			console.log(`[DRIAD] Discovering relays for source ${source} via ${queryDomain}`);
+
+			// In browser, we use a DRIAD proxy service or DNS-over-HTTPS
+			const relays = await this.queryDRIADProxy(source);
+
+			if (relays.length > 0) {
+				this.cache.set(source, relays);
+				setTimeout(() => this.cache.delete(source), this.cacheExpiry);
+			}
+
+			return relays;
+		} catch (error) {
+			console.warn(`[DRIAD] Discovery failed for source ${source}:`, error);
+			return [];
+		}
+	}
+
+	/**
+	 * Query DRIAD proxy service (browser-compatible)
+	 */
+	private async queryDRIADProxy(source: string): Promise<DRIADRelay[]> {
+		// List of known DRIAD proxy endpoints
+		const proxyEndpoints = [
+			"https://driad.amt.net/api/v1/relays",
+			"https://multicast-gateway.cloudflare.com/driad",
+		];
+
+		for (const endpoint of proxyEndpoints) {
+			try {
+				// Query by source address per RFC 8777
+				const response = await fetch(`${endpoint}?source=${encodeURIComponent(source)}`, {
+					method: "GET",
+					headers: { Accept: "application/json" },
+					signal: AbortSignal.timeout(5000),
+				});
+
+				if (response.ok) {
+					const data = (await response.json()) as { relays: DRIADRelay[] };
+					return data.relays || [];
+				}
+			} catch {
+				// Try next proxy endpoint
+			}
+		}
+
+		// Fallback: Try DNS-over-HTTPS query
+		const dohRelay = await this.queryDNSOverHTTPS(source);
+		if (dohRelay) {
+			return [dohRelay];
+		}
+
+		// Final fallback to well-known AMT relays
+		return [
+			{ host: "amt-relay.m2icast.net", port: 2268, priority: 10, weight: 100, asn: 0 },
+			{ host: "amt.akamaistream.net", port: 2268, priority: 20, weight: 50, asn: 0 },
+		];
+	}
+
+	/**
+	 * Query DNS-over-HTTPS for DRIAD relay based on source address (RFC 8777)
+	 */
+	private async queryDNSOverHTTPS(source: string): Promise<DRIADRelay | null> {
+		try {
+			// Build DRIAD query name from source address (reversed octets)
+			const reversedSource = source.split(".").reverse().join(".");
+			const queryName = `${reversedSource}.amt.in-addr.arpa`;
+
+			const dohUrl = `https://cloudflare-dns.com/dns-query?name=${queryName}&type=A`;
+			const response = await fetch(dohUrl, {
+				headers: { Accept: "application/dns-json" },
+				signal: AbortSignal.timeout(3000),
+			});
+
+			if (!response.ok) {
+				return null;
+			}
+
+			const result = (await response.json()) as { Answer?: Array<{ data: string }> };
+
+			// Extract first A/AAAA record
+			if (result.Answer && result.Answer.length > 0) {
+				return {
+					host: result.Answer[0].data,
+					port: 2268,
+					priority: 10,
+					weight: 100,
+					asn: 0,
+				};
+			}
+
+			return null;
+		} catch (error) {
+			console.warn("[DRIAD] DNS-over-HTTPS query failed:", error);
+			return null;
+		}
+	}
+
+	/**
+	 * Select best relay based on RTT measurements
+	 */
+	async selectBestRelay(relays: DRIADRelay[]): Promise<DRIADRelay | null> {
+		if (relays.length === 0) return null;
+
+		// Measure RTT to each relay
+		const measured = await Promise.all(
+			relays.map(async (relay) => {
+				const rtt = await this.measureRTT(relay.host, relay.port);
+				return { ...relay, rtt };
+			}),
+		);
+
+		// Sort by priority, then by RTT
+		measured.sort((a, b) => {
+			if (a.priority !== b.priority) return a.priority - b.priority;
+			return (a.rtt || Infinity) - (b.rtt || Infinity);
+		});
+
+		console.log(`[DRIAD] Selected relay: ${measured[0].host} (RTT: ${measured[0].rtt}ms)`);
+		return measured[0];
+	}
+
+	private async measureRTT(host: string, _port: number): Promise<number> {
+		const start = performance.now();
+		try {
+			// Use HTTP/HTTPS probe since we can't do UDP from browser
+			await fetch(`https://${host}/health`, {
+				method: "HEAD",
+				signal: AbortSignal.timeout(2000),
+				mode: "no-cors",
+			});
+			return performance.now() - start;
+		} catch {
+			return Infinity;
+		}
+	}
+
+	/**
+	 * Clear the relay cache
+	 */
+	clearCache(): void {
+		this.cache.clear();
+	}
+
+	/**
+	 * Get cached relays for a source address
+	 */
+	getCached(source: string): DRIADRelay[] | undefined {
+		return this.cache.get(source);
+	}
+}
+
+// Export singleton instance
+export const driadDiscovery = new DRIADDiscovery();

package/src/fec-client.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Tests for FEC Client
+ *
+ * Note: MmtFecClient requires WASM module which is tested separately in mmt-wasm.
+ * These tests cover the pure TypeScript parts (MfuReassembler) and type exports.
+ */
+
+import { describe, expect, it, beforeEach } from "vitest";
+import type { FecDecoderConfig, MoqFecClientConfig } from "./fec-client.js";
+import { MoqFecClient } from "./fec-client.js";
+
+describe("FecDecoderConfig interface", () => {
+	it("should have correct shape", () => {
+		const config: FecDecoderConfig = {
+			symbolSize: 1280,
+			sourceBlocks: 1,
+			subBlocks: 1,
+			alignment: 8,
+			interleaveDepth: 30,
+		};
+
+		expect(config.symbolSize).toBe(1280);
+		expect(config.sourceBlocks).toBe(1);
+		expect(config.subBlocks).toBe(1);
+		expect(config.alignment).toBe(8);
+		expect(config.interleaveDepth).toBe(30);
+	});
+});
+
+describe("MoqFecClient", () => {
+	let client: MoqFecClient;
+
+	beforeEach(() => {
+		client = new MoqFecClient({
+			symbolSize: 1280,
+			k: 10,
+			p: 3,
+			interleaveDepth: 30,
+		});
+	});
+
+	it("should create with default config", () => {
+		const defaultClient = new MoqFecClient();
+		const config = defaultClient.getConfig();
+
+		expect(config.symbolSize).toBe(1280);
+		expect(config.k).toBe(10);
+		expect(config.p).toBe(3);
+		expect(config.interleaveDepth).toBe(30);
+	});
+
+	it("should create with custom config", () => {
+		const config = client.getConfig();
+
+		expect(config.symbolSize).toBe(1280);
+		expect(config.k).toBe(10);
+		expect(config.p).toBe(3);
+		expect(config.interleaveDepth).toBe(30);
+	});
+
+	it("should not be initialized without WASM module", () => {
+		expect(client.isInitialized()).toBe(false);
+		expect(client.isDecoderReady()).toBe(false);
+	});
+
+	it("should return default stats when not initialized", () => {
+		const stats = client.getStats();
+
+		expect(stats.blocksComplete).toBe(0);
+		expect(stats.blocksIncomplete).toBe(0);
+		expect(stats.totalSymbolsReceived).toBe(0);
+		expect(stats.effectiveLossRate).toBe(0);
+		expect(stats.recoveryRate).toBe(1);
+	});
+
+	it("should return ABR stats when not initialized", () => {
+		const abrStats = client.getAbrStats();
+
+		expect(abrStats.effectiveLossRate).toBe(0);
+		expect(abrStats.rawLossRate).toBe(0);
+		expect(abrStats.recoveryRate).toBe(1);
+		expect(abrStats.fecEnabled).toBe(false);
+	});
+
+	it("should calculate max block size", () => {
+		// Without WASM, uses config values: k * symbolSize
+		const maxSize = client.getMaxBlockSize();
+		expect(maxSize).toBe(10 * 1280); // k=10, symbolSize=1280
+	});
+
+	it("should calculate overhead ratio", () => {
+		// Without WASM, uses config values: p / k
+		const overhead = client.getOverheadRatio();
+		expect(overhead).toBe(3 / 10); // p=3, k=10
+	});
+
+	it("should throw when encoding without initialization", () => {
+		expect(() => client.encodeBlock(new Uint8Array(100))).toThrow(
+			"MoqFecClient not initialized"
+		);
+	});
+
+	it("should return null when adding source symbol without decoder", () => {
+		const result = client.addSourceSymbol(0, 0, new Uint8Array(100));
+		expect(result).toBeNull();
+	});
+
+	it("should return null when adding repair symbol without decoder", () => {
+		const result = client.addRepairSymbol(0, 0, new Uint8Array(100));
+		expect(result).toBeNull();
+	});
+
+	it("should dispose cleanly", () => {
+		client.dispose();
+		expect(client.isInitialized()).toBe(false);
+		expect(client.getOti()).toBeNull();
+	});
+
+	it("should reject invalid OTI length", () => {
+		expect(() => client.setOti(new Uint8Array(10))).toThrow(
+			"OTI must be exactly 12 bytes"
+		);
+	});
+});
+
+describe("MoqFecClientConfig type", () => {
+	it("should allow partial config", () => {
+		const partial: Partial<MoqFecClientConfig> = {
+			k: 20,
+		};
+
+		const client = new MoqFecClient(partial);
+		const config = client.getConfig();
+
+		expect(config.k).toBe(20);
+		expect(config.p).toBe(3); // default
+		expect(config.symbolSize).toBe(1280); // default
+		expect(config.interleaveDepth).toBe(30); // default
+	});
+});