@leofcoin/chain 1.10.21 → 1.11.0

package/exports/state-checkpoint-BiQ1EXzo.js

@@ -0,0 +1,110 @@
+import { BlockMessage } from '@leofcoin/messages';
+import { jsonParseBigInt, jsonStringifyBigInt } from '@leofcoin/utils';
+
+const validateChainLink = (localTip, incoming) => {
+  const localHash = localTip?.hash || "0x0";
+  const localIndex = Number(localTip?.index ?? -1);
+  const hasCanonicalTip = localHash !== "0x0";
+  if (hasCanonicalTip && incoming.index < localIndex) return "stale";
+  if (hasCanonicalTip && incoming.index === localIndex) {
+    if (incoming.hash === localHash) return "duplicate";
+    throw new Error(`Block conflict detected at index ${incoming.index}`);
+  }
+  const expectedIndex = hasCanonicalTip ? localIndex + 1 : 0;
+  if (incoming.index !== expectedIndex) {
+    throw new Error(`Unexpected block index ${incoming.index}; expected ${expectedIndex}`);
+  }
+  if (incoming.previousHash !== localHash) {
+    throw new Error(
+      `previousHash mismatch at index ${incoming.index}: expected ${localHash}, got ${incoming.previousHash}`
+    );
+  }
+  return "append";
+};
+
+const CHECKPOINT_KEYS = ["checkpoint:0", "checkpoint:1"];
+const counters = [
+  "nativeCalls",
+  "nativeMints",
+  "nativeBurns",
+  "nativeTransfers",
+  "totalBurnAmount",
+  "totalMintAmount",
+  "totalTransferAmount",
+  "totalTransactions",
+  "totalBlocks"
+];
+const record = (value) => value && typeof value === "object" && !Array.isArray(value);
+const text = (value) => typeof value === "string" ? value : new TextDecoder("utf-8", { fatal: true }).decode(value);
+const digest = async (value) => [...new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value)))].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+function validateCheckpoint(snapshot, chainId, requiredContracts) {
+  if (!record(snapshot) || snapshot.chainId !== chainId || !record(snapshot.states) || !record(snapshot.accounts) || !record(snapshot.info))
+    throw new Error("Invalid checkpoint or chain identity");
+  const tip = snapshot.lastBlock;
+  const index = Number(tip?.index);
+  if (!["bigint", "number"].includes(typeof tip?.index) || !Number.isSafeInteger(index) || index < -1 || (index === -1 ? tip.hash !== "0x0" : typeof tip.hash !== "string" || !tip.hash || tip.hash === "0x0"))
+    throw new Error("Invalid checkpoint tip");
+  for (const contract of requiredContracts) if (!record(snapshot.states[contract])) throw new Error(`Incomplete checkpoint contract: ${contract}`);
+  for (const [address, nonce] of Object.entries(snapshot.accounts))
+    if (!address || typeof nonce !== "string" || !/^(0|[1-9]\d*)$/.test(nonce)) throw new Error("Invalid checkpoint nonce");
+  for (const counter of counters)
+    if (typeof snapshot.info[counter] !== "bigint" || snapshot.info[counter] < 0n) throw new Error(`Invalid checkpoint counter: ${counter}`);
+  if (snapshot.info.totalBlocks !== BigInt(index) + 1n) throw new Error("Checkpoint block count does not match tip");
+  return snapshot;
+}
+async function writeCheckpoint(store, snapshot, generation, requiredContracts) {
+  if (!Number.isSafeInteger(generation) || generation < 0) throw new Error("Invalid checkpoint generation");
+  validateCheckpoint(snapshot, snapshot.chainId, requiredContracts);
+  const payload = JSON.stringify({ generation, snapshot }, jsonStringifyBigInt);
+  await store.put(CHECKPOINT_KEYS[generation % 2], new TextEncoder().encode(JSON.stringify({ schema: 1, payload, checksum: await digest(payload) })));
+}
+async function readCheckpoint(store, chainId, requiredContracts) {
+  const valid = [];
+  let present = 0;
+  const keys = new Set(await store.keys());
+  for (const key of CHECKPOINT_KEYS) {
+    if (!keys.has(key)) continue;
+    present++;
+    const bytes = await store.get(key);
+    try {
+      const envelope = JSON.parse(text(bytes));
+      if (envelope.schema !== 1 || typeof envelope.payload !== "string" || envelope.checksum !== await digest(envelope.payload)) throw new Error("Invalid checkpoint checksum");
+      const result = JSON.parse(envelope.payload, jsonParseBigInt);
+      if (!Number.isSafeInteger(result.generation) || result.generation < 0 || result.generation % 2 !== CHECKPOINT_KEYS.indexOf(key)) throw new Error("Invalid checkpoint generation");
+      validateCheckpoint(result.snapshot, chainId, requiredContracts);
+      valid.push(result);
+    } catch {
+    }
+  }
+  if (present && !valid.length) throw new Error("No valid state checkpoint remains; preserve this data root and rebuild in a separate root");
+  return valid.sort((left, right) => right.generation - left.generation)[0];
+}
+async function recoveryHistory(hash, readBlock) {
+  const reversed = [];
+  const seen = /* @__PURE__ */ new Set();
+  while (hash !== "0x0") {
+    if (!hash || seen.has(hash)) throw new Error("Invalid or cyclic recovery ancestry");
+    seen.add(hash);
+    const bytes = await readBlock(hash);
+    if (!bytes) throw new Error(`Recovery block unavailable: ${hash}`);
+    const message = new BlockMessage(bytes);
+    if (await message.hash() !== hash) throw new Error(`Recovery block hash mismatch: ${hash}`);
+    reversed.push({ ...message.decoded, hash, loaded: false });
+    hash = message.decoded.previousHash;
+  }
+  const history = reversed.reverse();
+  let tip = { index: -1, hash: "0x0" };
+  for (const block of history) {
+    const index = Number(block.index);
+    if (!Number.isSafeInteger(index) || index < 0) throw new Error("Invalid recovery block index");
+    if (validateChainLink(tip, { index, hash: block.hash, previousHash: block.previousHash }) !== "append") throw new Error("Invalid recovery chain link");
+    tip = { index, hash: block.hash };
+  }
+  return history;
+}
+async function restoreAccountNonces(store, accounts) {
+  await store.clear();
+  for (const [address, nonce] of Object.entries(accounts)) await store.put(address, String(nonce));
+}
+
+export { CHECKPOINT_KEYS as C, recoveryHistory as a, restoreAccountNonces as b, validateCheckpoint as c, readCheckpoint as r, validateChainLink as v, writeCheckpoint as w };

