@leofcoin/chain 1.10.12 → 1.10.14

package/exports/chain.js

@@ -11,6 +11,7 @@ import { randombytes } from '@leofcoin/crypto';
 import EasyWorker from '@vandeurenglenn/easy-worker';
 import { ContractDeploymentError, ExecutionError, isResolveError, ResolveError, isExecutionError } from '@leofcoin/errors';
 import { P as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO } from './constants-CMYKv-Rt.js';
+import ConnectionMonitor from './connection-monitor.js';
 import { q as quorumThreshold } from './quorum-S_qdgiAY.js';
 import '@leofcoin/networks';
 
@@ -37,6 +38,27 @@ class Protocol {
   }
 }
 
+const waitForCanonicalTransaction = (pubsub, transactionPool, hash) => new Promise((resolve, reject) => {
+  const completionTopic = `transaction.completed.${hash}`;
+  const cleanup = () => {
+    pubsub.unsubscribe("block-processed", blockProcessed);
+    pubsub.unsubscribe(completionTopic, transactionCompleted);
+  };
+  const blockProcessed = (block) => {
+    if (!Array.isArray(block?.transactions) || !block.transactions.includes(hash)) return;
+    cleanup();
+    resolve(hash);
+  };
+  const transactionCompleted = async (result) => {
+    if (result?.status === "fulfilled") return;
+    await transactionPool.delete(hash);
+    cleanup();
+    reject({ hash, error: result?.error });
+  };
+  pubsub.subscribe("block-processed", blockProcessed);
+  pubsub.subscribe(completionTopic, transactionCompleted);
+});
+
 class Transaction extends Protocol {
   #pendingNonces = /* @__PURE__ */ new Map();
   #maxPendingNonce = /* @__PURE__ */ new Map();
@@ -238,26 +260,7 @@ class Transaction extends Protocol {
     const hash = await message.hash();
     try {
       let data;
-      const wait = new Promise(async (resolve, reject) => {
-        if (pubsub.hasSubscribers(`transaction.completed.${hash}`)) {
-          const result = pubsub.getValue(`transaction.completed.${hash}`);
-          if (result.status !== "fulfilled") {
-            await transactionPoolStore.delete(hash);
-          }
-          result.status === "fulfilled" ? resolve(result.hash) : reject({ hash: result.hash, error: result.error });
-        } else {
-          const completed = async (result) => {
-            if (result.status !== "fulfilled") {
-              await transactionPoolStore.delete(hash);
-            }
-            result.status === "fulfilled" ? resolve(result.hash) : reject({ hash: result.hash, error: result.error });
-            setTimeout(async () => {
-              pubsub.unsubscribe(`transaction.completed.${hash}`, completed);
-            }, 1e4);
-          };
-          pubsub.subscribe(`transaction.completed.${hash}`, completed);
-        }
-      });
+      const wait = waitForCanonicalTransaction(pubsub, transactionPoolStore, hash);
       await globalThis.transactionPoolStore.put(hash, message.encoded);
       this.addPendingNonce(message.decoded.from, message.decoded.nonce);
       try {
@@ -1648,6 +1651,12 @@ class State extends Contract {
       const localIndex = localBlock ? Number(localBlock.index) : -1;
       const remoteIndex = Number(lastBlock.index);
       const remoteBlockHash = lastBlock.hash;
+      globalThis.pubsub.publish("sync-progress", {
+        phase: "syncing",
+        startIndex: localIndex,
+        localIndex,
+        targetIndex: remoteIndex
+      });
       let localStateHash = "0x0";
       try {
         localStateHash = new TextDecoder().decode(await globalThis.chainStore.get("lastBlock"));
@@ -1707,6 +1716,12 @@ class State extends Contract {
       } else {
         debug$1(`Block already in local state. Remote hash: ${remoteBlockHash} matches local state`);
       }
+      globalThis.pubsub.publish("sync-progress", {
+        phase: "synced",
+        startIndex: localIndex,
+        localIndex: remoteIndex,
+        targetIndex: remoteIndex
+      });
     } catch (error) {
       console.log(error);
       throw error;
@@ -1993,297 +2008,6 @@ class VersionControl extends State {
   }
 }
 
-class ConnectionMonitor {
-  #isMonitoring = false;
-  #checkInterval = null;
-  #reconnectDelay = 5e3;
-  #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);
-  }
-  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 = 5e3;
-    };
-    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() {
-    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) {
-      console.warn("\u26A0\uFE0F No peer connections detected \u2014 attempting reconnection");
-      await this.#attemptReconnection();
-    } else if (compatiblePeers.length === 0 && connectedPeers.length > 0) {
-      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 import('@leofcoin/networks');
-          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));
-      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 = 5e3;
-      } else {
-        console.warn("\u26A0\uFE0F Reconnection attempt completed but no peers connected");
-        if (this.#reconnectDelay >= 3e4) {
-          console.warn("\u26A0\uFE0F Reconnection delay reached maximum, resetting to 5 seconds");
-          this.#reconnectDelay = 5e3;
-        } else {
-          this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 3e4);
-          console.warn(`\u26A0\uFE0F Increasing reconnection delay to ${this.#reconnectDelay} ms`);
-        }
-        this.#reconnectTimer = setTimeout(() => this.#attemptReconnection(), this.#reconnectDelay);
-      }
-    } catch (error) {
-      console.error("\u274C Reconnection failed:", error?.message || error);
-      if (this.#reconnectDelay >= 3e4) {
-        this.#reconnectDelay = 5e3;
-      } else {
-        this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 3e4);
-      }
-      this.#reconnectTimer = setTimeout(() => this.#attemptReconnection(), this.#reconnectDelay);
-    }
-  }
-}
-
 const validateChainLink = (localTip, incoming) => {
   const localHash = localTip?.hash || "0x0";
   const localIndex = Number(localTip?.index ?? -1);
@@ -3319,7 +3043,6 @@ class Chain extends VersionControl {
         seed: hash,
         timestamp: Number(executionTimestamp)
       });
-      globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: "fulfilled", hash });
       return result || "no state change";
     } catch (error) {
       await transactionPoolStore.delete(hash);
@@ -3441,6 +3164,25 @@ class Chain extends VersionControl {
   async participate(address) {
     try {
       if (!await this.staticCall(addresses.validators, "has", [address])) {
+        const minimumBalance = BigInt(await this.staticCall(addresses.validators, "minimumBalance"));
+        const allowance = BigInt(
+          await this.staticCall(addresses.nativeToken, "allowance", [address, addresses.validators]) || 0n
+        );
+        if (allowance < minimumBalance) {
+          const approval = await signTransaction(
+            {
+              from: address,
+              to: addresses.nativeToken,
+              method: "approve",
+              params: [addresses.validators, minimumBalance],
+              nonce: await this.getNonce(address) + 1,
+              timestamp: Date.now()
+            },
+            globalThis.peernet.identity
+          );
+          const pendingApproval = await this.sendTransaction(approval);
+          await pendingApproval.wait;
+        }
         const rawTransaction = {
           from: address,
           to: addresses.validators,
@@ -3717,7 +3459,8 @@ class Chain extends VersionControl {
     return this.call(addresses.nativeToken, "mint", [to, amount]);
   }
   transfer(from, to, amount) {
-    return this.call(addresses.nativeToken, "transfer", [from, to, amount]);
+    if (from !== globalThis.peernet.selectedAccount) throw new Error("transfer sender must be the selected account");
+    return this.call(addresses.nativeToken, "transfer", [to, amount]);
   }
   balanceOf(address) {
     return this.staticCall(addresses.nativeToken, "balanceOf", [address]);