@leofcoin/chain 1.10.20 → 1.10.22

package/exports/browser/{messages-DCePyqKC-BSvJxDWZ.js → messages-DZYCxoZI-D6kIiLKF.js}

@@ -1,6 +1,6 @@
-import { F as FormatInterface } from './node-browser-Ha4Lvntj.js';
+import { F as FormatInterface } from './node-browser-BMfelxXV.js';
 import './browser-crypto-CH0ua22L.js';
-import './connection-monitor-D-krNiRH.js';
+import './connection-monitor-DMGAhcC0.js';
 import './index-CvKt4UDE.js';
 import './sha2-BKcEJzgd.js';
 

package/exports/browser/{node-browser-Ha4Lvntj.js → node-browser-BMfelxXV.js}

@@ -1,5 +1,5 @@
 import { F as FormatInterface$2, T as TransactionMessage, C as ContractMessage, n as createHash$1 } from './browser-crypto-CH0ua22L.js';
-import { B as BlockMessage, a as BWMessage, V as ValidatorMessage, S as StateMessage, L as LastBlockMessage, D as DEFAULT_NODE_OPTIONS, g as guardPeerMessages } from './connection-monitor-D-krNiRH.js';
+import { B as BlockMessage, b as BWMessage, V as ValidatorMessage, S as StateMessage, L as LastBlockMessage, D as DEFAULT_NODE_OPTIONS, g as guardPeerMessages, c as guardProviderDiscovery } from './connection-monitor-DMGAhcC0.js';
 import './index-CvKt4UDE.js';
 
 var proto = {};
