@leofcoin/chain 1.10.20 → 1.10.22

package/README.md

@@ -6,4 +6,42 @@
 
 - reachedOneZeroZero
 
+## Cold-sync reliability
+
+Both server and browser nodes guard provider discovery against fast negative
+responses. A walk succeeds only after a connected peer confirms it provides
+the requested hash; individual discovery requests retain the protocol request
+timeout.
+
+Chain content requests probe the exact requested store before requesting bytes
+from a peer. A pending-only copy cannot act as a provider for the canonical
+transaction store. Responses must use the expected codec and advertised hash;
+the first valid response wins, and unavailable content fails explicitly.
+
+Historical ancestry is resolved iteratively, finishing transaction dependencies
+before requesting the next parent. Duplicate callers await the same resolution,
+completed blocks survive retries, and missing or cyclic ancestry fails explicitly.
+Only dependencies of the selected target tip are resolved; unrelated hashes in
+a peer's `knownBlocks` inventory do not gate canonical catch-up.
+Transaction bodies are hash-checked before entering the canonical transaction
+store. Resolving data never applies it: canonical loading still uses the
+serialized state writer and chain-link validation.
+
+## Pending transaction propagation
+
+Transactions enter the local pending pool before canonical confirmation. Peers
+relay newly accepted transaction bytes using the existing `add-transaction`
+topic; duplicate and already-confirmed entries are not relayed again.
+
+On compatible peer reconnection, pending pools are reconciled even at equal
+block heights. Missing bodies are fetched from `transactionPool`, checked against
+their advertised hash, and admitted through the normal signature-validation and
+pending-nonce path. Unavailable or invalid entries are logged without preventing
+recovery of the remaining entries.
+
+Pool admission and pubsub publication are not validator acknowledgements.
+`sendTransaction().wait` resolves only after canonical block inclusion. Deploy
+the updated chain runtime to intermediate nodes and validators as well as the
+browser to enable relay and reconnect recovery throughout the network.
+
 <a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/"><img alt="Creative Commons Licence" style="border-width:0" src="https://i.creativecommons.org/l/by-nc/4.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/">Creative Commons Attribution-NonCommercial 4.0 International License</a>.

package/exports/browser/beacon-wire.js

@@ -1,4 +1,4 @@
-import { s as signTransaction, c as MultiWallet, d as createTransactionHash } from './index-DCbLvMKL.js';
+import { s as signTransaction, c as MultiWallet, d as createTransactionHash } from './index-dxD17Fom.js';
 import { f as fromBase58 } from './index-CvKt4UDE.js';
 import './browser-crypto-CH0ua22L.js';
 import './sha2-BKcEJzgd.js';

package/exports/browser/{browser-CCfR9KOM-BGMMnVsR.js → browser-CCfR9KOM-UO9mzy-j.js}

@@ -1,8 +1,8 @@
-import { g as getDefaultExportFromCjs } from './node-browser-Ha4Lvntj.js';
+import { g as getDefaultExportFromCjs } from './node-browser-BMfelxXV.js';
 import './browser-crypto-CH0ua22L.js';
 import './index-CvKt4UDE.js';
 import './sha2-BKcEJzgd.js';
-import './connection-monitor-D-krNiRH.js';
+import './connection-monitor-DMGAhcC0.js';
 
 function _mergeNamespaces$1(n, m) {
 	m.forEach(function (e) {

package/exports/browser/chain.js

@@ -1,6 +1,6 @@
 import { F as FormatInterface, p as proto, a as proto$1, b as proto$2, T as TransactionMessage, j as jsonStringifyBigInt, c as jsonParseBigInt, C as ContractMessage, d as Codec } from './browser-crypto-CH0ua22L.js';
-import { B as BlockMessage, L as LastBlockMessage, P as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO, C as ConnectionMonitor, a as BWMessage, S as StateMessage } from './connection-monitor-D-krNiRH.js';
-import { M as MAX_TRANSACTION_BYTES, a as MAX_BLOCK_TRANSACTION_BYTES, b as MAX_BLOCK_TRANSACTIONS, c as MultiWallet, d as createTransactionHash, e as calculateFee, f as createContractMessage, s as signTransaction, r as randombytes, g as distributeTransactionFee, h as supportsTransactionFees, i as supportsMonetaryPolicy, v as validateBlockResourceLimits, j as calculateMonetaryPolicy, k as distributeAmount, l as aggregateValidatorFees, m as MONETARY_POLICY_AUTHORITY, n as contractFactoryMessage, o as nativeTokenMessage, p as validatorsMessage, q as nameServiceMessage, t as parseUnits, u as formatUnits } from './index-DCbLvMKL.js';
+import { P as Protocol, B as BlockMessage, L as LastBlockMessage, a as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO, C as ConnectionMonitor, b as BWMessage, S as StateMessage } from './connection-monitor-DMGAhcC0.js';
+import { M as MAX_TRANSACTION_BYTES, a as MAX_BLOCK_TRANSACTION_BYTES, b as MAX_BLOCK_TRANSACTIONS, c as MultiWallet, d as createTransactionHash, e as calculateFee, f as createContractMessage, s as signTransaction, r as randombytes, g as distributeTransactionFee, h as supportsTransactionFees, i as supportsMonetaryPolicy, v as validateBlockResourceLimits, j as calculateMonetaryPolicy, k as distributeAmount, l as aggregateValidatorFees, m as MONETARY_POLICY_AUTHORITY, n as contractFactoryMessage, o as nativeTokenMessage, p as validatorsMessage, q as nameServiceMessage, t as parseUnits, u as formatUnits } from './index-dxD17Fom.js';
 import { f as fromBase58 } from './index-CvKt4UDE.js';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers-B85MJLTf.js';
 import { q as quorumThreshold } from './quorum-S_qdgiAY.js';
@@ -2915,29 +2915,6 @@ function requireSemver () {
 var semverExports = requireSemver();
 var semver = /*@__PURE__*/getDefaultExportFromCjs(semverExports);
 
-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 = () => {
@@ -3164,7 +3141,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);
       }
@@ -4304,6 +4281,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) {
@@ -4320,7 +4306,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"]({
@@ -4576,7 +4562,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);
@@ -4584,84 +4571,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";
-      }
-    } 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;
+    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;
       }
-    }
-    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));
+      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 });
       }
-      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) {
@@ -4798,24 +4762,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;
@@ -5171,15 +5117,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,
@@ -6077,39 +6014,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") {
@@ -6177,6 +6104,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;
@@ -6209,22 +6144,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) {
@@ -6601,18 +6520,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);
         }
@@ -6630,7 +6563,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);
     }