@leofcoin/chain 1.10.6 → 1.10.8

package/exports/chain.js

@@ -1115,6 +1115,87 @@ class Jobber {
   }
 }
 
+const MAX_RESPONSE_DEPTH$1 = 3;
+const asLastBlockMessage = async (blockInput, claimedHash) => {
+  const block = new BlockMessage(blockInput);
+  const hash = await block.hash();
+  if (claimedHash && hash !== claimedHash) {
+    throw new Error(`lastBlock hash mismatch: expected ${claimedHash}, got ${hash}`);
+  }
+  return new LastBlockMessage({ hash, index: block.decoded.index });
+};
+const resolveLegacyHash = async (hash) => {
+  const blockData = await globalThis.peernet?.get?.(hash, "block");
+  if (!blockData) throw new Error(`unable to resolve lastBlock hash: ${hash}`);
+  return asLastBlockMessage(blockData, hash);
+};
+const resolveLastBlockMessage = async (result, depth = 0) => {
+  if (depth > MAX_RESPONSE_DEPTH$1) throw new Error("lastBlock response nesting exceeds limit");
+  if (result instanceof Uint8Array) {
+    let codec;
+    try {
+      codec = new Codec(result);
+    } catch {
+    }
+    if (codec) {
+      if (codec.name === "peernet-response") {
+        const ResponseMessage = globalThis.peernet?.protos?.["peernet-response"];
+        if (!ResponseMessage) throw new Error("peernet-response codec is not registered");
+        const wrapped = new ResponseMessage(result);
+        if (wrapped?.decoded?.response === void 0) throw new Error("peernet-response has no response payload");
+        return resolveLastBlockMessage(wrapped.decoded.response, depth + 1);
+      }
+      if (codec.name === "last-block-message") return new LastBlockMessage(result);
+      if (codec.name === "block-message") return asLastBlockMessage(result);
+    }
+    const candidate = new TextDecoder().decode(result);
+    if (candidate) return resolveLegacyHash(candidate);
+  }
+  if (typeof result === "string") return resolveLegacyHash(result);
+  if (result && typeof result === "object") {
+    const response = result.decoded?.response ?? result.response;
+    if (response !== void 0) return resolveLastBlockMessage(response, depth + 1);
+    if ("hash" in result && "index" in result) return new LastBlockMessage(result);
+    if ("previousHash" in result && "index" in result) return asLastBlockMessage(result);
+  }
+  throw new Error(`invalid lastBlock payload: ${typeof result}`);
+};
+
+const MAX_RESPONSE_DEPTH = 3;
+const decodeResponsePayload = async (result, depth = 0) => {
+  if (depth > MAX_RESPONSE_DEPTH) throw new Error("peernet response nesting exceeds limit");
+  if (result instanceof Uint8Array) {
+    let codec;
+    try {
+      codec = new Codec(result);
+    } catch {
+    }
+    if (codec?.name === "peernet-response") {
+      const ResponseMessage = globalThis.peernet?.protos?.["peernet-response"];
+      if (!ResponseMessage) throw new Error("peernet-response codec is not registered");
+      const wrapped = new ResponseMessage(result);
+      return decodeResponsePayload(wrapped.decoded.response, depth + 1);
+    }
+    try {
+      return JSON.parse(new TextDecoder().decode(result));
+    } catch {
+      return result;
+    }
+  }
+  if (result && typeof result === "object") {
+    const response = result.decoded?.response ?? result.response;
+    if (response !== void 0) return decodeResponsePayload(response, depth + 1);
+  }
+  if (typeof result === "string") {
+    try {
+      return JSON.parse(result);
+    } catch {
+      return result;
+    }
+  }
+  return result;
+};
+
 const debug$1 = createDebugger("leofcoin/state");
 class State extends Contract {
   constructor(config) {
@@ -1194,42 +1275,6 @@ class State extends Contract {
   get resolving() {
     return this.#resolving;
   }
-  async #resolveLastBlockMessage(result) {
-    if (result instanceof Uint8Array) {
-      try {
-        let payload = result;
-        for (let i = 0; i < 3; i += 1) {
-          try {
-            const wrapped = await new globalThis.peernet.protos["peernet-response"](payload);
-            if (wrapped?.decoded?.response === void 0) break;
-            payload = wrapped.decoded.response;
-          } catch {
-            break;
-          }
-        }
-        if (payload !== result) return this.#resolveLastBlockMessage(payload);
-        return new LastBlockMessage(result);
-      } catch {
-        const candidate = new TextDecoder().decode(result);
-        if (candidate) {
-          const blockData = await globalThis.peernet.get(candidate, "block");
-          if (blockData) return new BlockMessage(blockData);
-        }
-      }
-    }
-    if (typeof result === "string") {
-      const blockData = await globalThis.peernet.get(result, "block");
-      if (blockData) return new BlockMessage(blockData);
-    }
-    if (result && typeof result === "object") {
-      const response = result.decoded?.response ?? result.response;
-      if (response !== void 0) return this.#resolveLastBlockMessage(response);
-      if ("hash" in result && "index" in result) {
-        return new LastBlockMessage(result);
-      }
-    }
-    throw new Error(`invalid lastBlock payload: ${typeof result}`);
-  }
   get contracts() {
     return this.#machine.contracts;
   }
@@ -1674,21 +1719,9 @@ class State extends Contract {
         compatiblePeerCount += 1;
         const task = async () => {
           try {
-            let result = await peer.request(node.encoded);
+            const result = await peer.request(node.encoded);
             const resultType = result instanceof Uint8Array ? `bytes:${result.length}` : typeof result;
             debug$1(`lastBlock result type: ${resultType}`);
-            console.log({ result });
-            if (result instanceof Uint8Array) {
-              for (let i = 0; i < 3; i += 1) {
-                try {
-                  const wrapped = await new globalThis.peernet.protos["peernet-response"](result);
-                  if (wrapped?.decoded?.response === void 0) break;
-                  result = wrapped.decoded.response;
-                } catch {
-                  break;
-                }
-              }
-            }
             return { result, peer };
           } catch (error) {
             const peerId = peer?.peerId || peer?.id || peer?.address || "unknown";
@@ -1712,7 +1745,7 @@ class State extends Contract {
     console.log({ promises });
     promises = await Promise.all(
       promises.map(async (item) => ({
-        value: (await this.#resolveLastBlockMessage(item.value)).decoded,
+        value: (await resolveLastBlockMessage(item.value)).decoded,
         peer: item.peer
       }))
     );
@@ -1733,10 +1766,11 @@ class State extends Contract {
         });
         let node2 = await globalThis.peernet.prepareMessage(data2);
         try {
-          let message2 = await peer.request(node2.encoded);
-          message2 = await new globalThis.peernet.protos["peernet-response"](message2);
+          const message2 = await decodeResponsePayload(await peer.request(node2.encoded));
+          const blocks = message2?.blocks;
+          if (!Array.isArray(blocks)) throw new Error("knownBlocks response does not contain a blocks array");
           const MAX_WANTLIST_SIZE = 1e3;
-          const incoming = message2.decoded.response.blocks.filter((block) => !this.knownBlocks.includes(block));
+          const incoming = blocks.filter((block) => !this.knownBlocks.includes(block));
           const remaining = MAX_WANTLIST_SIZE - this.wantList.length;
           if (remaining > 0) this.wantList.push(...incoming.slice(0, remaining));
         } catch (error) {
@@ -1816,28 +1850,20 @@ class State extends Contract {
     this.#chainState = "loaded";
     return true;
   }
-  promiseRequests(promises) {
-    return new Promise(async (resolve, reject) => {
-      const timeout = setTimeout(() => {
-        resolve([{ index: 0, hash: "0x0" }]);
-        debug$1("sync timed out");
-      }, this.requestTimeout);
-      console.log({ promises });
-      promises = await Promise.allSettled(promises);
-      console.log({ promises });
-      promises = promises.filter(({ status }) => status === "fulfilled");
-      clearTimeout(timeout);
-      if (promises.length > 0) {
-        promises = promises.map(async ({ value }) => {
-          const node = await new globalThis.peernet.protos["peernet-response"](value.result);
-          return { value: node.decoded.response, peer: value.peer };
-        });
-        promises = await Promise.all(promises);
-        resolve(promises);
-      } else {
-        resolve([]);
-      }
-    });
+  async promiseRequests(promises) {
+    let timeout;
+    const settled = await Promise.race([
+      Promise.allSettled(promises),
+      new Promise((resolve) => {
+        timeout = setTimeout(() => resolve(null), this.requestTimeout);
+      })
+    ]);
+    clearTimeout(timeout);
+    if (settled === null) {
+      debug$1("sync timed out");
+      return [];
+    }
+    return settled.filter(({ status }) => status === "fulfilled").map(({ value }) => ({ value: value.result, peer: value.peer }));
   }
   get canSync() {
     if (this.#chainSyncing) return false;
@@ -2250,6 +2276,46 @@ const validateChainLink = (localTip, incoming) => {
   return "append";
 };
 
+const BLOCK_REWARD = 150n;
+const validateCanonicalValidatorSet = (blockIndex, expectedValidators, validators) => {
+  const actualValidators = validators.map(({ address }) => address);
+  const canonicalExpected = [...new Set(expectedValidators)].sort();
+  if (actualValidators.length !== canonicalExpected.length || actualValidators.some((address, index) => address !== canonicalExpected[index])) {
+    throw new Error(
+      `Block ${blockIndex} validator set mismatch: expected ${canonicalExpected.join(",")}, got ${actualValidators.join(",")}`
+    );
+  }
+};
+const validateBlockEconomics = (block, calculatedFees) => {
+  if (block.validators.length === 0) {
+    throw new Error(`Block ${block.index} cannot distribute rewards without validators`);
+  }
+  if (block.reward !== BLOCK_REWARD) {
+    throw new Error(`Block ${block.index} has invalid base reward: expected ${BLOCK_REWARD}, got ${block.reward}`);
+  }
+  if (block.fees !== calculatedFees) {
+    throw new Error(`Block ${block.index} has invalid fees: expected ${calculatedFees}, got ${block.fees}`);
+  }
+  const validatorCount = BigInt(block.validators.length);
+  const expectedReward = calculatedFees / validatorCount + BLOCK_REWARD / validatorCount;
+  for (const validator of block.validators) {
+    if (validator.reward !== expectedReward) {
+      throw new Error(
+        `Block ${block.index} has an invalid reward for validator ${validator.address}: expected ${expectedReward}, got ${validator.reward}`
+      );
+    }
+  }
+};
+
+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,
@@ -2417,8 +2483,23 @@ class Chain extends VersionControl {
             debug(`[consensus] Block hash mismatch in proposal: expected ${blockHash}, got ${actualHash}`);
             return;
           }
+          if (BigInt(blockMessage.decoded.index) !== index) {
+            debug(`[consensus] Proposal height ${index} does not match block height ${blockMessage.decoded.index}`);
+            return;
+          }
+          if (blockMessage.decoded.producer !== from) {
+            debug(`[consensus] Proposal sender ${from} does not match block producer ${blockMessage.decoded.producer}`);
+            return;
+          }
+          validateChainLink(localBlock, {
+            index: Number(blockMessage.decoded.index),
+            hash: actualHash,
+            previousHash: String(blockMessage.decoded.previousHash)
+          });
+          await this.#validateBlockValidators(blockMessage);
+          await this.#resolveBlockTransactions(blockMessage);
         } catch (e) {
-          debug(`[consensus] Cannot fetch proposed block ${blockHash}:`, e?.message);
+          debug(`[consensus] Invalid proposed block ${blockHash}:`, e?.message);
           return;
         }
         this.#consensusRound = Number(round);
@@ -2673,15 +2754,21 @@ class Chain extends VersionControl {
     if (new Set(validatorAddresses).size !== validatorAddresses.length) {
       throw new Error(`Block ${blockMessage.decoded.index} validators contain duplicates`);
     }
-    const validatorCount = BigInt(validators.length);
-    const expectedReward = blockMessage.decoded.fees / validatorCount + blockMessage.decoded.reward / validatorCount;
-    for (const validator of validators) {
-      if (validator.reward !== expectedReward) {
-        throw new Error(
-          `Block ${blockMessage.decoded.index} has an invalid reward for validator ${validator.address}: expected ${expectedReward}, got ${validator.reward}`
-        );
-      }
-    }
+    const expectedValidators = await this.staticCall(addresses.validators, "validators");
+    validateCanonicalValidatorSet(blockMessage.decoded.index, expectedValidators, validators);
+  }
+  async #resolveBlockTransactions(blockMessage) {
+    const transactions = await Promise.all(
+      blockMessage.decoded.transactions.map(async (expectedHash) => {
+        const data = await globalThis.peernet.get(expectedHash, "transaction");
+        const transaction = await resolveTransactionReference(expectedHash, data);
+        await this.validateTransactionSignature(transaction);
+        return transaction;
+      })
+    );
+    const calculatedFees = (await Promise.all(transactions.map((transaction) => calculateFee(transaction.decoded)))).reduce((total, fee) => total + BigInt(fee), 0n);
+    validateBlockEconomics(blockMessage.decoded, calculatedFees);
+    return transactions;
   }
   /** Check if the next block will cross an epoch boundary (block-based timing) */
   #isEpochBoundary(blockHeight) {
@@ -2905,42 +2992,6 @@ class Chain extends VersionControl {
       throw error;
     }
   }
-  async #resolveLastBlockMessage(result) {
-    if (result instanceof Uint8Array) {
-      try {
-        let payload = result;
-        for (let i = 0; i < 3; i += 1) {
-          try {
-            const wrapped = await new globalThis.peernet.protos["peernet-response"](payload);
-            if (wrapped?.decoded?.response === void 0) break;
-            payload = wrapped.decoded.response;
-          } catch {
-            break;
-          }
-        }
-        if (payload !== result) return this.#resolveLastBlockMessage(payload);
-        return new LastBlockMessage(result);
-      } catch {
-        const candidate = new TextDecoder().decode(result);
-        if (candidate) {
-          const blockData = await globalThis.peernet.get(candidate, "block");
-          if (blockData) return new BlockMessage(blockData);
-        }
-      }
-    }
-    if (typeof result === "string") {
-      const blockData = await globalThis.peernet.get(result, "block");
-      if (blockData) return new BlockMessage(blockData);
-    }
-    if (result && typeof result === "object") {
-      const response = result.decoded?.response ?? result.response;
-      if (response !== void 0) return this.#resolveLastBlockMessage(response);
-      if ("hash" in result && "index" in result) {
-        return new LastBlockMessage(result);
-      }
-    }
-    throw new Error(`invalid lastBlock payload: ${typeof result}`);
-  }
   async #decodeKnownBlocksResponse(response) {
     if (!response) return null;
     if (Array.isArray(response)) {
@@ -3073,7 +3124,7 @@ class Chain extends VersionControl {
       if (lastBlockRaw === void 0 || lastBlockRaw === null) {
         throw new Error(`invalid lastBlock payload: ${typeof lastBlockRaw}`);
       }
-      const lastBlockMessage = await this.#resolveLastBlockMessage(lastBlockRaw);
+      const lastBlockMessage = await resolveLastBlockMessage(lastBlockRaw);
       console.log(lastBlockMessage);
       lastBlock = lastBlockMessage.decoded;
     } catch (error) {
@@ -3216,13 +3267,7 @@ class Chain extends VersionControl {
     }
     console.log(`[chain] \u2705 Block data integrity verified: ${hash}`);
     await this.#validateBlockValidators(blockMessage);
-    const transactions = await Promise.all(
-      blockMessage.decoded.transactions.map(async (hash2) => {
-        const data = await peernet.get(hash2, "transaction");
-        return new TransactionMessage(data);
-      })
-    );
-    await Promise.all(transactions.map((transaction) => this.validateTransactionSignature(transaction)));
+    const transactions = await this.#resolveBlockTransactions(blockMessage);
     await Promise.all(
       blockMessage.decoded.transactions.map(async (transactionHash) => {
         if (await transactionPoolStore.has(transactionHash)) await transactionPoolStore.delete(transactionHash);
@@ -3348,7 +3393,7 @@ class Chain extends VersionControl {
       fees: BigInt(0),
       timestamp,
       previousHash: "",
-      reward: BigInt(150),
+      reward: BLOCK_REWARD,
       index: 0,
       producer: "",
       producerProof: "",