implement basic bitmap for validator overlap (#46)

* implement basic bitmap for validator overlap

* fmt

* cut cycle count by ~20%

* fmt

* remove redundant code

* maybe this is a better name

Author: austinabell

contracts/artifacts/Blobstream0.json

@@ -40,6 +40,14 @@ contract Blobstream0 is IDAOracle, Ownable2Step {
     /// NOTE: Matches existing Blobstream contract, for ease of integration.
     event HeadUpdate(uint64 blockNumber, bytes32 headerHash);
 
+    /// @notice Validator bitmap of the intersection of validators that signed off on both the
+    /// trusted block and the new header. This event is emitted to allow for slashing equivocations.
+    /// NOTE: This event matches existing Blobstream contracts, for ease of integration.
+    /// @param trustedBlock The trusted block of the block range.
+    /// @param targetBlock The target block of the block range.
+    /// @param validatorBitmap The validator bitmap for the block range.
+    event ValidatorBitmapEquivocation(uint64 trustedBlock, uint64 targetBlock, uint256 validatorBitmap);
+
     /// @notice Target height for next batch was below the current height.
     error InvalidTargetHeight();
 
@@ -113,6 +121,7 @@ contract Blobstream0 is IDAOracle, Ownable2Step {
         verifier.verify(_seal, imageId, sha256(_commitBytes));
 
         emit DataCommitmentStored(proofNonce, latestHeight, commit.newHeight, commit.merkleRoot);
+        emit ValidatorBitmapEquivocation(latestHeight, commit.newHeight, commit.validatorBitmap);
 
         // Update latest block in state
         latestHeight = commit.newHeight;

contracts/src/Blobstream0.sol

@@ -20,5 +20,5 @@ pragma solidity ^0.8.20;
 
 library ImageID {
     bytes32 public constant LIGHT_CLIENT_GUEST_ID =
-        bytes32(0xce4bdb306e686a0d2a412c0ddb392d1dd3b07842a28c828519dc44052daf5319);
+        bytes32(0x7c4d4662f341e9147ab7b60c4dedce832d331f65df62ee43b09abdff5d8283e3);
 }

contracts/src/ImageID.sol

@@ -24,4 +24,5 @@ struct RangeCommitment {
     uint64 newHeight;
     bytes32 newHeaderHash;
     bytes32 merkleRoot;
+    uint256 validatorBitmap;
 }

contracts/src/RangeCommitment.sol

@@ -14,7 +14,7 @@
 
 use alloy_sol_types::SolValue;
 use blobstream0_primitives::proto::{TrustedLightBlock, UntrustedLightBlock};
-use blobstream0_primitives::RangeCommitment;
+use blobstream0_primitives::{generate_bitmap, RangeCommitment};
 use blobstream0_primitives::{build_merkle_root, expect_block_hash, light_client_verify};
 use risc0_zkvm::guest::env;
 use tendermint_light_client_verifier::{types::Header, Verdict};
@@ -47,6 +47,10 @@ fn main() {
     // Assert all bytes have been read, as a sanity check.
     assert!(cursor.is_empty());
 
+
+    // Generate validator bitmap of intersection of trusted and untrusted block signatures.
+    let validator_bitmap = generate_bitmap(&trusted_block, &untrusted_block);
+
     // Build merkle root, while also verifying hash links between all blocks.
     let merkle_root = build_merkle_root(&trusted_block, &interval_headers, &untrusted_block);
 
@@ -64,6 +68,7 @@ fn main() {
         newHeight: untrusted_block.signed_header.header.height.value(),
         newHeaderHash: expect_block_hash(untrusted_block.signed_header.header()).into(),
         merkleRoot: merkle_root.into(),
+        validatorBitmap: validator_bitmap.into(),
     };
     env::commit_slice(commit.abi_encode().as_slice());
 }

light-client-guest/guest/src/main.rs

@@ -17,8 +17,11 @@ use alloy_primitives::U256;
 use alloy_sol_types::SolValue;
 use proto::{TrustedLightBlock, UntrustedLightBlock};
 use sha2::Sha256;
+use std::collections::BTreeSet;
 use std::iter;
 use std::time::Duration;
+use tendermint::account::Id;
+use tendermint::block::signed_header::SignedHeader;
 use tendermint::merkle::simple_hash_from_byte_vectors;
 use tendermint::Hash;
 use tendermint_light_client_verifier::types::{Header, TrustThreshold};
@@ -142,6 +145,41 @@ pub fn light_client_verify(
     )
 }
 
+fn commitment_signature_addresses(signed_header: &SignedHeader) -> BTreeSet<Id> {
+    signed_header
+        .commit
+        .signatures
+        .iter()
+        .filter_map(|sig| sig.is_commit().then(|| sig.validator_address().unwrap()))
+        .collect()
+}
+
+/// Generates a bitmap of the validators that have signed both headers. The ordering is based on the
+/// trusted block's validator set ordering.
+pub fn generate_bitmap(
+    trusted_block: &TrustedLightBlock,
+    untrusted_block: &UntrustedLightBlock,
+) -> U256 {
+    // Create sets of validator addresses that have signed each block
+    let trusted_validators = commitment_signature_addresses(&trusted_block.signed_header);
+    let untrusted_validators = commitment_signature_addresses(&untrusted_block.signed_header);
+
+    // Construct the validator bitmap.
+    trusted_block
+        .next_validators
+        .validators()
+        .iter()
+        .enumerate()
+        .fold(U256::ZERO, |mut bitmap, (i, validator)| {
+            if trusted_validators.contains(&validator.address)
+                && untrusted_validators.contains(&validator.address)
+            {
+                bitmap.set_bit(i, true);
+            }
+            bitmap
+        })
+}
+
 /// Convenience function to pull the block hash data, assuming a Sha256 hash.
 pub fn expect_block_hash(block: &Header) -> [u8; 32] {
     let Hash::Sha256(hash) = block.hash() else {