package/exports/state-checkpoint.js

@@ -0,0 +1,3 @@
+import '@leofcoin/messages';
+import '@leofcoin/utils';
+export { C as CHECKPOINT_KEYS, r as readCheckpoint, a as recoveryHistory, b as restoreAccountNonces, c as validateCheckpoint, w as writeCheckpoint } from './state-checkpoint-BiQ1EXzo.js';

package/exports/workers/block-worker.js

@@ -1,6 +1,6 @@
-import { E as EasyWorker, F as FormatInterface, p as proto$3, e as encodeFrames, d as decodeFrames, a as proto$2 } from './worker-BDTWOCzS-COrAszCt.js';
+import { B as BinaryWorker, a as BinaryFormat, p as proto$2, e as encodeFrames, d as decodeFrames, b as proto$1 } from './proposal.proto-8zgMfutf-B3So_tnS.js';
 
-class ValidatorMessage extends FormatInterface {
+class ValidatorMessage extends BinaryFormat {
     get messageName() {
         return 'ValidatorMessage';
     }
@@ -8,11 +8,11 @@ class ValidatorMessage extends FormatInterface {
         if (buffer instanceof ValidatorMessage)
             return buffer;
         const name = 'validator-message';
-        super(buffer, proto$2, { name });
+        super(buffer, proto$1, { name });
     }
 }
 
-class BlockMessage extends FormatInterface {
+class BlockMessage extends BinaryFormat {
     get messageName() {
         return 'BlockMessage';
     }
@@ -20,7 +20,7 @@ class BlockMessage extends FormatInterface {
         if (buffer instanceof BlockMessage)
             return buffer;
         const name = 'block-message';
-        super(buffer, proto$3, { name });
+        super(buffer, proto$2, { name });
     }
     encode(decoded) {
         decoded = decoded || this.decoded;
@@ -40,14 +40,13 @@ class BlockMessage extends FormatInterface {
         encoded = encoded || this.encoded;
         super.decode(encoded);
         // @ts-ignore
-        // Preserve historical acceptance of padded length prefixes. Tightening
-        // canonical protocol validation is a separate, versioned decision.
-        this.decoded.validators = decodeFrames(this.decoded.validators, 0, { canonical: false }).map((validator) => new ValidatorMessage(validator).decoded);
+        // Binary-only protocol also requires canonical validator frame lengths.
+        this.decoded.validators = decodeFrames(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
         return this.decoded;
     }
 }
 
-const worker = new EasyWorker();
+const worker = new BinaryWorker();
 globalThis.BigNumber = BigNumber;
 globalThis.contracts = {};
 const run = async (blocks) => {