feat: sparse pub rand generation (#110)

## Description

<!-- Brief description of changes -->

## Checklist

- [x] I have updated the
[docs/SPEC.md](https://github.com/babylonlabs-io/rollup-bsn-contracts/blob/main/docs/SPEC.md)
file if this change affects the specification
- [x] I have updated the schema by running `cargo gen-schema`

---------

Co-authored-by: Runchao Han <[email protected]>

Author: gusin13

CHANGELOG.md

@@ -39,10 +39,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 ### State and API breaking
 
-* [#82](https://github.com/babylonlabs-io/rollup-bsn-contracts/pull/108) core: 
-  add allow-list to instantiate arg
+* [#110](https://github.com/babylonlabs-io/rollup-bsn-contracts/pull/110) feat: sparse pub rand generation
 * [#97](https://github.com/babylonlabs-io/rollup-bsn-contracts/pull/97) feat:
-  versioning of FP allowlist
+* [#82](https://github.com/babylonlabs-io/rollup-bsn-contracts/pull/108) core: add allow-list to instantiate arg
 * [#100](https://github.com/babylonlabs-io/rollup-bsn-contracts/pull/100) chore:
   add query to fetch highest voted height
 

contracts/finality/schema/finality.json

@@ -837,6 +837,7 @@
           "required": [
             "babylon_epoch",
             "commitment",
+            "interval",
             "num_pub_rand",
             "start_height"
           ],
@@ -856,6 +857,12 @@
                 "minimum": 0.0
               }
             },
+            "interval": {
+              "description": "The interval of the commitment between each two consecutive pub rand values The pub rand values will be in height `start_height`, `start_height + interval`, `start_height + 2 * interval`, ...",
+              "type": "integer",
+              "format": "uint64",
+              "minimum": 0.0
+            },
             "num_pub_rand": {
               "description": "The amount of committed public randomness",
               "type": "integer",
@@ -901,6 +908,7 @@
           "required": [
             "babylon_epoch",
             "commitment",
+            "interval",
             "num_pub_rand",
             "start_height"
           ],
@@ -920,6 +928,12 @@
                 "minimum": 0.0
               }
             },
+            "interval": {
+              "description": "The interval of the commitment between each two consecutive pub rand values The pub rand values will be in height `start_height`, `start_height + interval`, `start_height + 2 * interval`, ...",
+              "type": "integer",
+              "format": "uint64",
+              "minimum": 0.0
+            },
             "num_pub_rand": {
               "description": "The amount of committed public randomness",
               "type": "integer",
@@ -951,6 +965,7 @@
           "required": [
             "babylon_epoch",
             "commitment",
+            "interval",
             "num_pub_rand",
             "start_height"
           ],
@@ -970,6 +985,12 @@
                 "minimum": 0.0
               }
             },
+            "interval": {
+              "description": "The interval of the commitment between each two consecutive pub rand values The pub rand values will be in height `start_height`, `start_height + interval`, `start_height + 2 * interval`, ...",
+              "type": "integer",
+              "format": "uint64",
+              "minimum": 0.0
+            },
             "num_pub_rand": {
               "description": "The amount of committed public randomness",
               "type": "integer",
@@ -1005,6 +1026,7 @@
           "required": [
             "babylon_epoch",
             "commitment",
+            "interval",
             "num_pub_rand",
             "start_height"
           ],
@@ -1024,6 +1046,12 @@
                 "minimum": 0.0
               }
             },
+            "interval": {
+              "description": "The interval of the commitment between each two consecutive pub rand values The pub rand values will be in height `start_height`, `start_height + interval`, `start_height + 2 * interval`, ...",
+              "type": "integer",
+              "format": "uint64",
+              "minimum": 0.0
+            },
             "num_pub_rand": {
               "description": "The amount of committed public randomness",
               "type": "integer",

contracts/finality/schema/raw/response_to_first_pub_rand_commit.json

@@ -16,6 +16,7 @@
       "required": [
         "babylon_epoch",
         "commitment",
+        "interval",
         "num_pub_rand",
         "start_height"
       ],
@@ -35,6 +36,12 @@
             "minimum": 0.0
           }
         },
+        "interval": {
+          "description": "The interval of the commitment between each two consecutive pub rand values The pub rand values will be in height `start_height`, `start_height + interval`, `start_height + 2 * interval`, ...",
+          "type": "integer",
+          "format": "uint64",
+          "minimum": 0.0
+        },
         "num_pub_rand": {
           "description": "The amount of committed public randomness",
           "type": "integer",

contracts/finality/schema/raw/response_to_last_pub_rand_commit.json

@@ -16,6 +16,7 @@
       "required": [
         "babylon_epoch",
         "commitment",
+        "interval",
         "num_pub_rand",
         "start_height"
       ],
@@ -35,6 +36,12 @@
             "minimum": 0.0
           }
         },
