@leofcoin/chain 1.10.21 → 1.10.22

package/README.md

@@ -6,6 +6,27 @@
 
 - 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

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 = () => {
@@ -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,
@@ -6207,13 +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();
-    }
     try {
       let stateInfo = await this.#makeRequest(peer, "stateInfo");
       if (stateInfo instanceof Uint8Array) {