Merge pull request #47 from opentensor/Release/1.0.0

Release/1.0.0

Author: thewhaleking

CHANGELOG.MD

@@ -1,5 +1,17 @@
 # Changelog
 
+## v1.0.0 /2025-08-07
+
+## What's Changed
+* fix annotation by @basfroman in https://github.com/opentensor/bittensor-drand/pull/32
+* Add `arm` wheels by @basfroman in https://github.com/opentensor/bittensor-drand/pull/34
+* CR Improvements by @JohnReedV in https://github.com/opentensor/bittensor-drand/pull/45
+* Add hotkey to `WeightsTlockPayload` by @JohnReedV in https://github.com/opentensor/bittensor-drand/pull/44
+* Update FFI calculations by @JohnReedV in https://github.com/opentensor/bittensor-drand/pull/43
+
+
+**Full Changelog**: https://github.com/opentensor/bittensor-drand/compare/v0.5.0...v1.0.0
+
 ## v0.5.1 /2025-06-11
 
 ## What's Changed

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bittensor-drand"
-version = "0.5.0"
+version = "1.0.0"
 edition = "2021"
 
 [lib]

Cargo.toml

@@ -17,7 +17,8 @@ def get_encrypted_commit(
     current_block: int,
     netuid: int,
     subnet_reveal_period_epochs: int,
-    block_time: Union[int, float] = 12,
+    block_time: Union[int, float],
+    hotkey: bytes,
 ) -> tuple[bytes, int]:
     """Returns encrypted commit and target round for `commit_crv3_weights` extrinsic.
 
@@ -30,6 +31,7 @@ def get_encrypted_commit(
         netuid: The network unique identifier (NetUID) for the subnet.
         subnet_reveal_period_epochs: Number of epochs after which the reveal will be performed. Corresponds to the hyperparameter `commit_reveal_weights_interval` of the subnet. In epochs.
         block_time: Amount of time in seconds for one block. Defaults to 12 seconds.
+        hotkey: The hotkey of a neuron-committer is represented as public_key bytes (wallet.hotkey.public_key).
 
     Returns:
         commit (bytes): Raw bytes of the encrypted and compressed uids & weights values for setting weights.
@@ -47,6 +49,7 @@ def get_encrypted_commit(
         netuid,
         subnet_reveal_period_epochs,
         block_time,
+        hotkey,
     )
 
 

bittensor_drand/__init__.py

@@ -1,6 +1,6 @@
 [project]
 name = "bittensor-drand"
-version = "0.5.1"
+version = "1.0.0"
 description = ""
 readme = "README.md"
 license = {file = "LICENSE"}

pyproject.toml

@@ -1,7 +1,7 @@
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use codec::{Decode, Encode};
 
-use rand_core::OsRng;
+use rand_core::{OsRng, RngCore};
 use serde::Deserialize;
 use sha2::Digest;
 use std::os::raw::c_char;
@@ -14,7 +14,6 @@ use tle::{
 };
 use w3f_bls::EngineBLS;
 
-pub const SUBTENSOR_PULSE_DELAY: u64 = 24; //Drand rounds amount
 const PUBLIC_KEY: &str = "83cf0f2896adee7eb8b5f01fcad3912212c437e0073e911fb90022d3e760183c8c4b450b6a0a6c3ac6a5776a2d1064510d1fec758c921cc22b0e17e63aaf4bcb5ed66304de9cf809bd274ca73bab4af5a6e9c76a4bc09e76eae8991ef5ece45a";
 pub const GENESIS_TIME: u64 = 1692803367;
 pub const DRAND_PERIOD: u64 = 3;
@@ -34,6 +33,7 @@ const ENDPOINTS: [&str; 5] = [
 
 #[derive(Encode, Decode, Debug, PartialEq)]
 pub struct WeightsTlockPayload {
+    pub hotkey: Vec<u8>,
     pub uids: Vec<u16>,
     pub values: Vec<u16>,
     pub version_key: u64,
@@ -94,7 +94,8 @@ pub fn encrypt_and_compress(
     let identity = Identity::new(b"", vec![message]);
 
     // Encrypt payload
-    let esk = [2; 32];
+    let mut esk = [0u8; 32];
+    OsRng.fill_bytes(&mut esk);
     let ct = tle::<TinyBLS381, AESGCMStreamCipherProvider, OsRng>(
         pub_key,
         esk,
@@ -178,6 +179,7 @@ pub fn decrypt_and_decompress(
 /// * `netuid` - A u16 representing the network's unique identifier.
 /// * `subnet_reveal_period_epochs` - A u64 indicating the number of epochs before reveal.
 /// * `block_time` - Duration of each block in seconds as u64.
+/// * `hotkey` - The hotkey of the committing validator
 ///
 /// # Returns
 ///
@@ -194,49 +196,66 @@ pub fn generate_commit(
     netuid: u16,
     subnet_reveal_period_epochs: u64,
     block_time: f64,
+    hotkey: Vec<u8>,
 ) -> Result<(Vec<u8>, u64), (std::io::Error, String)> {
-    // Steps comes from here https://github.com/opentensor/subtensor/pull/982/files#diff-7261bf1c7f19fc66a74c1c644ec2b4b277a341609710132fb9cd5f622350a6f5R120-R131
-
-    // Instantiate payload
-    let payload = WeightsTlockPayload {
-        uids,
-        values,
-        version_key,
-    };
-    let serialized_payload = payload.encode();
-
-    let now = SystemTime::now()
+    //----------------------------------------------------------------------
+    // 1 ▸ derive the first block of the reveal epoch
+    //----------------------------------------------------------------------
+    let tempo_plus_one = tempo.saturating_add(1);
+    let netuid_plus_one = netuid as u64 + 1;
+
+    // epoch index of `current_block`
+    let current_epoch = (current_block + netuid_plus_one) / tempo_plus_one;
+
+    // epoch index in which the commit must be revealed
+    let reveal_epoch = current_epoch + subnet_reveal_period_epochs;
+
+    // very first block *inside* the reveal epoch
+    let first_reveal_blk = reveal_epoch
+        .saturating_mul(tempo_plus_one)
+        .saturating_sub(netuid_plus_one);
+
+    //----------------------------------------------------------------------
+    // 2 ▸ decide in which *block* we want the pulse to be emitted
+    //     – we aim for first_reveal_blk + 3
+    //----------------------------------------------------------------------
+    pub const SECURITY_BLOCK_OFFSET: u64 = 3;
+    let target_ingest_blk = first_reveal_blk.saturating_add(SECURITY_BLOCK_OFFSET);
+    let blocks_until_ingest = target_ingest_blk.saturating_sub(current_block);
+    let secs_until_ingest = blocks_until_ingest as f64 * block_time;
+
+    //----------------------------------------------------------------------
+    // 3 ▸ convert the desired timestamp into a DRAND round
+    //----------------------------------------------------------------------
+    let now_secs = SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .unwrap()
         .as_secs_f64();
 
-    let tempo_plus_one = tempo + 1;
-    let netuid_plus_one = (netuid as u64) + 1;
-    let block_with_offset = current_block + netuid_plus_one;
-    let current_epoch = block_with_offset / tempo_plus_one;
-
-    let mut reveal_epoch = current_epoch + subnet_reveal_period_epochs;
-    let mut reveal_block_number = reveal_epoch * tempo_plus_one - netuid_plus_one;
-    let mut blocks_until_reveal = reveal_block_number - current_block;
-    let mut time_until_reveal = (blocks_until_reveal as f64) * block_time;
-
-    //
-    while time_until_reveal < (SUBTENSOR_PULSE_DELAY * DRAND_PERIOD) as f64 {
-        reveal_epoch += 1;
-        reveal_block_number = reveal_epoch * tempo_plus_one - netuid_plus_one;
-        blocks_until_reveal = reveal_block_number - current_block;
-        time_until_reveal = (blocks_until_reveal as f64) * block_time;
+    let target_secs = now_secs + secs_until_ingest;
+
+    // Round ***down*** so we never request a not‑yet‑ingested pulse.
+    let mut reveal_round =
+        ((target_secs - GENESIS_TIME as f64) / DRAND_PERIOD as f64).floor() as u64;
+
+    if reveal_round < 1 {
+        reveal_round = 1;
     }
 
-    let reveal_time = now + time_until_reveal;
-    let reveal_round = ((reveal_time - GENESIS_TIME as f64) / DRAND_PERIOD as f64).ceil() as u64
-        - SUBTENSOR_PULSE_DELAY;
+    //----------------------------------------------------------------------
+    // 5 ▸ build & encrypt payload
+    //----------------------------------------------------------------------
+    let payload = WeightsTlockPayload {
+        hotkey,
+        uids,
+        values,
+        version_key,
+    };
 
-    let ct_bytes = encrypt_and_compress(&serialized_payload, reveal_round)?;
+    let ct_bytes = encrypt_and_compress(&payload.encode(), reveal_round)?;
 
     Ok((ct_bytes, reveal_round))
 }
-
 /// Encrypts a string-based commitment using Drand timelock encryption for a future reveal round.
 ///
 /// This function encodes the input `data` and calculates the corresponding Drand round number
@@ -470,6 +489,7 @@ mod tests {
         let current_block = 1000;
         let netuid = 1;
         let reveal_epochs = 3;
+        let hotkey = vec![1, 2, 3];
 
         let (encrypted, reveal_round) = generate_commit(
             uids.clone(),
@@ -480,6 +500,7 @@ mod tests {
             netuid,
             reveal_epochs,
             12.0,
+            hotkey.clone(),
         )
         .expect("Commit generation failed");
 
@@ -499,6 +520,7 @@ mod tests {
             assert_eq!(payload.uids, uids);
             assert_eq!(payload.values, values);
             assert_eq!(payload.version_key, version_key);
+            assert_eq!(payload.hotkey, hotkey)
         }
     }
 }

src/drand.rs

@@ -375,6 +375,8 @@ pub extern "C" fn cr_encrypt_commitment(
 /// * `netuid` - Network UID
 /// * `subnet_reveal_epochs` - Number of epochs to wait before revealing
 /// * `block_time` - Duration of a single block in seconds
+/// * `hotkey_ptr` - Pointer to a byte array representing the hotkey (Vec<u8>)
+/// * `hotkey_len` - Length of the hotkey byte array
 /// * `round_out` - Output parameter that will be set to the reveal round number
 /// * `err_out` - Output parameter that will be set to an error message on failure
 ///
@@ -401,13 +403,18 @@ pub extern "C" fn cr_generate_commit(
     netuid: u16,
     subnet_reveal_epochs: u64,
     block_time: f64,
+    hotkey_ptr: *const u8,
+    hotkey_len: usize,
     round_out: *mut u64,
     err_out: *mut *mut c_char,
 ) -> CRByteBuffer {
     unsafe { *err_out = ptr::null_mut() }
 
-    if (uids_ptr.is_null() && uids_len > 0) || (vals_ptr.is_null() && vals_len > 0) {
-        unsafe { *err_out = err_to_cstring("uids/values ptr is null") };
+    if (uids_ptr.is_null() && uids_len > 0)
+        || (vals_ptr.is_null() && vals_len > 0)
+        || (hotkey_ptr.is_null() && hotkey_len > 0)
+    {
+        unsafe { *err_out = err_to_cstring("uids/values/hotkey ptr is null") };
         return CRByteBuffer {
             ptr: ptr::null_mut(),
             len: 0,
@@ -426,6 +433,7 @@ pub extern "C" fn cr_generate_commit(
 
     let uids = unsafe { std::slice::from_raw_parts(uids_ptr, uids_len) }.to_vec();
     let values = unsafe { std::slice::from_raw_parts(vals_ptr, vals_len) }.to_vec();
+    let hotkey = unsafe { std::slice::from_raw_parts(hotkey_ptr, hotkey_len) }.to_vec();
 
     match drand::generate_commit(
         uids,
@@ -436,6 +444,7 @@ pub extern "C" fn cr_generate_commit(
         netuid,
         subnet_reveal_epochs,
         block_time,
+        hotkey,
     ) {
         Ok((ct, rr)) => {
             unsafe { *round_out = rr }
@@ -785,6 +794,7 @@ mod tests {
     fn test_generate_commit_success() {
         let uids: [u16; 3] = [1, 2, 3];
         let vals: [u16; 3] = [10, 20, 30];
+        let hotkey: [u8; 3] = [11, 22, 33];
 
         let mut round: u64 = 0;
         let mut err_ptr: *mut c_char = ptr::null_mut();
@@ -801,6 +811,8 @@ mod tests {
                 1,      // netuid
                 2,      // subnet_reveal_epochs
                 12.0,   // block_time
+                hotkey.as_ptr(),
+                hotkey.len(),
                 &mut round,
                 &mut err_ptr,
             )
@@ -819,6 +831,7 @@ mod tests {
     #[test]
     fn test_generate_commit_null_uids() {
         let vals: [u16; 2] = [1, 2];
+        let hotkey: [u8; 3] = [11, 22, 33];
         let mut round: u64 = 0;
         let mut err_ptr: *mut c_char = ptr::null_mut();
 
@@ -834,6 +847,8 @@ mod tests {
                 0,
                 0,
                 12.0,
+                hotkey.as_ptr(),
+                hotkey.len(),
                 &mut round,
                 &mut err_ptr,
             )
@@ -851,6 +866,7 @@ mod tests {
     fn test_generate_commit_mismatched_lengths() {
         let uids: [u16; 2] = [1, 2];
         let vals: [u16; 3] = [10, 20, 30];
+        let hotkey: [u8; 3] = [11, 22, 33];
         let mut round: u64 = 0;
         let mut err_ptr: *mut c_char = ptr::null_mut();
 
@@ -866,6 +882,8 @@ mod tests {
                 0,
                 0,
                 12.0,
+                hotkey.as_ptr(),
+                hotkey.len(),
                 &mut round,
                 &mut err_ptr,
             )

src/ffi.rs

@@ -27,7 +27,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 ///         - the encrypted commitment (as bytes)
 ///         - the reveal round number (int) when it can be decrypted.
 #[pyfunction]
-#[pyo3(signature = (uids, weights, version_key, tempo, current_block, netuid, subnet_reveal_period_epochs, block_time=12.0))]
+#[pyo3(signature = (uids, weights, version_key, tempo, current_block, netuid, subnet_reveal_period_epochs, block_time, hotkey))]
 fn get_encrypted_commit(
     py: Python,
     uids: Vec<u16>,
@@ -38,6 +38,7 @@ fn get_encrypted_commit(
     netuid: u16,
     subnet_reveal_period_epochs: u64,
     block_time: f64,
+    hotkey: Vec<u8>,
 ) -> PyResult<(Py<PyBytes>, u64)> {
     // create runtime to make async call
     let result = drand::generate_commit(
@@ -49,6 +50,7 @@ fn get_encrypted_commit(
         netuid,
         subnet_reveal_period_epochs,
         block_time,
+        hotkey,
     );
     // matching the result
     match result {