+        "interval": {
+          "description": "The interval of the commitment between each two consecutive pub rand values The pub rand values will be in height `start_height`, `start_height + interval`, `start_height + 2 * interval`, ...",
+          "type": "integer",
+          "format": "uint64",
+          "minimum": 0.0
+        },
         "num_pub_rand": {
           "description": "The amount of committed public randomness",
           "type": "integer",

contracts/finality/schema/raw/response_to_list_pub_rand_commit.json

@@ -12,6 +12,7 @@
       "required": [
         "babylon_epoch",
         "commitment",
+        "interval",
         "num_pub_rand",
         "start_height"
       ],
@@ -31,6 +32,12 @@
             "minimum": 0.0
           }
         },
+        "interval": {
+          "description": "The interval of the commitment between each two consecutive pub rand values The pub rand values will be in height `start_height`, `start_height + interval`, `start_height + 2 * interval`, ...",
+          "type": "integer",
+          "format": "uint64",
+          "minimum": 0.0
+        },
         "num_pub_rand": {
           "description": "The amount of committed public randomness",
           "type": "integer",

contracts/finality/schema/raw/response_to_pub_rand_commit_for_height.json

@@ -16,6 +16,7 @@
       "required": [
         "babylon_epoch",
         "commitment",
+        "interval",
         "num_pub_rand",
         "start_height"
       ],
@@ -35,6 +36,12 @@
             "minimum": 0.0
           }
         },
