feat(block): block signatures

src/block.rs

@@ -5,10 +5,12 @@ mod block_test;
 use derive_more::Display;
 use serde::{Deserialize, Serialize};
 
-use crate::core::{ContractAddress, GlobalRoot};
-use crate::hash::StarkHash;
+use crate::core::{ContractAddress, GlobalRoot, SequencerPublicKey};
+use crate::crypto::{verify_message_hash_signature, Signature};
+use crate::hash::{poseidon_hash_array, StarkHash};
 use crate::serde_utils::{BytesAsHex, PrefixedBytesAsHex};
 use crate::transaction::{Transaction, TransactionHash, TransactionOutput};
+use crate::StarknetApiError;
 
 /// A block.
 #[derive(Debug, Default, Clone, Eq, PartialEq, Deserialize, Serialize)]
@@ -135,3 +137,26 @@ impl From<GasPrice> for PrefixedBytesAsHex<16_usize> {
     Debug, Default, Copy, Clone, Eq, PartialEq, Hash, Deserialize, Serialize, PartialOrd, Ord,
 )]
 pub struct BlockTimestamp(pub u64);
+
+/// The signature of a [Block](`crate::block::Block`), signed by the sequencer. The signed message
+/// is defined as poseidon_hash(block_hash, state_diff_commitment).
+#[derive(
+    Debug, Default, Copy, Clone, Eq, PartialEq, Hash, Deserialize, Serialize, PartialOrd, Ord,
+)]
+pub struct BlockSignature(pub Signature);
+
+/// Verifies that the the block header was signed by the expected sequencer.
+pub fn verify_block_signature(
+    sequencer_pub_key: &SequencerPublicKey,
+    signature: &BlockSignature,
+    state_diff_commitment: &GlobalRoot,
+    block_hash: &BlockHash,
+) -> Result<bool, StarknetApiError> {
+    let message_hash = poseidon_hash_array(&[block_hash.0, state_diff_commitment.0]);
+    verify_message_hash_signature(&message_hash.0, &signature.0, &sequencer_pub_key.0).map_err(
+        |err| StarknetApiError::BlockSignatureVerificationFailed {
+            block_hash: *block_hash,
+            error: err,
+        },
+    )
+}

src/block_test.rs

@@ -1,4 +1,9 @@
-use crate::block::BlockNumber;
+use super::verify_block_signature;
+use crate::block::{BlockNumber, BlockSignature};
+use crate::core::{GlobalRoot, SequencerPublicKey};
+use crate::crypto::{Signature, PublicKey};
+use crate::hash::StarkFelt;
+use crate::{stark_felt, BlockHash};
 
 #[test]
 fn test_block_number_iteration() {
@@ -20,3 +25,24 @@ fn test_block_number_iteration() {
 
     assert_eq!(expected, from_iter);
 }
+
+#[test]
+fn block_signature_verification() {
+    let block_hash =
+        BlockHash(stark_felt!("0x7d5db04c5ca2aea828180dc441afb1580e3cee7547a3567ced3aa5bb8b273c0"));
+    let state_commitment = GlobalRoot(stark_felt!(
+        "0x64689c12248e1110af4b3af0e2b43cd51ad13e8855f10e37669e2a4baf919c6"
+    ));
+    let signature = BlockSignature(Signature {
+        r: stark_felt!("0x1b382bbfd693011c9b7692bc932b23ed9c288deb27c8e75772e172abbe5950c"),
+        s: stark_felt!("0xbe4438085057e1a7c704a0da3b30f7b8340fe3d24c86772abfd24aa597e42"),
+    });
+    let sequencer_pub_key = SequencerPublicKey(PublicKey(stark_felt!(
+        "0x48253ff2c3bed7af18bde0b611b083b39445959102d4947c51c4db6aa4f4e58"
+    )));
+
+    assert!(
+        verify_block_signature(&sequencer_pub_key, &signature, &state_commitment, &block_hash)
+            .unwrap()
+    );
+}

src/core.rs

@@ -10,6 +10,7 @@ use primitive_types::H160;
 use serde::{Deserialize, Serialize};
 use starknet_crypto::FieldElement;
 
+use crate::crypto::PublicKey;
 use crate::hash::{pedersen_hash_array, StarkFelt, StarkHash};
 use crate::serde_utils::{BytesAsHex, PrefixedBytesAsHex};
 use crate::transaction::{Calldata, ContractAddressSalt};
@@ -275,3 +276,9 @@ impl From<EthAddress> for PrefixedBytesAsHex<20_usize> {
         BytesAsHex(felt.0.to_fixed_bytes())
     }
 }
+
+/// A public key of a sequencer.
+#[derive(
+    Debug, Copy, Clone, Default, Eq, PartialEq, Hash, Deserialize, Serialize, PartialOrd, Ord,
+)]
+pub struct SequencerPublicKey(pub PublicKey);

src/lib.rs

@@ -15,6 +15,8 @@ pub mod type_utils;
 
 use std::num::ParseIntError;
 
+use block::BlockHash;
+use crypto::CryptoError;
 use serde_utils::InnerDeserializationError;
 
 /// The error type returned by StarknetApi.
@@ -32,4 +34,6 @@ pub enum StarknetApiError {
     /// Missing resource type / duplicated resource type.
     #[error("Missing resource type / duplicated resource type; got {0}.")]
     InvalidResourceMappingInitializer(String),
+    #[error("Failed to verify the signature of block {block_hash}. Error: {error}")]
+    BlockSignatureVerificationFailed { block_hash: BlockHash, error: CryptoError },
 }