werift 0.20.0 → 0.21.0

package/lib/ice/src/ice.js

@@ -3,23 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CandidatePairState = exports.CandidatePair = exports.Connection = void 0;
-exports.validateRemoteCandidate = validateRemoteCandidate;
-exports.sortCandidatePairs = sortCandidatePairs;
-exports.candidatePairPriority = candidatePairPriority;
-exports.serverReflexiveCandidate = serverReflexiveCandidate;
-exports.validateAddress = validateAddress;
+exports.Connection = void 0;
 const crypto_1 = require("crypto");
 const net_1 = require("net");
 const debug_1 = __importDefault(require("debug"));
 const int64_buffer_1 = require("int64-buffer");
 const isEqual_1 = __importDefault(require("lodash/isEqual"));
-const p_cancelable_1 = __importDefault(require("p-cancelable"));
-const rx_mini_1 = require("rx.mini");
 const promises_1 = __importDefault(require("timers/promises"));
+const common_1 = require("./imports/common");
 const candidate_1 = require("./candidate");
 const lookup_1 = require("./dns/lookup");
 const helper_1 = require("./helper");
+const iceBase_1 = require("./iceBase");
 const const_1 = require("./stun/const");
 const message_1 = require("./stun/message");
 const protocol_1 = require("./stun/protocol");