+        "interval": {
+          "description": "The interval of the commitment between each two consecutive pub rand values The pub rand values will be in height `start_height`, `start_height + interval`, `start_height + 2 * interval`, ...",
+          "type": "integer",
+          "format": "uint64",
+          "minimum": 0.0
+        },
         "num_pub_rand": {
           "description": "The amount of committed public randomness",
           "type": "integer",

contracts/finality/src/error.rs

@@ -91,8 +91,8 @@ pub enum ContractError {
     DuplicatedFinalitySig(String, u64),
     #[error("Too few public randomness values: given {given}, required minimum {required}")]
     TooFewPubRand { given: u64, required: u64 },
-    #[error("Block height overflow: start height {start_height} is equal or higher than (start height + num pub rand) {end_height}")]
-    OverflowInBlockHeight { start_height: u64, end_height: u64 },
+    #[error("Block height overflow detected for start height {start_height}")]
+    OverflowInBlockHeight { start_height: u64 },
     #[error("Invalid commitment length: expected {expected} bytes, got {actual}")]
     InvalidCommitmentLength { expected: usize, actual: usize },
     #[error("Invalid signature length: expected {expected} bytes, got {actual}")]

contracts/finality/src/exec/finality.rs

@@ -137,7 +137,10 @@ fn verify_finality_signature(
     signing_context: &str,
     signature: &[u8],
 ) -> Result<(), ContractError> {
-    let proof_height = pr_commit.start_height + proof.index;
+    // For sparse generation: proof_height = start_height + index * interval
+    // For consecutive generation (interval=1): proof_height = start_height + index * 1 = start_height + index
+    let proof_height = pr_commit.start_height + proof.index * pr_commit.interval;
+
     if block_height != proof_height {
         return Err(ContractError::InvalidFinalitySigHeight(
             proof_height,
@@ -289,6 +292,7 @@ pub(crate) mod tests {
         let pr_commit = PubRandCommit {
             start_height: pr_commit.start_height,
             num_pub_rand: pr_commit.num_pub_rand,
+            interval: 1, // TODO: test with interval > 1
             babylon_epoch: current_epoch,
             commitment: pr_commit.commitment,
         };
@@ -298,9 +302,31 @@ pub(crate) mod tests {
         // This needs mock data from babylon_test_utils
         // https://github.com/babylonlabs-io/rollup-bsn-contracts/issues/66
         let context = "";
+        // For test, we need to create a mock storage with proper config
+        let mut deps = mock_deps_babylon();
+
+        // Set up a default config for testing (interval = 1 for consecutive generation)
+        let config = crate::state::config::Config {
+            bsn_id: "test-bsn".to_string(),
+            min_pub_rand: 1,
+            rate_limiting: crate::state::config::RateLimitingConfig {
+                max_msgs_per_interval: 100,
+                block_interval: 10,
+            },
+            bsn_activation_height: 0,
+            // Consecutive generation for this test
+            // TODO: test with interval > 1
+            finality_signature_interval: 1,
+        };
+        crate::state::config::set_config(deps.as_mut().storage, &config).unwrap();
+
+        // Calculate block height using the same logic as verify_finality_signature
+        let block_height = pr_commit.start_height
+            + proof.index.unsigned_abs() * config.finality_signature_interval;
+
         let res = verify_finality_signature(
             &hex::decode(&pk_hex).unwrap(),
-            pr_commit.start_height + proof.index.unsigned_abs(),
+            block_height,
             &pub_rand_value,
             // we need to add a typecast below because the provided proof is of type
             // tendermint_proto::crypto::Proof, whereas the fn expects babylon_merkle::proof

contracts/finality/src/exec/public_randomness.rs

@@ -3,7 +3,7 @@ use crate::error::ContractError;
 use crate::msg::BabylonMsg;
 use crate::state::allowlist::ensure_fp_in_allowlist;
 use crate::state::config::get_config;
-use crate::state::public_randomness::{insert_pub_rand_commit, PubRandCommit};
+use crate::state::public_randomness::{compute_end_height, insert_pub_rand_commit, PubRandCommit};
 use crate::state::rate_limiting::check_rate_limit_and_accumulate;
 use crate::utils::{get_fp_rand_commit_context_v0, query_finality_provider};
 use babylon_bindings::BabylonQuery;
@@ -44,7 +44,13 @@ pub fn handle_public_randomness_commit(
     let config = get_config(deps.storage)?;
 
     // Validate the commitment parameters
-    validate_pub_rand_commit(start_height, num_pub_rand, commitment, config.min_pub_rand)?;
+    validate_pub_rand_commit(
+        start_height,
+        num_pub_rand,
+        commitment,
+        config.min_pub_rand,
+        config.finality_signature_interval,
+    )?;
 
     let fp_btc_pk = hex::decode(fp_btc_pk_hex)?;
 
@@ -79,6 +85,7 @@ pub fn handle_public_randomness_commit(
         PubRandCommit {
             start_height,
             num_pub_rand,
+            interval: config.finality_signature_interval,
             babylon_epoch: current_epoch,
             commitment: commitment.to_vec(),
         },
@@ -97,6 +104,7 @@ pub fn validate_pub_rand_commit(
     num_pub_rand: u64,
     commitment: &[u8],
     min_pub_rand: u64,
+    finality_signature_interval: u64,
 ) -> Result<(), ContractError> {
     // Check if commitment is exactly 32 bytes
     if commitment.len() != COMMITMENT_LENGTH_BYTES {
@@ -106,15 +114,9 @@ pub fn validate_pub_rand_commit(
         });
     }
 
-    // Check for overflow when doing (StartHeight + NumPubRand)
+    // Check for overflow when computing the end height
     // To avoid public randomness reset
-    let end_height = start_height.saturating_add(num_pub_rand);
-    if start_height >= end_height {
-        return Err(ContractError::OverflowInBlockHeight {
-            start_height,
-            end_height,
-        });
-    }
+    compute_end_height(start_height, num_pub_rand, finality_signature_interval)?;
 
     // Validate minimum public randomness requirement
     if num_pub_rand < min_pub_rand {
@@ -412,8 +414,8 @@ pub(crate) mod tests {
     fn test_overflow_protection_fails() {
         let mut deps = mock_deps_babylon();
 
-        // Configure the contract with random min_pub_rand
-        let instantiate_msg = new_init_msg(get_random_u64());
+        // Configure the contract with small min_pub_rand to avoid TooFewPubRand error
+        let instantiate_msg = new_init_msg(1);
 
         let info = message_info(&deps.api.addr_make(CREATOR), &[]);
         instantiate(deps.as_mut(), mock_env(), info, instantiate_msg).unwrap();
@@ -428,17 +430,16 @@ pub(crate) mod tests {
             deps.as_mut(),
             &mock_env(),
             &get_random_fp_pk_hex(),
-            u64::MAX, // This will cause overflow when added to num_pub_rand
-            1,
+            u64::MAX - 10, // This will cause overflow when we add (num_pub_rand-1)*interval
+            100,           // Large enough to pass min_pub_rand but cause overflow
             &get_random_block_hash(),
             &random_signature,
         );
 
         assert_eq!(
             result.unwrap_err(),
             ContractError::OverflowInBlockHeight {
-                start_height: u64::MAX,
-                end_height: u64::MAX // saturating_add results in MAX
+                start_height: u64::MAX - 10
             }
         );
     }