@@ -8510,7 +8510,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-dTQVgkpf-DOL2rIjp.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-dTQVgkpf-C6SJ0ZYW.js');
             const { identity, accounts } = await importee.default(password, this.network);
             if (fresh) {
                 await globalThis.accountStore.clear();
@@ -16102,7 +16102,7 @@ const blockchainCodecs = [
     },
     {
         name: 'raw-transaction-message',
-        codec: '0x772746d',
+        codec: '0x72746d',
         hashAlg: 'keccak-256'
     },
     {
@@ -16147,6 +16147,21 @@ const blockchainCodecs = [
     }
 ];
 const consensusCodecs = [
+    {
+        name: 'beacon-activation-message',
+        codec: '0x62616d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'beacon-commitment-message',
+        codec: '0x62636d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'beacon-share-message',
+        codec: '0x62736d',
+        hashAlg: 'keccak-256'
+    },
     {
         name: 'proposal-message',
         codec: '0x70726d',
@@ -16225,7 +16240,7 @@ const peernetCodecs = [
     },
     {
         name: 'peernet-ps',
-        codec: '707073',
+        codec: '0x707073',
         hashAlg: 'keccak-256'
     },
     {
@@ -17927,7 +17942,7 @@ class Peernet {
         await getAddress();
         this.storePrefix = options.storePrefix;
         this.root = options.root;
-        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-DCePyqKC-BSvJxDWZ.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-DZYCxoZI-D6kIiLKF.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -17973,7 +17988,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-DKKzPSlb-C_1ug6ux.js');
+        const importee = await import('./client-DbZBfpG6-CYDyUGUC.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -18776,6 +18791,7 @@ class Node {
     config = { ...DEFAULT_NODE_OPTIONS, ...config };
     this.#node = globalThis.Peernet ? await new globalThis.Peernet(config, password) : await new Peernet(config, password);
     guardPeerMessages(this.#node);
+    guardProviderDiscovery(this.#node);
     await nodeConfig(config);
     globalThis.pubsub.subscribe("chain:ready", async () => {
       if (!this.#node.autoStart) {
@@ -18787,4 +18803,4 @@ class Node {
   }
 }
 
-export { FormatInterface as F, LittlePubSub as L, MultiWallet as M, Node as N, base58$1 as b, createDebugger as c, deflate_1 as d, encrypt as e, getDefaultExportFromCjs as g, inflate_1 as i };
+export { FormatInterface as F, LittlePubSub as L, MultiWallet as M, Node as N, base58$1 as b, createDebugger as c, encrypt as e, getDefaultExportFromCjs as g };

package/exports/browser/node-browser.js

@@ -1,5 +1,5 @@
-export { N as default } from './node-browser-Ha4Lvntj.js';
+export { N as default } from './node-browser-BMfelxXV.js';
 import './browser-crypto-CH0ua22L.js';
-import './connection-monitor-D-krNiRH.js';
+import './connection-monitor-DMGAhcC0.js';
 import './index-CvKt4UDE.js';
 import './sha2-BKcEJzgd.js';

package/exports/chain.js

@@ -7,39 +7,16 @@ import { MAX_TRANSACTION_BYTES, MAX_BLOCK_TRANSACTION_BYTES, MAX_BLOCK_TRANSACTI
 import MultiWallet from '@leofcoin/multi-wallet';
 import { fromBase58 } from '@vandeurenglenn/typed-array-utils';
 import semver from 'semver';
+import { P as Protocol, C as ConnectionMonitor } from './connection-monitor-h2L8vsS7.js';
 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-Dy9i9S_o.js';
-import ConnectionMonitor from './connection-monitor.js';
 import { q as quorumThreshold } from './quorum-S_qdgiAY.js';
 import { assertHashFormatState } from './hash-format-state.js';
 import { createChainIdentity, assertChainId, findChainPresence } from '@leofcoin/lib/chain-identity';
 import '@leofcoin/networks';
 
-const limit = 1800;
-const transactionLimit = 2500;
-const requestTimeout = 3e4;
-const syncTimeout = 3e4;
-class Protocol {
-  constructor(config) {
-    this.resolveTimeout = 1e4;
-    if (config?.resolveTimeout) this.resolveTimeout = config.resolveTimeout;
-  }
-  get limit() {
-    return limit;
-  }
-  get transactionLimit() {
-    return transactionLimit;
-  }
-  get requestTimeout() {
-    return requestTimeout;
-  }
-  get syncTimeout() {
-    return syncTimeout;
-  }
-}
-
 const waitForCanonicalTransaction = (pubsub, transactionPool, hash) => new Promise((resolve, reject) => {
   const completionTopic = `transaction.completed.${hash}`;
   const cleanup = () => {
@@ -266,7 +243,7 @@ class Transaction extends Protocol {
       await globalThis.transactionPoolStore.put(hash, message.encoded);
       this.addPendingNonce(message.decoded.from, message.decoded.nonce);
       try {
-        peernet.publish("add-transaction", message.encoded);
+        await peernet.publish("add-transaction", message.encoded);
       } catch (publishError) {
         console.warn("peernet publish failed: add-transaction", publishError?.message ?? publishError);
       }
@@ -1267,6 +1244,15 @@ const validateChainLink = (localTip, incoming) => {
   return "append";
 };
 
+const resolveTransactionReference = async (expectedHash, transactionData) => {
+  const transaction = transactionData instanceof TransactionMessage ? transactionData : new TransactionMessage(transactionData);
+  const actualHash = await transaction.hash();
+  if (actualHash !== expectedHash) {
+    throw new Error(`Transaction hash mismatch: expected ${expectedHash}, got ${actualHash}`);
+  }
+  return transaction;
+};
+
 const debug$1 = createDebugger("leofcoin/state");
 class State extends Contract {
   constructor(config) {
@@ -1283,7 +1269,7 @@ class State extends Contract {
     this.#totalSize = 0;
     this.#canonicalStateQueue = new CanonicalStateQueue();
     this.#loaded = false;
-    this.#resolvingHashes = /* @__PURE__ */ new Set();
+    this.#resolvingHashes = /* @__PURE__ */ new Map();
     this._wantList = [];
     this.#chainStateHandler = () => {
       return new globalThis.peernet.protos["peernet-response"]({
@@ -1539,7 +1525,8 @@ class State extends Contract {
         if (!exists) {
           const data = await peernet.get(hash, "transaction");
           if (!data) throw new Error(`missing transaction data for ${hash}`);
-          await transactionStore.put(hash, data);
+          const transaction = await resolveTransactionReference(hash, data);
+          await transactionStore.put(hash, transaction.encoded);
         }
         const inPool = await transactionPoolStore.has(hash);
         if (inPool) await transactionPoolStore.delete(hash);
@@ -1547,84 +1534,61 @@ class State extends Contract {
     );
   }
   async #resolveBlock(hash) {
-    let index = this.#blockHashMap.get(hash);
-    let localHash = "0x0";
-    try {
-      const rawLocalHash = await globalThis.stateStore.get("lastBlock");
-      if (rawLocalHash) {
-        const decoded = JSON.parse(new TextDecoder().decode(rawLocalHash));
-        localHash = typeof decoded === "string" ? decoded : decoded?.hash ?? "0x0";
+    const localHash = (await this.canonicalTip()).hash;
+    const visited = /* @__PURE__ */ new Set();
+    while (hash !== "0x0" && hash !== localHash) {
+      if (visited.has(hash)) throw new ResolveError(`cyclic block ancestry at ${hash}`);
+      visited.add(hash);
+      const cachedIndex = this.#blockHashMap.get(hash);
+      const cached = this.#blocks[cachedIndex];
+      if (cached) {
+        hash = cached.previousHash;
+        continue;
       }
-    } catch (error) {
-      debug$1("no local state found");
-    }
-    if (this.#blocks[index]) {
-      const previousHash = this.#blocks[index].previousHash;
-      if (previousHash === localHash) return;
-      if (previousHash !== "0x0") {
-        return this.resolveBlock(previousHash);
-      } else {
-        return;
+      try {
+        const block = await this.getAndPutBlock(hash);
+        await this.#resolveTransactions(block.decoded.transactions);
+        const index = block.decoded.index;
+        const size = block.encoded.byteLength;
+        this.#totalSize += size;
+        this.#blocks[index] = { hash, ...block.decoded };
+        this.#blockHashMap.set(hash, index);
+        debug$1(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
+        globalThis.pubsub.publish("block-resolved", { hash, index });
+        this.#lastResolved = this.#blocks[index];
+        this.#lastResolvedTime = Date.now();
+        hash = block.decoded.previousHash;
+      } catch (error) {
+        throw new ResolveError(`block: ${hash}`, { cause: error });
       }
     }
-    try {
-      const block = await this.getAndPutBlock(hash);
-      const promises = [];
-      if (block.decoded.previousHash !== "0x0" && block.decoded.previousHash !== localHash) {
-        promises.push(this.resolveBlock(block.decoded.previousHash));
-      }
-      promises.push(this.#resolveTransactions(block.decoded.transactions));
-      await Promise.all(promises);
-      index = block.decoded.index;
-      const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength;
-      this.#totalSize += size;
-      this.#blocks[index] = { hash, ...block.decoded };
-      this.#blockHashMap.set(hash, index);
-      debug$1(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
-      globalThis.pubsub.publish("block-resolved", { hash, index });
-      this.#lastResolved = this.#blocks[index];
-      this.#lastResolvedTime = Date.now();
-    } catch (error) {
-      throw new ResolveError(`block: ${hash}@${index}`, { cause: error });
-    }
-    return;
   }
   async resolveBlock(hash) {
     if (!hash) throw new Error(`expected hash, got: ${hash}`);
     if (hash === "0x0") return;
-    if (this.#resolvingHashes.has(hash)) return;
-    this.#resolvingHashes.add(hash);
-    const isEntering = this.#resolvingHashes.size === 1;
+    const existing = this.#resolvingHashes.get(hash);
+    if (existing) return existing;
     this.#resolving = true;
-    try {
-      if (isEntering) {
-        if (this.jobber.busy && this.jobber.destroy) await this.jobber.destroy();
-        await this.jobber.add(() => this.#resolveBlock(hash));
-      } else {
-        await this.#resolveBlock(hash);
-      }
-      try {
-        const lastBlockHash = await globalThis.stateStore.get("lastBlock");
-        if (lastBlockHash === hash) {
+    const resolution = Promise.resolve().then(async () => {
+      for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+          await this.#resolveBlock(hash);
           this.#resolveErrored = false;
           return;
+        } catch (error) {
+          console.error(`block resolution attempt ${attempt + 1} failed for ${hash}`, error);
+          if (attempt === 2) {
+            if (!this.wantList.includes(hash)) this.wantList.push(hash);
+            throw new ResolveError(`block: ${hash}`, { cause: error });
+          }
         }
-      } catch (error) {
       }
-    } catch (error) {
-      console.log({ error });
-      this.#resolveErrorCount += 1;
-      if (this.#resolveErrorCount < 3) {
-        this.#resolvingHashes.delete(hash);
-        return this.resolveBlock(hash);
-      }
-      this.#resolveErrorCount = 0;
-      this.wantList.push(hash);
-      throw new ResolveError(`block: ${hash}`, { cause: error });
-    } finally {
+    }).finally(() => {
       this.#resolvingHashes.delete(hash);
       if (this.#resolvingHashes.size === 0) this.#resolving = false;
-    }
+    });
+    this.#resolvingHashes.set(hash, resolution);
+    return resolution;
   }
   async resolveBlocks() {
     if (this.#chainSyncing || this.#resolving) {
@@ -1761,24 +1725,6 @@ class State extends Contract {
         return;
       }
       if (localStateHash !== remoteBlockHash) {
-        if (this.wantList.length > 0) {
-          debug$1(`Fetching ${this.wantList.length} blocks before resolving`);
-          const getBatch = async (batch) => {
-            const blocks2 = await Promise.all(
-              batch.map(
-                (hash) => this.getAndPutBlock(hash).catch((e) => {
-                  console.warn(`failed to fetch block ${hash}`, e);
-                })
-              )
-            );
-            const transactions = blocks2.filter((block) => Boolean(block)).flatMap((block) => block.decoded.transactions);
-            return this.#resolveTransactions(transactions);
-          };
-          for (let i = 0; i < this.wantList.length; i += 50) {
-            const batch = this.wantList.slice(i, i + 50);
-            await getBatch(batch);
-          }
-        }
         debug$1(`Resolving remote block: ${remoteBlockHash} @${remoteIndex} (differs from local state)`);
         await this.resolveBlock(remoteBlockHash);
         const blocksSynced = remoteIndex - localIndex;
@@ -2134,15 +2080,6 @@ const validateBlockEconomics = (block, calculatedFees, validatorFees = /* @__PUR
   }
 };
 
-const resolveTransactionReference = async (expectedHash, transactionData) => {
-  const transaction = transactionData instanceof TransactionMessage ? transactionData : new TransactionMessage(transactionData);
-  const actualHash = await transaction.hash();
-  if (actualHash !== expectedHash) {
-    throw new Error(`Transaction hash mismatch: expected ${expectedHash}, got ${actualHash}`);
-  }
-  return transaction;
-};
-
 const consensusSignableData = (validatorsAddress, type, message) => ({
   from: String(message.from),
   to: validatorsAddress,
@@ -2960,39 +2897,29 @@ class Chain extends VersionControl {
   }
   async getPeerTransactionPool(peer) {
     let transactionsInPool = await this.#makeRequest(peer, "transactionPool");
-    console.log("raw response for request transactionPool:", transactionsInPool);
     if (transactionsInPool instanceof Uint8Array) {
-      try {
-        transactionsInPool = JSON.parse(new TextDecoder().decode(transactionsInPool));
-      } catch {
-        debug("transactionPool response must be decoded array payload");
-        return [];
-      }
+      transactionsInPool = new TextDecoder().decode(transactionsInPool);
     }
     if (typeof transactionsInPool === "string") {
-      try {
-        transactionsInPool = JSON.parse(transactionsInPool);
-      } catch {
-        return [];
-      }
+      transactionsInPool = JSON.parse(transactionsInPool);
     }
-    if (!Array.isArray(transactionsInPool)) return [];
-    const localTransactions = new Set(await globalThis.transactionPoolStore.keys());
-    const transactionsToGet = [];
-    for (const key of transactionsInPool) {
-      if (!localTransactions.has(key)) {
-        let txData;
-        try {
-          txData = await globalThis.peernet.get(key, "transaction");
-        } catch (error) {
-          debug(`Failed to get transaction ${key}:`, error?.message ?? error);
-        }
-        if (txData !== void 0) {
-          transactionsToGet.push(transactionPoolStore.put(key, txData));
-        }
+    if (!Array.isArray(transactionsInPool) || transactionsInPool.some((hash) => typeof hash !== "string")) {
+      throw new Error("transactionPool response must be an array of transaction hashes");
+    }
+    const recovered = [];
+    for (const hash of new Set(transactionsInPool)) {
+      if (await globalThis.transactionPoolStore.has(hash)) continue;
+      if (await globalThis.transactionStore.has(hash)) continue;
+      try {
+        const txData = await globalThis.peernet.get(hash, "transactionPool");
+        if (txData === void 0) throw new Error("pending transaction body unavailable");
+        const transaction = await resolveTransactionReference(hash, txData);
+        recovered.push(await this.#sendTransaction(transaction));
+      } catch (error) {
+        debug(`Failed to recover transaction ${hash}:`, error?.message ?? error);
       }
     }
-    return Promise.all(transactionsToGet);
+    return recovered;
   }
   async #peerConnected(peerId) {
     if (typeof peerId !== "string" || !peerId.trim() || peerId === "undefined") {
@@ -3060,6 +2987,14 @@ class Chain extends VersionControl {
       await this.#recordPeerFailure(peerId, `unreasonable lastBlock index: ${lastBlock.index}`);
       return;
     }
+    setTimeout(async () => {
+      try {
+        await this.getPeerTransactionPool(peer);
+      } catch (error) {
+        const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
+        debug(`transactionPool request failed: ${peerName}:`, error?.message ?? error);
+      }
+    }, 3e3);
     if (!lastBlock || !lastBlock.hash || lastBlock.hash === "0x0") {
       debug(`peer has no lastBlock: ${peerId}`);
       return;
@@ -3092,22 +3027,6 @@ class Chain extends VersionControl {
         }
       }
     }
-    if (this.wantList.length > 0) {
-      const promises = await Promise.allSettled(this.wantList.map((hash) => peernet.get(hash, "block")));
-      for (let i = promises.length - 1; i >= 0; i -= 1) {
-        if (promises[i].status === "fulfilled") this.wantList.splice(i, 1);
-      }
-      if (this.wantList.length === 0) await this.triggerSync();
-    }
-    setTimeout(async () => {
-      try {
-        const peerTransactionPool = higherThenCurrentLocal && await this.getPeerTransactionPool(peer) || [];
-        if (this.#participating && peerTransactionPool.length > 0) return this.#runEpoch();
-      } catch (error) {
-        const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
-        debug(`transactionPool request failed: ${peerName}:`, error?.message ?? error);
-      }
-    }, 3e3);
     try {
       let stateInfo = await this.#makeRequest(peer, "stateInfo");
       if (stateInfo instanceof Uint8Array) {
@@ -3484,18 +3403,32 @@ class Chain extends VersionControl {
     await this.validateTransactionSignature(transaction);
     let hash;
     try {
+      hash = await transaction.hash();
+      if (await globalThis.transactionStore.has(hash)) return hash;
+      const alreadyPending = await globalThis.transactionPoolStore.has(hash);
       hash = await enqueueTransaction(transaction, {
         putToPool: (txHash, data) => globalThis.transactionPoolStore.put(txHash, data),
         hasInPool: (txHash) => globalThis.transactionPoolStore.has(txHash),
         hasInStore: (txHash) => globalThis.transactionStore.has(txHash),
         addPendingNonce: (address, nonce) => this.addPendingNonce(address, nonce)
       });
-      if (this.#participating && !this.#runningEpoch) this.#runEpoch();
+      if (!alreadyPending) {
+        try {
+          await globalThis.peernet.publish("add-transaction", transaction.encoded);
+        } catch (publishError) {
+          debug("peernet publish failed: add-transaction relay", publishError?.message ?? publishError);
+        }
+      }
+      if (this.#participating && !this.#runningEpoch) {
+        void this.#runEpoch().catch((error) => {
+          debug("transaction epoch scheduling failed:", error?.message ?? error);
+        });
+      }
       return hash;
     } catch (e) {
       if (hash) {
         try {
-          globalThis.peernet.publish("invalid-transaction", hash);
+          await globalThis.peernet.publish("invalid-transaction", hash);
         } catch (publishError) {
           debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
         }
@@ -3513,7 +3446,7 @@ class Chain extends VersionControl {
     const event = await super.sendTransaction(transactionMessage);
     await this.#sendTransaction(transactionMessage.encoded);
     try {
-      globalThis.peernet.publish("send-transaction", transactionMessage.encoded);
+      await globalThis.peernet.publish("send-transaction", transactionMessage.encoded);
     } catch (publishError) {
       debug("peernet publish failed: send-transaction", publishError?.message ?? publishError);
     }