@@ -27,14 +22,14 @@ const protocol_2 = require("./turn/protocol");
 const utils_1 = require("./utils");
 const log = (0, debug_1.default)("werift-ice : packages/ice/src/ice.ts : log");
 class Connection {
-    constructor(iceControlling, options) {
-        Object.defineProperty(this, "iceControlling", {
+    constructor(_iceControlling, options) {
+        Object.defineProperty(this, "_iceControlling", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: iceControlling
+            value: _iceControlling
         });
-        Object.defineProperty(this, "localUserName", {
+        Object.defineProperty(this, "localUsername", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -46,23 +41,23 @@ class Connection {
             writable: true,
             value: (0, helper_1.randomString)(22)
         });
-        Object.defineProperty(this, "remotePassword", {
+        Object.defineProperty(this, "remoteIsLite", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: ""
+            value: false
         });
-        Object.defineProperty(this, "remoteUsername", {
+        Object.defineProperty(this, "remotePassword", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: ""
         });
-        Object.defineProperty(this, "remoteIsLite", {
+        Object.defineProperty(this, "remoteUsername", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: ""
         });
         Object.defineProperty(this, "checkList", {
             enumerable: true,
@@ -88,37 +83,37 @@ class Connection {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "useIpv4", {
+        Object.defineProperty(this, "options", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "useIpv6", {
+        Object.defineProperty(this, "remoteCandidatesEnd", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: false
         });
-        Object.defineProperty(this, "options", {
+        Object.defineProperty(this, "localCandidatesEnd", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: false
         });
-        Object.defineProperty(this, "remoteCandidatesEnd", {
+        Object.defineProperty(this, "generation", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: -1
         });
-        Object.defineProperty(this, "_localCandidatesEnd", {
+        Object.defineProperty(this, "userHistory", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: {}
         });
-        Object.defineProperty(this, "_tieBreaker", {
+        Object.defineProperty(this, "tieBreaker", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -136,24 +131,6 @@ class Connection {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "restarted", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "onData", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new rx_mini_1.Event()
-        });
-        Object.defineProperty(this, "stateChanged", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new rx_mini_1.Event()
-        });
         Object.defineProperty(this, "_remoteCandidates", {
             enumerable: true,
             configurable: true,
@@ -191,6 +168,12 @@ class Connection {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "earlyChecksDone", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "localCandidatesStart", {
             enumerable: true,
             configurable: true,
@@ -215,66 +198,101 @@ class Connection {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "onData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new common_1.Event()
+        });
+        Object.defineProperty(this, "stateChanged", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new common_1.Event()
+        });
+        Object.defineProperty(this, "onIceCandidate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new common_1.Event()
+        });
         // 4.1.1.4 ? 生存確認 life check
         Object.defineProperty(this, "queryConsent", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: () => new p_cancelable_1.default(async (r, f, onCancel) => {
-                let failures = 0;
-                const cancelEvent = new AbortController();
-                onCancel(() => {
-                    failures += CONSENT_FAILURES;
-                    cancelEvent.abort();
-                    f("cancel");
-                });
-                // """
-                // Periodically check consent (RFC 7675).
-                // """
-                try {
-                    while (!this.remoteIsLite && this.state !== "closed") {
-                        // # randomize between 0.8 and 1.2 times CONSENT_INTERVAL
-                        await promises_1.default.setTimeout(CONSENT_INTERVAL * (0.8 + 0.4 * Math.random()) * 1000, undefined, { signal: cancelEvent.signal });
-                        const pair = this.nominated;
-                        if (!pair) {
-                            break;
-                        }
-                        const request = this.buildRequest(pair, false);
-                        try {
-                            const [msg, addr] = await pair.protocol.request(request, pair.remoteAddr, Buffer.from(this.remotePassword, "utf8"), 0);
-                            failures = 0;
-                            if (this.state === "disconnected") {
-                                this.setState("connected");
+            value: () => {
+                if (this.queryConsentHandle) {
+                    this.queryConsentHandle.resolve();
+                }
+                this.queryConsentHandle = (0, helper_1.cancelable)(async (_, __, onCancel) => {
+                    let failures = 0;
+                    let canceled = false;
+                    const cancelEvent = new AbortController();
+                    onCancel.once(() => {
+                        canceled = true;
+                        failures += iceBase_1.CONSENT_FAILURES;
+                        cancelEvent.abort();
+                        this.queryConsentHandle = undefined;
+                    });
+                    const { localUsername, remoteUsername, iceControlling } = this;
+                    // """
+                    // Periodically check consent (RFC 7675).
+                    // """
+                    try {
+                        while (this.state !== "closed" && !canceled) {
+                            // # randomize between 0.8 and 1.2 times CONSENT_INTERVAL
+                            await promises_1.default.setTimeout(iceBase_1.CONSENT_INTERVAL * (0.8 + 0.4 * Math.random()) * 1000, undefined, { signal: cancelEvent.signal });
+                            const nominated = this.nominated;
+                            if (!nominated || canceled) {
+                                break;
+                            }
+                            const request = this.buildRequest({
+                                nominate: false,
+                                localUsername,
+                                remoteUsername,
+                                iceControlling,
+                            });
+                            try {
+                                await nominated.protocol.request(request, nominated.remoteAddr, Buffer.from(this.remotePassword, "utf8"), 0);
+                                failures = 0;
+                                if (this.state === "disconnected") {
+                                    this.setState("connected");
+                                }
+                            }
+                            catch (error) {
+                                if (nominated.id === this.nominated?.id) {
+                                    log("no stun response");
+                                    failures++;
+                                    this.setState("disconnected");
+                                    break;
+                                }
+                            }
+                            if (failures >= iceBase_1.CONSENT_FAILURES) {
+                                log("Consent to send expired");
+                                this.queryConsentHandle = undefined;
+                                this.setState("closed");
+                                break;
                             }
-                        }
-                        catch (error) {
-                            log("no stun response");
-                            failures++;
-                            this.setState("disconnected");
-                        }
-                        if (failures >= CONSENT_FAILURES) {
-                            log("Consent to send expired");
-                            this.queryConsentHandle = undefined;
-                            // 切断検知
-                            r(await this.close());
-                            return;
                         }
                     }
-                }
-                catch (error) { }
-            })
+                    catch (error) { }
+                });
+            }
         });
         Object.defineProperty(this, "send", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: async (data) => {
-                // """
-                // Send a datagram on the first component.
-                // If the connection is not established, a `ConnectionError` is raised.
-                // :param data: The data to be sent.
-                // """
-                await this.sendTo(data);
+                const activePair = this.nominated;
+                if (activePair) {
+                    await activePair.protocol.sendData(data, activePair.remoteAddr);
+                }
+                else {
+                    // log("Cannot send data, ice not connected");
+                    return;
+                }
             }
         });
         // 3.  Terminology : Check
@@ -282,26 +300,42 @@ class Connection {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: (pair) => new p_cancelable_1.default(async (r, f, onCancel) => {
-                onCancel(() => f("cancel"));
+            value: (pair) => (0, helper_1.cancelable)(async (r) => {
                 // """
                 // Starts a check.
                 // """
                 log("check start", pair.toJSON());
-                this.setPairState(pair, CandidatePairState.IN_PROGRESS);
-                const nominate = this.iceControlling && !this.remoteIsLite;
-                const request = this.buildRequest(pair, nominate);
+                pair.updateState(iceBase_1.CandidatePairState.IN_PROGRESS);
                 const result = {};
+                const { remotePassword, remoteUsername, generation } = this;
+                const localUsername = pair.localCandidate.ufrag ?? this.localUsername;
+                const nominate = this.iceControlling && !this.remoteIsLite;
+                const request = this.buildRequest({
+                    nominate,
+                    localUsername,
+                    remoteUsername,
+                    iceControlling: this.iceControlling,
+                });
                 try {
-                    const [response, addr] = await pair.protocol.request(request, pair.remoteAddr, Buffer.from(this.remotePassword, "utf8"), 4);
-                    log("response", response, addr);
+                    const [response, addr] = await pair.protocol.request(request, pair.remoteAddr, Buffer.from(remotePassword, "utf8"), 4);
+                    log("response received", request.toJSON(), response.toJSON(), addr, {
+                        localUsername,
+                        remoteUsername,
+                        remotePassword,
+                        generation,
+                    });
                     result.response = response;
                     result.addr = addr;
                 }
                 catch (error) {
                     const exc = error;
                     // 7.1.3.1.  Failure Cases
-                    log("failure case", exc.response);
+                    log("failure case", request.toJSON(), exc.response ? JSON.stringify(exc.response.toJSON(), null, 2) : error, {
+                        localUsername,
+                        remoteUsername,
+                        remotePassword,
+                        generation,
+                    });
                     if (exc.response?.getAttributeValue("ERROR-CODE")[0] === 487) {
                         if (request.attributesKeys.includes("ICE-CONTROLLED")) {
                             this.switchRole(true);
@@ -309,14 +343,20 @@ class Connection {
                         else if (request.attributesKeys.includes("ICE-CONTROLLING")) {
                             this.switchRole(false);
                         }
-                        await this.checkStart(pair);
+                        await this.checkStart(pair).awaitable;
+                        r();
+                        return;
+                    }
+                    if (exc.response?.getAttributeValue("ERROR-CODE")[0] === 401) {
+                        log("retry 401", pair.toJSON());
+                        await this.checkStart(pair).awaitable;
                         r();
                         return;
                     }
                     else {
                         // timeout
-                        log("CandidatePairState.FAILED", pair.toJSON());
-                        this.setPairState(pair, CandidatePairState.FAILED);
+                        log("checkStart CandidatePairState.FAILED", pair.toJSON());
+                        pair.updateState(iceBase_1.CandidatePairState.FAILED);
                         this.checkComplete(pair);
                         r();
                         return;
@@ -324,7 +364,7 @@ class Connection {
                 }
                 // # check remote address matches
                 if (!(0, isEqual_1.default)(result.addr, pair.remoteAddr)) {
-                    this.setPairState(pair, CandidatePairState.FAILED);
+                    pair.updateState(iceBase_1.CandidatePairState.FAILED);
                     this.checkComplete(pair);
                     r();
                     return;
@@ -337,18 +377,23 @@ class Connection {
                 else if (this.iceControlling && !this.nominating) {
                     // # perform regular nomination
                     this.nominating = true;
-                    const request = this.buildRequest(pair, true);
+                    const request = this.buildRequest({
+                        nominate: true,
+                        localUsername,
+                        remoteUsername,
+                        iceControlling: this.iceControlling,
+                    });
                     try {
                         await pair.protocol.request(request, pair.remoteAddr, Buffer.from(this.remotePassword, "utf8"));
                     }
                     catch (error) {
-                        this.setPairState(pair, CandidatePairState.FAILED);
+                        pair.updateState(iceBase_1.CandidatePairState.FAILED);
                         this.checkComplete(pair);
                         return;
                     }
                     pair.nominated = true;
                 }
-                this.setPairState(pair, CandidatePairState.SUCCEEDED);
+                pair.updateState(iceBase_1.CandidatePairState.SUCCEEDED);
                 this.checkComplete(pair);
                 r();
             })
@@ -364,14 +409,71 @@ class Connection {
             }
         });
         this.options = {
-            ...defaultOptions,
+            ...iceBase_1.defaultOptions,
             ...options,
         };
-        const { stunServer, turnServer, useIpv4, useIpv6 } = this.options;
-        this.stunServer = validateAddress(stunServer);
-        this.turnServer = validateAddress(turnServer);
-        this.useIpv4 = useIpv4;
-        this.useIpv6 = useIpv6;
+        const { stunServer, turnServer } = this.options;
+        this.stunServer = (0, iceBase_1.validateAddress)(stunServer) ?? [
+            "stun.l.google.com",
+            19302,
+        ];
+        this.turnServer = (0, iceBase_1.validateAddress)(turnServer);
+        this.restart();
+    }
+    get iceControlling() {
+        return this._iceControlling;
+    }
+    set iceControlling(value) {
+        if (this.generation > 0 || this.nominated) {
+            return;
+        }
+        this._iceControlling = value;
+        for (const pair of this.checkList) {
+            pair.iceControlling = value;
+        }
+    }
+    async restart() {
+        this.generation++;
+        this.localUsername = (0, helper_1.randomString)(4);
+        this.localPassword = (0, helper_1.randomString)(22);
+        if (this.options.localPasswordPrefix) {
+            this.localPassword =
+                this.options.localPasswordPrefix +
+                    this.localPassword.slice(this.options.localPasswordPrefix.length);
+        }
+        this.userHistory[this.localUsername] = this.localPassword;
+        this.remoteUsername = "";
+        this.remotePassword = "";
+        this.localCandidates = [];
+        this._remoteCandidates = [];
+        this.remoteCandidatesEnd = false;
+        this.localCandidatesEnd = false;
+        this.state = "new";
+        this.lookup?.close?.();
+        this.lookup = undefined;
+        this.nominated = undefined;
+        this.nominating = false;
+        this.checkList = [];
+        this.checkListDone = false;
+        this.checkListState = new helper_1.PQueue();
+        this.earlyChecks = [];
+        this.earlyChecksDone = false;
+        this.localCandidatesStart = false;
+        // protocolsはincomingのearlyCheckに使うかもしれないので残す
+        for (const protocol of this.protocols) {
+            if (protocol.localCandidate) {
+                protocol.localCandidate.generation = this.generation;
+                protocol.localCandidate.ufrag = this.localUsername;
+            }
+        }
+        this.queryConsentHandle?.resolve?.();
+        this.queryConsentHandle = undefined;
+        this.promiseGatherCandidates = undefined;
+    }
+    resetNominatedPair() {
+        log("resetNominatedPair");
+        this.nominated = undefined;
+        this.nominating = false;
     }
     setRemoteParams({ iceLite, usernameFragment, password, }) {
         log("setRemoteParams", { iceLite, usernameFragment, password });
@@ -380,11 +482,11 @@ class Connection {
         this.remotePassword = password;
     }
     // 4.1.1 Gathering Candidates
-    async gatherCandidates(cb) {
+    async gatherCandidates() {
         if (!this.localCandidatesStart) {
             this.localCandidatesStart = true;
-            this.promiseGatherCandidates = new rx_mini_1.Event();
-            let address = (0, utils_1.getHostAddresses)(this.useIpv4, this.useIpv6);
+            this.promiseGatherCandidates = new common_1.Event();
+            let address = (0, utils_1.getHostAddresses)(this.options.useIpv4, this.options.useIpv6);
             const { interfaceAddresses } = this.options;
             if (interfaceAddresses) {
                 const filteredAddresses = address.filter((check) => Object.values(interfaceAddresses).includes(check));
@@ -395,18 +497,86 @@ class Connection {
             if (this.options.additionalHostAddresses) {
                 address = Array.from(new Set([...this.options.additionalHostAddresses, ...address]));
             }
-            const candidates = await this.getCandidates(address, 5, cb);
+            const candidates = await this.getCandidates(address, 5);
             this.localCandidates = [...this.localCandidates, ...candidates];
-            this._localCandidatesEnd = true;
+            this.localCandidatesEnd = true;
             this.promiseGatherCandidates.execute();
         }
         this.setState("completed");
     }
-    async getCandidates(addresses, timeout = 5, cb) {
+    ensureProtocol(protocol) {
+        protocol.onRequestReceived.subscribe((msg, addr, data) => {
+            if (msg.messageMethod !== const_1.methods.BINDING) {
+                this.respondError(msg, addr, protocol, [400, "Bad Request"]);
+                return;
+            }
+            const txUsername = msg.getAttributeValue("USERNAME");
+            // 相手にとってのremoteは自分にとってのlocal
+            const { remoteUsername: localUsername } = decodeTxUsername(txUsername);
+            const localPassword = this.userHistory[localUsername] ?? this.localPassword;
+            const { iceControlling } = this;
+            // 7.2.1.1.  Detecting and Repairing Role Conflicts
+            if (iceControlling && msg.attributesKeys.includes("ICE-CONTROLLING")) {
+                if (this.tieBreaker >= msg.getAttributeValue("ICE-CONTROLLING")) {
+                    this.respondError(msg, addr, protocol, [487, "Role Conflict"]);
+                    return;
+                }
+                else {
+                    this.switchRole(false);
+                }
+            }
+            else if (!iceControlling &&
+                msg.attributesKeys.includes("ICE-CONTROLLED")) {
+                if (this.tieBreaker < msg.getAttributeValue("ICE-CONTROLLED")) {
+                    this.respondError(msg, addr, protocol, [487, "Role Conflict"]);
+                }
+                else {
+                    this.switchRole(true);
+                    return;
+                }
+            }
+            if (this.options.filterStunResponse &&
+                !this.options.filterStunResponse(msg, addr, protocol)) {
+                return;
+            }
+            // # send binding response
+            const response = new message_1.Message(const_1.methods.BINDING, const_1.classes.RESPONSE, msg.transactionId);
+            response
+                .setAttribute("XOR-MAPPED-ADDRESS", addr)
+                .addMessageIntegrity(Buffer.from(localPassword, "utf8"))
+                .addFingerprint();
+            protocol.sendStun(response, addr).catch((e) => {
+                log("sendStun error", e);
+            });
+            if (this.checkList.length === 0 && !this.earlyChecksDone) {
+                this.earlyChecks.push([msg, addr, protocol]);
+            }
+            else {
+                this.checkIncoming(msg, addr, protocol);
+            }
+        });
+        protocol.onDataReceived.subscribe((data) => {
+            try {
+                this.onData.execute(data);
+            }
+            catch (error) {
+                log("dataReceived", error);
+            }
+        });
+    }
+    async getCandidates(addresses, timeout = 5) {
         let candidates = [];
+        addresses = addresses.filter((address) => {
+            // ice restartで同じアドレスが追加されるのを防ぐ
+            if (this.protocols.find((protocol) => protocol.localIp === address)) {
+                return false;
+            }
+            return true;
+        });
         await Promise.allSettled(addresses.map(async (address) => {
             // # create transport
-            const protocol = new protocol_1.StunProtocol(this);
+            const protocol = new protocol_1.StunProtocol();
+            this.ensureProtocol(protocol);
             try {
                 await protocol.connectionMade((0, net_1.isIPv4)(address), this.options.portRange, this.options.interfaceAddresses);
             }
@@ -414,16 +584,14 @@ class Connection {
                 log("protocol STUN", error);
                 return;
             }
-            protocol.localAddress = address;
+            protocol.localIp = address;
             this.protocols.push(protocol);
             // # add host candidate
             const candidateAddress = [address, protocol.getExtraInfo()[1]];
-            protocol.localCandidate = new candidate_1.Candidate((0, candidate_1.candidateFoundation)("host", "udp", candidateAddress[0]), 1, "udp", (0, candidate_1.candidatePriority)(1, "host"), candidateAddress[0], candidateAddress[1], "host");
+            protocol.localCandidate = new candidate_1.Candidate((0, candidate_1.candidateFoundation)("host", "udp", candidateAddress[0]), 1, "udp", (0, candidate_1.candidatePriority)("host"), candidateAddress[0], candidateAddress[1], "host", undefined, undefined, undefined, this.generation, this.localUsername);
             this.pairLocalProtocol(protocol);
             candidates.push(protocol.localCandidate);
-            if (cb) {
-                cb(protocol.localCandidate);
-            }
+            this.onIceCandidate.execute(protocol.localCandidate);
         }));
         let candidatePromises = [];
         // # query STUN server for server-reflexive candidates (IPv4 only)
@@ -433,9 +601,12 @@ class Connection {
                 const timer = setTimeout(f, timeout * 1000);
                 if (protocol.localCandidate?.host &&
                     (0, net_1.isIPv4)(protocol.localCandidate?.host)) {
-                    const candidate = await serverReflexiveCandidate(protocol, stunServer).catch((error) => log("error", error));
-                    if (candidate && cb)
-                        cb(candidate);
+                    const candidate = await (0, iceBase_1.serverReflexiveCandidate)(protocol, stunServer).catch((error) => {
+                        log("error", error);
+                    });
+                    if (candidate) {
+                        this.onIceCandidate.execute(candidate);
+                    }
                     clearTimeout(timer);
                     r(candidate);
                 }
@@ -451,19 +622,37 @@ class Connection {
         const { turnUsername, turnPassword } = this.options;
         if (turnServer && turnUsername && turnPassword) {
             const turnCandidate = (async () => {
-                const protocol = await (0, protocol_2.createTurnEndpoint)(turnServer, turnUsername, turnPassword, {
+                const protocol = await (0, protocol_2.createStunOverTurnClient)({
+                    address: turnServer,
+                    username: turnUsername,
+                    password: turnPassword,
+                }, {
                     portRange: this.options.portRange,
                     interfaceAddresses: this.options.interfaceAddresses,
+                    transport: this.options.turnTransport === "tcp" ? "tcp" : "udp",
+                }).catch(async (e) => {
+                    if (this.options.turnTransport !== "tcp") {
+                        return await (0, protocol_2.createStunOverTurnClient)({
+                            address: turnServer,
+                            username: turnUsername,
+                            password: turnPassword,
+                        }, {
+                            portRange: this.options.portRange,
+                            interfaceAddresses: this.options.interfaceAddresses,
+                            transport: "tcp",
+                        });
+                    }
+                    else {
+                        throw e;
+                    }
                 });
+                this.ensureProtocol(protocol);
                 this.protocols.push(protocol);
                 const candidateAddress = protocol.turn.relayedAddress;
                 const relatedAddress = protocol.turn.mappedAddress;
                 log("turn candidateAddress", candidateAddress);
-                protocol.localCandidate = new candidate_1.Candidate((0, candidate_1.candidateFoundation)("relay", "udp", candidateAddress[0]), 1, "udp", (0, candidate_1.candidatePriority)(1, "relay"), candidateAddress[0], candidateAddress[1], "relay", relatedAddress[0], relatedAddress[1]);
-                if (cb) {
-                    cb(protocol.localCandidate);
-                }
-                protocol.receiver = this;
+                protocol.localCandidate = new candidate_1.Candidate((0, candidate_1.candidateFoundation)("relay", "udp", candidateAddress[0]), 1, "udp", (0, candidate_1.candidatePriority)("relay"), candidateAddress[0], candidateAddress[1], "relay", relatedAddress[0], relatedAddress[1], undefined, this.generation, this.localUsername);
+                this.onIceCandidate.execute(protocol.localCandidate);
                 return protocol.localCandidate;
             })().catch((error) => {
                 log("query TURN server", error);
@@ -488,23 +677,32 @@ class Connection {
         // This coroutine returns if a candidate pair was successfully nominated
         // and raises an exception otherwise.
         // """
-        log("start connect ice", this.localCandidates);
-        if (!this._localCandidatesEnd) {
-            if (!this.localCandidatesStart)
+        log("start connect ice");
+        if (!this.localCandidatesEnd) {
+            if (!this.localCandidatesStart) {
                 throw new Error("Local candidates gathering was not performed");
-            if (this.promiseGatherCandidates)
+            }
+            if (this.promiseGatherCandidates) {
                 // wait for GatherCandidates finish
                 await this.promiseGatherCandidates.asPromise();
+            }
         }
-        if (!this.remoteUsername || !this.remotePassword)
+        if (!this.remoteUsername || !this.remotePassword) {
             throw new Error("Remote username or password is missing");
+        }
         // # 5.7.1. Forming Candidate Pairs
-        this.remoteCandidates.forEach(this.pairRemoteCandidate);
+        for (const c of this.remoteCandidates) {
+            this.pairRemoteCandidate(c);
+        }
         this.sortCheckList();
         this.unfreezeInitial();
+        log("earlyChecks", this.localPassword, this.earlyChecks.length);
         // # handle early checks
-        this.earlyChecks.forEach((earlyCheck) => this.checkIncoming(...earlyCheck));
+        for (const earlyCheck of this.earlyChecks) {
+            this.checkIncoming(...earlyCheck);
+        }
         this.earlyChecks = [];
+        this.earlyChecksDone = true;
         // # perform checks
         // 5.8.  Scheduling Checks
         for (;;) {
@@ -515,17 +713,19 @@ class Connection {
             await promises_1.default.setTimeout(20);
         }
         // # wait for completion
-        let res = ICE_FAILED;
-        while (this.checkList.length > 0 && res === ICE_FAILED) {
+        let res = iceBase_1.ICE_FAILED;
+        while (this.checkList.length > 0 && res === iceBase_1.ICE_FAILED) {
             res = await this.checkListState.get();
         }
         // # cancel remaining checks
-        this.checkList.forEach((check) => check.handle?.cancel());
-        if (res !== ICE_COMPLETED) {
+        for (const check of this.checkList) {
+            check.handle?.resolve?.();
+        }
+        if (res !== iceBase_1.ICE_COMPLETED) {
             throw new Error("ICE negotiation failed");
         }
         // # start consent freshness tests
-        this.queryConsentHandle = (0, helper_1.future)(this.queryConsent());
+        this.queryConsent();
         this.setState("connected");
     }
     unfreezeInitial() {
@@ -533,16 +733,16 @@ class Connection {
         const [firstPair] = this.checkList;
         if (!firstPair)
             return;
-        if (firstPair.state === CandidatePairState.FROZEN) {
-            this.setPairState(firstPair, CandidatePairState.WAITING);
+        if (firstPair.state === iceBase_1.CandidatePairState.FROZEN) {
+            firstPair.updateState(iceBase_1.CandidatePairState.WAITING);
         }
         // # unfreeze pairs with same component but different foundations
         const seenFoundations = new Set(firstPair.localCandidate.foundation);
         for (const pair of this.checkList) {
             if (pair.component === firstPair.component &&
                 !seenFoundations.has(pair.localCandidate.foundation) &&
-                pair.state === CandidatePairState.FROZEN) {
-                this.setPairState(pair, CandidatePairState.WAITING);
+                pair.state === iceBase_1.CandidatePairState.FROZEN) {
+                pair.updateState(iceBase_1.CandidatePairState.WAITING);
                 seenFoundations.add(pair.localCandidate.foundation);
             }
         }
@@ -554,21 +754,22 @@ class Connection {
             // # find the highest-priority pair that is in the waiting state
             const pair = this.checkList
                 .filter((pair) => {
-                if (this.options.forceTurn && pair.protocol.type === "stun")
+                if (this.options.forceTurn &&
+                    pair.protocol.type === protocol_1.StunProtocol.type)
                     return false;
                 return true;
             })
-                .find((pair) => pair.state === CandidatePairState.WAITING);
+                .find((pair) => pair.state === iceBase_1.CandidatePairState.WAITING);
             if (pair) {
-                pair.handle = (0, helper_1.future)(this.checkStart(pair));
+                pair.handle = this.checkStart(pair);
                 return true;
             }
         }
         {
             // # find the highest-priority pair that is in the frozen state
-            const pair = this.checkList.find((pair) => pair.state === CandidatePairState.FROZEN);
+            const pair = this.checkList.find((pair) => pair.state === iceBase_1.CandidatePairState.FROZEN);
             if (pair) {
-                pair.handle = (0, helper_1.future)(this.checkStart(pair));
+                pair.handle = this.checkStart(pair);
                 return true;
             }
         }
@@ -584,19 +785,11 @@ class Connection {
         // """
         this.setState("closed");
         // # stop consent freshness tests
-        if (this.queryConsentHandle && !this.queryConsentHandle.done()) {
-            this.queryConsentHandle.cancel();
-            try {
-                await this.queryConsentHandle.promise;
-            }
-            catch (error) {
-                // pass
-            }
-        }
+        this.queryConsentHandle?.resolve?.();
         // # stop check list
         if (this.checkList && !this.checkListDone) {
             this.checkListState.put(new Promise((r) => {
-                r(ICE_FAILED);
+                r(iceBase_1.ICE_FAILED);
             }));
         }
         this.nominated = undefined;
@@ -607,7 +800,8 @@ class Connection {
         }
         this.protocols = [];
         this.localCandidates = [];
-        await this.lookup?.close();
+        this.lookup?.close?.();
+        this.lookup = undefined;
     }
     setState(state) {
         this.state = state;
@@ -625,8 +819,6 @@ class Connection {
         }
         if (remoteCandidate.host.includes(".local")) {
             try {
-                if (this.state === "closed")
-                    return;
                 if (!this.lookup) {
                     this.lookup = new lookup_1.MdnsLookup();
                 }
@@ -638,105 +830,21 @@ class Connection {
             }
         }
         try {
-            validateRemoteCandidate(remoteCandidate);
+            (0, iceBase_1.validateRemoteCandidate)(remoteCandidate);
         }
         catch (error) {
             return;
         }
         log("addRemoteCandidate", remoteCandidate);
-        this.remoteCandidates.push(remoteCandidate);
+        this._remoteCandidates.push(remoteCandidate);
         this.pairRemoteCandidate(remoteCandidate);
         this.sortCheckList();
     }
-    async sendTo(data) {
-        // """
-        // Send a datagram on the specified component.
-        // If the connection is not established, a `ConnectionError` is raised.
-        // :param data: The data to be sent.
-        // :param component: The component on which to send the data.
-        // """
-        const activePair = this.nominated;
-        if (activePair) {
-            await activePair.protocol.sendData(data, activePair.remoteAddr);
-        }
-        else {
-            // log("Cannot send data, ice not connected");
-            return;
-        }
-    }
     getDefaultCandidate() {
         const candidates = this.localCandidates.sort((a, b) => a.priority - b.priority);
         const [candidate] = candidates;
         return candidate;
     }
-    requestReceived(message, addr, protocol, rawData) {
-        if (message.messageMethod !== const_1.methods.BINDING) {
-            this.respondError(message, addr, protocol, [400, "Bad Request"]);
-            return;
-        }
-        // # authenticate request
-        try {
-            (0, message_1.parseMessage)(rawData, Buffer.from(this.localPassword, "utf8"));
-            if (!this.remoteUsername) {
-                const rxUsername = `${this.localUserName}:${this.remoteUsername}`;
-                if (message.getAttributeValue("USERNAME") != rxUsername) {
-                    throw new Error("Wrong username");
-                }
-            }
-        }
-        catch (error) {
-            this.respondError(message, addr, protocol, [400, "Bad Request"]);
-            return;
-        }
-        const { iceControlling } = this;
-        // 7.2.1.1.  Detecting and Repairing Role Conflicts
-        if (iceControlling && message.attributesKeys.includes("ICE-CONTROLLING")) {
-            if (this._tieBreaker >= message.getAttributeValue("ICE-CONTROLLING")) {
-                this.respondError(message, addr, protocol, [487, "Role Conflict"]);
-                return;
-            }
-            else {
-                this.switchRole(false);
-            }
-        }
-        else if (!iceControlling &&
-            message.attributesKeys.includes("ICE-CONTROLLED")) {
-            if (this._tieBreaker < message.getAttributeValue("ICE-CONTROLLED")) {
-                this.respondError(message, addr, protocol, [487, "Role Conflict"]);
-            }
-            else {
-                this.switchRole(true);
-                return;
-            }
-        }
-        if (this.options.filterStunResponse &&
-            !this.options.filterStunResponse(message, addr, protocol)) {
-            return;
-        }
-        // # send binding response
-        const response = new message_1.Message(const_1.methods.BINDING, const_1.classes.RESPONSE, message.transactionId);
-        response
-            .setAttribute("XOR-MAPPED-ADDRESS", addr)
-            .addMessageIntegrity(Buffer.from(this.localPassword, "utf8"))
-            .addFingerprint();
-        protocol.sendStun(response, addr).catch((e) => {
-            log("sendStun error", e);
-        });
-        // todo fix
-        // if (this.checkList.length === 0) {
-        //   this.earlyChecks.push([message, addr, protocol]);
-        // } else {
-        this.checkIncoming(message, addr, protocol);
-        // }
-    }
-    dataReceived(data, component) {
-        try {
-            this.onData.execute(data, component);
-        }
-        catch (error) {
-            log("dataReceived", error);
-        }
-    }
     // for test only
     set remoteCandidates(value) {
         if (this.remoteCandidatesEnd)
@@ -744,12 +852,12 @@ class Connection {
         this._remoteCandidates = [];
         for (const remoteCandidate of value) {
             try {
-                validateRemoteCandidate(remoteCandidate);
+                (0, iceBase_1.validateRemoteCandidate)(remoteCandidate);
             }
             catch (error) {
                 continue;
             }
-            this.remoteCandidates.push(remoteCandidate);
+            this._remoteCandidates.push(remoteCandidate);
         }
         this.remoteCandidatesEnd = true;
     }
@@ -757,36 +865,32 @@ class Connection {
         return this._remoteCandidates;
     }
     sortCheckList() {
-        sortCandidatePairs(this.checkList, this.iceControlling);
+        (0, iceBase_1.sortCandidatePairs)(this.checkList, this.iceControlling);
     }
     findPair(protocol, remoteCandidate) {
         const pair = this.checkList.find((pair) => (0, isEqual_1.default)(pair.protocol, protocol) &&
             (0, isEqual_1.default)(pair.remoteCandidate, remoteCandidate));
         return pair;
     }
-    setPairState(pair, state) {
-        log("setPairState", pair.toJSON(), CandidatePairState[state]);
-        pair.updateState(state);
-    }
     switchRole(iceControlling) {
         log("switch role", iceControlling);
         this.iceControlling = iceControlling;
         this.sortCheckList();
     }
-    resetNominatedPair() {
-        log("resetNominatedPair");
-        this.nominated = undefined;
-        this.nominating = false;
-    }
     checkComplete(pair) {
         pair.handle = undefined;
-        if (pair.state === CandidatePairState.SUCCEEDED) {
+        if (pair.state === iceBase_1.CandidatePairState.SUCCEEDED) {
             // Updating the Nominated Flag
             // https://www.rfc-editor.org/rfc/rfc8445#section-7.3.1.5,
             // Once the nominated flag is set for a component of a data stream, it
             // concludes the ICE processing for that component.  See Section 8.
             // So disallow overwriting of the pair nominated for that component
-            if (pair.nominated && this.nominated == undefined) {
+            if (pair.nominated &&
+                // remoteのgenerationをチェックする.localのgenerationは更新が間に合わないかもしれないのでチェックしない
+                (pair.remoteCandidate.generation != undefined
+                    ? pair.remoteCandidate.generation === this.generation
+                    : true) &&
+                this.nominated == undefined) {
                 log("nominated", pair.toJSON());
                 this.nominated = pair;
                 this.nominating = false;
@@ -796,8 +900,8 @@ class Connection {
                 // nominated pairs for that media stream.
                 for (const p of this.checkList) {
                     if (p.component === pair.component &&
-                        [CandidatePairState.WAITING, CandidatePairState.FROZEN].includes(p.state)) {
-                        this.setPairState(p, CandidatePairState.FAILED);
+                        [iceBase_1.CandidatePairState.WAITING, iceBase_1.CandidatePairState.FROZEN].includes(p.state)) {
+                        p.updateState(iceBase_1.CandidatePairState.FAILED);
                     }
                 }
             }
@@ -807,27 +911,28 @@ class Connection {
             if (this.nominated) {
                 if (!this.checkListDone) {
                     log("ICE completed");
-                    this.checkListState.put(new Promise((r) => r(ICE_COMPLETED)));
+                    this.checkListState.put(new Promise((r) => r(iceBase_1.ICE_COMPLETED)));
                     this.checkListDone = true;
                 }
                 return;
             }
+            log("not completed", pair.toJSON());
             // 7.1.3.2.3.  Updating Pair States
             for (const p of this.checkList) {
                 if (p.localCandidate.foundation === pair.localCandidate.foundation &&
-                    p.state === CandidatePairState.FROZEN) {
-                    this.setPairState(p, CandidatePairState.WAITING);
+                    p.state === iceBase_1.CandidatePairState.FROZEN) {
+                    p.updateState(iceBase_1.CandidatePairState.WAITING);
                 }
             }
         }
         {
-            const list = [CandidatePairState.SUCCEEDED, CandidatePairState.FAILED];
+            const list = [iceBase_1.CandidatePairState.SUCCEEDED, iceBase_1.CandidatePairState.FAILED];
             if (this.checkList.find(({ state }) => !list.includes(state))) {
                 return;
             }
         }
         if (!this.iceControlling) {
-            const target = CandidatePairState.SUCCEEDED;
+            const target = iceBase_1.CandidatePairState.SUCCEEDED;
             if (this.checkList.find(({ state }) => state === target)) {
                 return;
             }
@@ -835,17 +940,22 @@ class Connection {
         if (!this.checkListDone) {
             log("ICE failed");
             this.checkListState.put(new Promise((r) => {
-                r(ICE_FAILED);
+                r(iceBase_1.ICE_FAILED);
             }));
         }
     }
+    addPair(pair) {
+        this.checkList.push(pair);
+        this.sortCheckList();
+    }
     // 7.2.  STUN Server Procedures
     // 7.2.1.3、7.2.1.4、および7.2.1.5
     checkIncoming(message, addr, protocol) {
-        // log("checkIncoming", message.toJSON(), addr);
         // """
         // Handle a successful incoming check.
         // """
+        const txUsername = message.getAttributeValue("USERNAME");
+        const { remoteUsername: localUsername } = decodeTxUsername(txUsername);
         // find remote candidate
         let remoteCandidate;
         const [host, port] = addr;
@@ -857,20 +967,27 @@ class Connection {
         }
         if (!remoteCandidate) {
             // 7.2.1.3.  Learning Peer Reflexive Candidates
-            remoteCandidate = new candidate_1.Candidate((0, helper_1.randomString)(10), 1, "udp", message.getAttributeValue("PRIORITY"), host, port, "prflx");
-            this.remoteCandidates.push(remoteCandidate);
+            remoteCandidate = new candidate_1.Candidate((0, helper_1.randomString)(10), 1, "udp", message.getAttributeValue("PRIORITY"), host, port, "prflx", undefined, undefined, undefined, undefined, undefined);
+            this._remoteCandidates.push(remoteCandidate);
         }
         // find pair
         let pair = this.findPair(protocol, remoteCandidate);
         if (!pair) {
-            pair = new CandidatePair(protocol, remoteCandidate);
-            this.setPairState(pair, CandidatePairState.WAITING);
-            this.checkList.push(pair);
-            this.sortCheckList();
+            pair = new iceBase_1.CandidatePair(protocol, remoteCandidate, this.iceControlling);
+            pair.updateState(iceBase_1.CandidatePairState.WAITING);
+            this.addPair(pair);
         }
+        pair.localCandidate.ufrag = localUsername;
+        log("Triggered Checks", message.toJSON(), pair.toJSON(), {
+            localUsername: this.localUsername,
+            remoteUsername: this.remoteUsername,
+            localPassword: this.localPassword,
+            remotePassword: this.remotePassword,
+            generation: this.generation,
+        });
         // 7.2.1.4.  Triggered Checks
-        if ([CandidatePairState.WAITING, CandidatePairState.FAILED].includes(pair.state)) {
-            pair.handle = (0, helper_1.future)(this.checkStart(pair));
+        if ([iceBase_1.CandidatePairState.WAITING, iceBase_1.CandidatePairState.FAILED].includes(pair.state)) {
+            pair.handle = this.checkStart(pair);
         }
         else {
             pair;
@@ -879,7 +996,7 @@ class Connection {
         if (message.attributesKeys.includes("USE-CANDIDATE") &&
             !this.iceControlling) {
             pair.remoteNominated = true;
-            if (pair.state === CandidatePairState.SUCCEEDED) {
+            if (pair.state === iceBase_1.CandidatePairState.SUCCEEDED) {
                 pair.nominated = true;
                 this.checkComplete(pair);
             }
@@ -888,13 +1005,13 @@ class Connection {
     tryPair(protocol, remoteCandidate) {
         if (protocol.localCandidate?.canPairWith(remoteCandidate) &&
             !this.findPair(protocol, remoteCandidate)) {
-            const pair = new CandidatePair(protocol, remoteCandidate);
+            const pair = new iceBase_1.CandidatePair(protocol, remoteCandidate, this.iceControlling);
             if (this.options.filterCandidatePair &&
                 !this.options.filterCandidatePair(pair)) {
                 return;
             }
-            this.checkList.push(pair);
-            this.setPairState(pair, CandidatePairState.WAITING);
+            pair.updateState(iceBase_1.CandidatePairState.WAITING);
+            this.addPair(pair);
         }
     }
     pairLocalProtocol(protocol) {
@@ -902,20 +1019,20 @@ class Connection {
             this.tryPair(protocol, remoteCandidate);
         }
     }
-    buildRequest(pair, nominate) {
-        const txUsername = `${this.remoteUsername}:${this.localUserName}`;
+    buildRequest({ nominate, remoteUsername, localUsername, iceControlling, }) {
+        const txUsername = encodeTxUsername({ remoteUsername, localUsername });
         const request = new message_1.Message(const_1.methods.BINDING, const_1.classes.REQUEST);
         request
             .setAttribute("USERNAME", txUsername)
-            .setAttribute("PRIORITY", (0, candidate_1.candidatePriority)(pair.component, "prflx"));
-        if (this.iceControlling) {
-            request.setAttribute("ICE-CONTROLLING", this._tieBreaker);
+            .setAttribute("PRIORITY", (0, candidate_1.candidatePriority)("prflx"));
+        if (iceControlling) {
+            request.setAttribute("ICE-CONTROLLING", this.tieBreaker);
             if (nominate) {
                 request.setAttribute("USE-CANDIDATE", null);
             }
         }
         else {
-            request.setAttribute("ICE-CONTROLLED", this._tieBreaker);
+            request.setAttribute("ICE-CONTROLLED", this.tieBreaker);
         }
         return request;
     }
@@ -931,128 +1048,11 @@ class Connection {
     }
 }
 exports.Connection = Connection;
-class CandidatePair {
-    get state() {
-        return this._state;
-    }
-    toJSON() {
-        return {
-            protocol: this.protocol.type,
-            remoteAddr: this.remoteAddr,
-        };
-    }
-    constructor(protocol, remoteCandidate) {
-        Object.defineProperty(this, "protocol", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: protocol
-        });
-        Object.defineProperty(this, "remoteCandidate", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: remoteCandidate
-        });
-        Object.defineProperty(this, "handle", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "nominated", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "remoteNominated", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        // 5.7.4.  Computing States
-        Object.defineProperty(this, "_state", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: CandidatePairState.FROZEN
-        });
-    }
-    updateState(state) {
-        this._state = state;
-    }
-    get localCandidate() {
-        if (!this.protocol.localCandidate)
-            throw new Error("localCandidate not exist");
-        return this.protocol.localCandidate;
-    }
-    get remoteAddr() {
-        return [this.remoteCandidate.host, this.remoteCandidate.port];
-    }
-    get component() {
-        return this.localCandidate.component;
-    }
-}
-exports.CandidatePair = CandidatePair;
-const ICE_COMPLETED = 1;
-const ICE_FAILED = 2;
-const CONSENT_INTERVAL = 5;
-const CONSENT_FAILURES = 6;
-var CandidatePairState;
-(function (CandidatePairState) {
-    CandidatePairState[CandidatePairState["FROZEN"] = 0] = "FROZEN";
-    CandidatePairState[CandidatePairState["WAITING"] = 1] = "WAITING";
-    CandidatePairState[CandidatePairState["IN_PROGRESS"] = 2] = "IN_PROGRESS";
-    CandidatePairState[CandidatePairState["SUCCEEDED"] = 3] = "SUCCEEDED";
-    CandidatePairState[CandidatePairState["FAILED"] = 4] = "FAILED";
-})(CandidatePairState || (exports.CandidatePairState = CandidatePairState = {}));
-const defaultOptions = {
-    useIpv4: true,
-    useIpv6: true,
+const encodeTxUsername = ({ remoteUsername, localUsername, }) => {
+    return `${remoteUsername}:${localUsername}`;
+};
+const decodeTxUsername = (txUsername) => {
+    const [remoteUsername, localUsername] = txUsername.split(":");
+    return { remoteUsername, localUsername };
 };
-function validateRemoteCandidate(candidate) {
-    // """
-    // Check the remote candidate is supported.
-    // """
-    if (!["host", "relay", "srflx"].includes(candidate.type))
-        throw new Error(`Unexpected candidate type "${candidate.type}"`);
-    // ipaddress.ip_address(candidate.host)
-    return candidate;
-}
-function sortCandidatePairs(pairs, iceControlling) {
-    pairs.sort((a, b) => candidatePairPriority(a.localCandidate, a.remoteCandidate, iceControlling) -
-        candidatePairPriority(b.localCandidate, b.remoteCandidate, iceControlling));
-}
-// 5.7.2.  Computing Pair Priority and Ordering Pairs
-function candidatePairPriority(local, remote, iceControlling) {
-    const G = (iceControlling && local.priority) || remote.priority;
-    const D = (iceControlling && remote.priority) || local.priority;
-    return (1 << 32) * Math.min(G, D) + 2 * Math.max(G, D) + (G > D ? 1 : 0);
-}
-async function serverReflexiveCandidate(protocol, stunServer) {
-    // """
-    // Query STUN server to obtain a server-reflexive candidate.
-    // """
-    // # perform STUN query
-    const request = new message_1.Message(const_1.methods.BINDING, const_1.classes.REQUEST);
-    try {
-        const [response] = await protocol.request(request, stunServer);
-        const localCandidate = protocol.localCandidate;
-        if (!localCandidate)
-            throw new Error("not exist");
-        return new candidate_1.Candidate((0, candidate_1.candidateFoundation)("srflx", "udp", localCandidate.host), localCandidate.component, localCandidate.transport, (0, candidate_1.candidatePriority)(localCandidate.component, "srflx"), response.getAttributeValue("XOR-MAPPED-ADDRESS")[0], response.getAttributeValue("XOR-MAPPED-ADDRESS")[1], "srflx", localCandidate.host, localCandidate.port);
-    }
-    catch (error) {
-        // todo fix
-        log("error serverReflexiveCandidate", error);
-    }
-}
-function validateAddress(addr) {
-    if (addr && Number.isNaN(addr[1])) {
-        return [addr[0], 443];
-    }
-    return addr;
-}
 //# sourceMappingURL=ice.js.map