@leofcoin/chain 1.10.13 → 1.10.15

package/exports/browser/{client-B-jyclOB-CsNYfj4Z.js → client-DDC8C510-3uaB70KL.js}

@@ -1,8 +1,8 @@
-import { i as inflate_1, c as createDebugger, d as deflate_1, L as LittlePubSub } from './node-browser-xlqSBOaN.js';
-import 'crypto';
-import './constants-Cv0p224A.js';
-import './proposal.proto-BcUgd885.js';
+import { i as inflate_1, c as createDebugger, d as deflate_1, L as LittlePubSub } from './node-browser-BYi7D_oa.js';
+import './browser-crypto-B9N9KlL4.js';
+import './connection-monitor-GPztgSSJ.js';
 import './index-CvKt4UDE.js';
+import './sha2-piimb6xL.js';
 
 class Api {
     _pubsub;
@@ -233,7 +233,7 @@ class SocketRequestClient {
             const init = async () => {
                 // @ts-ignore
                 if (!globalThis.WebSocket && !this.#experimentalWebsocket)
-                    globalThis.WebSocket = (await import('./browser-DvU1xNFS-sdlKNCJc.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-DvU1xNFS-DmmNUdE-.js').then(function (n) { return n.b; })).default.w3cwebsocket;
                 const client = new WebSocket(this.#url, this.#protocol);
                 if (this.#experimentalWebsocket) {
                     client.addEventListener('error', this.onerror);
@@ -1155,6 +1155,7 @@ class Client {
     #connectEvent = 'peer:connected';
     #supportedTransports = new Set(['webrtc']);
     #preferredTransportKind = 'webrtc';
+    #wrtcBackend = 'vandeurenglenn';
     #fallbackTransportOrder = [];
     #enableCircuitFallback = true;
     #transportConnectTimeoutMs = 10_000;
@@ -1212,6 +1213,13 @@ class Client {
                 ? 'webrtc'
                 : 'webtransport';
         this.#webTransportUrlTemplate = options.transport?.webtransport?.urlTemplate;
+        const wrtcBackend = options.transport?.webrtc?.backend ||
+            globalThis.process?.env?.NETPEER_SWARM_WRTC_BACKEND ||
+            'vandeurenglenn';
+        if (wrtcBackend !== 'vandeurenglenn' && wrtcBackend !== 'koush') {
+            throw new Error(`Unsupported WebRTC backend: ${wrtcBackend}`);
+        }
+        this.#wrtcBackend = wrtcBackend;
         this.#enableCircuitFallback = options.transport?.fallback?.enabled ?? true;
         if (typeof options.transport?.fallback?.connectTimeoutMs === 'number' &&
             options.transport.fallback.connectTimeoutMs > 0) {
@@ -1297,7 +1305,8 @@ class Client {
         throw lastErr;
     }
     async _init() {
-        if (!globalThis.RTCPeerConnection &&
+        if (this.#supportedTransports.has('webrtc') &&
+            !globalThis.RTCPeerConnection &&
             !globalThis.wrtc) {
             const { backend, implementation } = await this.#loadNodeWebrtcImplementation();
             globalThis.wrtc = implementation;
@@ -1325,13 +1334,28 @@ class Client {
         }
     }
     async #loadNodeWebrtcImplementation() {
-        const koushWrtcModule = await import('./browser-CWeoyGUw-BabtHowB.js').then(function (n) { return n.b; });
-        const koushWrtc = koushWrtcModule.default;
-        if (!isWrtcImplementation(koushWrtc)) {
-            throw new Error('@koush/wrtc does not match required wrtc contract');
+        let wrtcModule;
+        if (this.#wrtcBackend === 'koush') {
+            try {
+                wrtcModule = await import('@koush/wrtc');
+            }
+            catch (error) {
+                throw new Error('The koush WebRTC backend is opt-in; install @koush/wrtc to use it', { cause: error });
+            }
         }
-        debug('using @koush/wrtc as wrtc implementation');
-        return { backend: 'koush', implementation: koushWrtc };
+        else {
+            wrtcModule = await import('@vandeurenglenn/wrtc');
+        }
+        const moduleCandidate = wrtcModule;
+        const implementation = isWrtcImplementation(moduleCandidate.default)
+            ? moduleCandidate.default
+            : wrtcModule;
+        if (!isWrtcImplementation(implementation)) {
+            const packageName = this.#wrtcBackend === 'koush' ? '@koush/wrtc' : '@vandeurenglenn/wrtc';
+            throw new Error(`${packageName} does not match required wrtc contract`);
+        }
+        debug(`using ${this.#wrtcBackend} as wrtc implementation`);
+        return { backend: this.#wrtcBackend, implementation };
     }
     setupStarListeners(starConnection, starId) {
         // create stable references to handlers so we can unsubscribe later

package/exports/browser/connection-monitor-GPztgSSJ.js

@@ -0,0 +1,454 @@
+import { F as FormatInterface, o as proto$2, q as proto$3, i as index, f as index$1, r as proto$4 } from './browser-crypto-B9N9KlL4.js';
+
+class ValidatorMessage extends FormatInterface {
+  get messageName() {
+    return "ValidatorMessage";
+  }
+  constructor(buffer) {
+    if (buffer instanceof ValidatorMessage)
+      return buffer;
+    const name = "validator-message";
+    super(buffer, proto$2, { name });
+  }
+}
+
+class BlockMessage extends FormatInterface {
+  get messageName() {
+    return "BlockMessage";
+  }
+  constructor(buffer) {
+    if (buffer instanceof BlockMessage)
+      return buffer;
+    const name = "block-message";
+    super(buffer, proto$3, { name });
+  }
+  encode(decoded) {
+    decoded = decoded || this.decoded;
+    const validators = [];
+    for (const validator of decoded.validators) {
+      if (validator instanceof ValidatorMessage)
+        validators.push(validator.encode());
+      else
+        validators.push(new ValidatorMessage(validator).encode());
+    }
+    return super.encode({
+      ...decoded,
+      validators: index(validators)
+    });
+  }
+  decode(encoded) {
+    encoded = encoded || this.encoded;
+    super.decode(encoded);
+    this.decoded.validators = index$1(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
+    return this.decoded;
+  }
+}
+
+var proto$1 = {
+  up: Number(),
+  down: Number()
+};
+
+class BWMessage extends FormatInterface {
+  get messageName() {
+    return "BWMessage";
+  }
+  constructor(buffer) {
+    if (buffer instanceof BWMessage)
+      return buffer;
+    const name = "bw-message";
+    super(buffer, proto$1, { name });
+  }
+}
+
+class LastBlockMessage extends FormatInterface {
+  get messageName() {
+    return "LastBlockMessage";
+  }
+  constructor(buffer) {
+    if (buffer instanceof LastBlockMessage)
+      return buffer;
+    const name = "last-block-message";
+    super(buffer, proto$4, { name });
+  }
+}
+
+var proto = {
+  lastblock: Object(),
+  values: Object()
+};
+
+class StateMessage extends FormatInterface {
+  get messageName() {
+    return "StateMessage";
+  }
+  constructor(buffer) {
+    if (buffer instanceof StateMessage)
+      return buffer;
+    const name = "state-message";
+    super(buffer, proto, { name });
+  }
+}
+
+var networks = {
+  leofcoin: {
+    mainnet: {
+      // ports don't really matter since it is favorable to have it begind a ngninx proxy but if we change something to the proto it's easier maybe?
+      port: 44444,
+      // todo a versionhash would be nice to have as a double check?
+      versionHash: "0",
+      // a short description identifying the version
+      description: "Main net current version",
+      stars: ["wss://star.leofcoin.org"]
+      // todo webrtc and bittorent stars
+    },
+    peach: {
+      faucet: "https://remote.leofcoin.org/faucet",
+      port: 44444,
+      description: "Main testnet: latest step before merging into main",
+      versionHash: "1",
+      stars: ["wss://star.leofcoin.org"]
+      // todo webrtc and bittorent stars
+    }
+  }
+};
+
+var networks$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: networks
+});
+
+const PROTOCOL_VERSION = "0.3.0";
+const REACHED_ONE_ZERO_ZERO = false;
+const DEFAULT_NODE_OPTIONS = {
+  autoStart: false,
+  network: "leofcoin:peach",
+  networkVersion: "peach",
+  version: PROTOCOL_VERSION,
+  stars: networks.leofcoin.peach.stars
+};
+
+const INITIAL_RECONNECT_DELAY = 5e3;
+const MAX_RECONNECT_DELAY = 3e4;
+const isSendablePeer = (peer) => {
+  if (!peer || typeof peer !== "object") return false;
+  const candidate = peer;
+  if (typeof candidate.send !== "function") return false;
+  if (candidate.connected === true) return true;
+  return typeof candidate.once === "function" && typeof candidate.removeListener === "function";
+};
+const guardPeerMessages = (peernet) => {
+  const sendMessage = peernet.sendMessage.bind(peernet);
+  peernet.sendMessage = (peer, ...args) => {
+    if (isSendablePeer(peer)) return sendMessage(peer, ...args);
+    for (const [peerId, connection] of Object.entries(peernet.connections || {})) {
+      if (connection === peer) delete peernet.connections[peerId];
+    }
+    return Promise.resolve(void 0);
+  };
+};
+class ConnectionMonitor {
+  #isMonitoring = false;
+  #checkInterval = null;
+  #reconnectDelay = INITIAL_RECONNECT_DELAY;
+  #reconnectTimer = null;
+  #healthCheckInterval = 6e4;
+  #version;
+  #lastHealthCheckAt = 0;
+  #reconnecting = false;
+  // event handlers to remove later
+  #onOnline = null;
+  #onVisibilityChange = null;
+  #onSigcont = null;
+  #onPeerConnected = null;
+  get isMonitoring() {
+    return this.#isMonitoring;
+  }
+  get connectedPeers() {
+    return Object.values(globalThis.peernet?.connections || {}).filter((peer) => peer.connected);
+  }
+  get compatiblePeers() {
+    return this.connectedPeers.filter((peer) => {
+      if (!peer.version || !this.#version) return false;
+      const [peerMajor, peerMinor] = peer.version.split(".");
+      const [localMajor, localMinor] = this.#version.split(".");
+      return peerMajor === localMajor && peerMinor === localMinor;
+    });
+  }
+  get disconnectedPeers() {
+    return Object.values(globalThis.peernet?.connections || {}).filter((peer) => !peer.connected);
+  }
+  #pruneInvalidConnections() {
+    const connections = globalThis.peernet?.connections;
+    if (!connections) return;
+    for (const [peerId, peer] of Object.entries(connections)) {
+      if (!isSendablePeer(peer)) {
+        delete connections[peerId];
+        console.warn(`Removed invalid peer connection: ${peerId}`);
+      }
+    }
+  }
+  start(version) {
+    this.#version = version;
+    console.log(`\u{1F517} Connection Monitor initialized for version: ${this.#version}`);
+    if (this.#isMonitoring) return;
+    this.#isMonitoring = true;
+    console.log("\u{1F504} Starting connection monitor...");
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+      this.#onOnline = () => {
+        console.log("\u{1F310} Network online \u2014 attempting restore");
+        void this.#restoreNetwork();
+      };
+      window.addEventListener("online", this.#onOnline);
+      this.#onVisibilityChange = () => {
+        if (document.visibilityState === "visible") {
+          console.log("\u{1F4A1} Visibility regained");
+          if (this.connectedPeers.length === 0) {
+            console.log("\u{1F4A1} Visibility regained \u2014 attempting restore");
+            void this.#restoreNetwork();
+          }
+        }
+      };
+      document.addEventListener("visibilitychange", this.#onVisibilityChange);
+    }
+    if (typeof process !== "undefined" && typeof process.on === "function") {
+      this.#onSigcont = () => {
+        console.log("\u{1F514} Process resumed (SIGCONT) \u2014 attempting restore");
+        void this.#restoreNetwork();
+      };
+      try {
+        process.on("SIGCONT", this.#onSigcont);
+      } catch (e) {
+      }
+    }
+    this.#lastHealthCheckAt = Date.now();
+    this.#checkInterval = setInterval(() => {
+      this.#healthCheck();
+    }, this.#healthCheckInterval);
+    this.#onPeerConnected = () => {
+      if (this.#reconnectTimer) {
+        clearTimeout(this.#reconnectTimer);
+        this.#reconnectTimer = null;
+      }
+      this.#reconnecting = false;
+      this.#reconnectDelay = INITIAL_RECONNECT_DELAY;
+    };
+    globalThis.pubsub?.subscribe("peer:connected", this.#onPeerConnected);
+  }
+  stop() {
+    if (!this.#isMonitoring) return;
+    this.#isMonitoring = false;
+    if (this.#checkInterval) {
+      clearInterval(this.#checkInterval);
+      this.#checkInterval = null;
+    }
+    if (typeof window !== "undefined") {
+      if (this.#onOnline) {
+        window.removeEventListener("online", this.#onOnline);
+        this.#onOnline = null;
+      }
+      if (this.#onVisibilityChange) {
+        document.removeEventListener("visibilitychange", this.#onVisibilityChange);
+        this.#onVisibilityChange = null;
+      }
+    }
+    if (typeof process !== "undefined" && typeof process.removeListener === "function" && this.#onSigcont) {
+      try {
+        process.removeListener("SIGCONT", this.#onSigcont);
+      } catch (e) {
+      }
+      this.#onSigcont = null;
+    }
+    if (this.#onPeerConnected) {
+      globalThis.pubsub?.unsubscribe("peer:connected", this.#onPeerConnected);
+      this.#onPeerConnected = null;
+    }
+    if (this.#reconnectTimer) {
+      clearTimeout(this.#reconnectTimer);
+      this.#reconnectTimer = null;
+    }
+    console.log("\u23F9\uFE0F Connection monitor stopped");
+  }
+  async #healthCheck() {
+    this.#pruneInvalidConnections();
+    const now = Date.now();
+    const expectedNext = this.#lastHealthCheckAt + this.#healthCheckInterval;
+    const drift = now - expectedNext;
+    this.#lastHealthCheckAt = now;
+    if (drift > 5e3) {
+      console.log(`\u23F0 Detected timer drift of ${drift}ms (likely system sleep) \u2014 attempting restore`);
+      void this.#restoreNetwork();
+    }
+    const connectedPeers = this.connectedPeers;
+    const compatiblePeers = this.compatiblePeers;
+    const disconnectedPeers = this.disconnectedPeers;
+    console.log(
+      `\u{1F50D} Health check: ${connectedPeers.length} connected, ${compatiblePeers.length} compatible, ${disconnectedPeers.length} negotiating`
+    );
+    if (connectedPeers.length === 0 && disconnectedPeers.length === 0 && !this.#reconnectTimer) {
+      console.warn("\u26A0\uFE0F No peer connections detected \u2014 attempting reconnection");
+      await this.#attemptReconnection();
+    } else if (compatiblePeers.length === 0 && connectedPeers.length > 0 && !this.#reconnectTimer) {
+      console.warn("\u26A0\uFE0F No compatible peers found \u2014 attempting reconnection");
+      await this.#attemptReconnection();
+    }
+    globalThis.pubsub?.publish("connection-status", {
+      connected: connectedPeers.length,
+      compatible: compatiblePeers.length,
+      healthy: compatiblePeers.length > 0
+    });
+  }
+  // lightweight TCP probe to detect internet connectivity in Node.js
+  async #isOnLine(timeout = 1500) {
+    if (navigator?.onLine !== void 0) {
+      return navigator.onLine;
+    }
+    return new Promise(async (resolve) => {
+      try {
+        const net = await import('net');
+        const socket = new net.Socket();
+        let finished = false;
+        const finish = (val) => {
+          if (finished) return;
+          finished = true;
+          try {
+            socket.destroy();
+          } catch (e) {
+          }
+          resolve(val);
+        };
+        socket.setTimeout(timeout);
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+        socket.once("timeout", () => finish(false));
+        socket.connect(53, "1.1.1.1");
+      } catch (e) {
+        resolve(false);
+      }
+    });
+  }
+  // Called on visibility/online/resume events
+  async #restoreNetwork() {
+    if (this.#reconnecting) {
+      console.log("\u{1F501} Reconnection already in progress, skipping");
+      return;
+    }
+    this.#reconnecting = true;
+    if (this.connectedPeers.length > 0) {
+      console.log("\u2705 Already connected to peers, skipping restoration");
+      this.#reconnecting = false;
+      return;
+    }
+    console.log("\u{1F501} Restoring network");
+    try {
+      const online = await this.#isOnLine(1500);
+      if (!online) {
+        console.warn("\u26A0\uFE0F No internet detected, skipping restore");
+        this.#reconnecting = false;
+        return;
+      }
+    } catch (e) {
+      console.warn("\u26A0\uFE0F Online probe failed, proceeding with restore", e?.message || e);
+    }
+    try {
+      console.log("\u{1F504} Attempting network restoration...");
+      if (globalThis.peernet?.client?.reinit) {
+        console.log("  \u2192 Trying client.reinit()");
+        try {
+          await globalThis.peernet.client.reinit();
+          console.log("  \u2705 client.reinit() succeeded");
+        } catch (e) {
+          console.warn("  \u26A0\uFE0F client.reinit() failed:", e?.message || e);
+        }
+      }
+      if (globalThis.peernet?.start) {
+        console.log("  \u2192 Trying peernet.start()");
+        try {
+          await globalThis.peernet.start();
+          console.log("  \u2705 peernet.start() succeeded");
+        } catch (e) {
+          console.warn("  \u26A0\uFE0F peernet.start() failed:", e?.message || e);
+        }
+      }
+      try {
+        const networkName = globalThis.peernet?.network;
+        if (networkName && typeof networkName === "string") {
+          const { default: networks } = await Promise.resolve().then(function () { return networks$1; });
+          const [mainKey, subKey] = networkName.split(":");
+          const networkConfig = networks?.[mainKey]?.[subKey];
+          if (networkConfig?.stars && Array.isArray(networkConfig.stars)) {
+            console.log("  \u2192 Attempting to dial star servers:", networkConfig.stars.join(", "));
+            for (const star of networkConfig.stars) {
+              try {
+                if (globalThis.peernet?.client && "dial" in globalThis.peernet.client) {
+                  await globalThis.peernet.client.dial(star);
+                  console.log(`  \u2705 Connected to star server: ${star}`);
+                }
+              } catch (e) {
+                console.warn(`  \u26A0\uFE0F Failed to dial ${star}:`, e?.message || e);
+              }
+            }
+          }
+        }
+      } catch (e) {
+        console.warn("  \u26A0\uFE0F Could not load or dial star servers:", e?.message || e);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      this.#pruneInvalidConnections();
+      const connectedAfter = this.connectedPeers.length;
+      console.log(`\u{1F504} Restoration complete. Connected peers: ${connectedAfter}`);
+    } catch (error) {
+      console.error("\u274C Network restoration failed:", error?.message || error);
+    } finally {
+      this.#reconnecting = false;
+    }
+  }
+  async waitForPeers(timeoutMs = 3e4) {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      const checkPeers = () => {
+        if (this.compatiblePeers.length > 0) {
+          resolve(true);
+          return;
+        }
+        if (Date.now() - startTime >= timeoutMs) {
+          resolve(false);
+          return;
+        }
+        setTimeout(checkPeers, 1e3);
+      };
+      checkPeers();
+    });
+  }
+  async #attemptReconnection() {
+    try {
+      await this.#restoreNetwork();
+      const hasConnections = this.connectedPeers.length > 0 || this.disconnectedPeers.length > 0;
+      if (hasConnections) {
+        console.log("\u2705 Reconnection successful, resetting backoff delay");
+        this.#reconnectDelay = INITIAL_RECONNECT_DELAY;
+      } else {
+        console.warn("\u26A0\uFE0F Reconnection attempt completed but no peers connected");
+        this.#scheduleReconnect();
+      }
+    } catch (error) {
+      console.error("\u274C Reconnection failed:", error?.message || error);
+      this.#scheduleReconnect();
+    }
+  }
+  #scheduleReconnect() {
+    if (!this.#isMonitoring || this.#reconnectTimer) return;
+    if (this.#reconnectDelay >= MAX_RECONNECT_DELAY) {
+      console.warn("\u26A0\uFE0F No peers available; automatic retries paused until the next health check or network event");
+      return;
+    }
+    this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, MAX_RECONNECT_DELAY);
+    console.warn(`\u26A0\uFE0F Increasing reconnection delay to ${this.#reconnectDelay} ms`);
+    this.#reconnectTimer = setTimeout(() => {
+      this.#reconnectTimer = null;
+      void this.#attemptReconnection();
+    }, this.#reconnectDelay);
+  }
+}
+
+export { BlockMessage as B, ConnectionMonitor as C, DEFAULT_NODE_OPTIONS as D, LastBlockMessage as L, PROTOCOL_VERSION as P, REACHED_ONE_ZERO_ZERO as R, StateMessage as S, ValidatorMessage as V, BWMessage as a, guardPeerMessages as g };