fix: sync prev committee during sequencerconfig derivation

Author: alxiong

justfile

@@ -199,42 +199,40 @@ test-dyn-comm: build_release_until build-test-utils
     --spawn "1:anvil --port 8545" \
     --run   "2:sleep 2" \
     --run   "3:scripts/deploy-test-contract" \
-    --spawn "4:target/release/yapper --keyset-file test-configs/c0/committee.toml" \
-    --spawn "5:target/release/run-committee --configs test-configs/c0/ --committee 0 --timeboost target/release/timeboost --until 1000" \
-    --run   "6:target/release/mkconfig -n 3 \
+    --spawn "4:target/release/run-committee --configs test-configs/c0/ --committee 0" \
+    --run   "5:target/release/mkconfig -n 3 \
                  --public-addr 127.0.0.1:9000 \
                  --internal-addr 127.0.0.1:9003 \
                  --http-api 127.0.0.1:9004 \
                  --chain-namespace 10101 \
                  --parent-rpc-url http://127.0.0.1:8545 \
                  --parent-ws-url ws://127.0.0.1:8545 \
                  --parent-chain-id 31337 \
-                 --parent-ibox-contract "0xa0f3a1a4e2b2bcb7b48c8527c28098f207572ec1" \
-                 --key-manager-contract "0x2bbf15bc655c4cc157b769cfcb1ea9924b9e1a35" \
+                 --parent-ibox-contract 0xa0f3a1a4e2b2bcb7b48c8527c28098f207572ec1 \
+                 --key-manager-contract 0x2bbf15bc655c4cc157b769cfcb1ea9924b9e1a35 \
                  --timestamp `just now-plus-20s` \
                  --stamp-dir /tmp \
                  --output test-configs/c1" \
-    --run   "7:target/release/register \
+    --run   "6:target/release/register \
                  -u http://localhost:8545 \
                  -k 0x2bbf15bc655c4cc157b769cfcb1ea9924b9e1a35 \
                  -c test-configs/c1/committee.toml" \
-    --run   "8:sleep 8" \
-    --run   "9:target/release/register \
+    --run   "7:sleep 8" \
+    --run   "8:target/release/register \
                  -u http://localhost:8545 \
                  -k 0x2bbf15bc655c4cc157b769cfcb1ea9924b9e1a35 \
                  -c test-configs/c0/committee.toml \
                  -a threshold-enc-key" \
-    --spawn "10:target/release/yapper \
+    --spawn "9:target/release/yapper \
                   --keyset-file test-configs/c1/committee.toml \
                   --parent-url http://localhost:8545 \
                   --key-manager-contract 0x2bbf15bc655c4cc157b769cfcb1ea9924b9e1a35" \
-    target/release/run-committee -- --configs test-configs/c1/ \
+    target/release/run-committee -- \
+      --configs test-configs/c1/ \
       --committee 1 \
-      --timeboost target/release/timeboost \
       --until 500 \
       --required-decrypt-rounds 3
 
-
 # portable calculation of now() + 20s in "%Y-%m-%dT%H:%M:%SZ" format
 [private]
 now-plus-20s:

timeboost/src/binaries/timeboost.rs

@@ -100,13 +100,13 @@ async fn main() -> Result<()> {
         .iter()
         .map(|peer| {
             let sig_key = multisig::PublicKey::try_from(peer.sigKey.as_ref())
-                .expect("Failed to parse sigKey");
+                .expect("Should parse sigKey bytes");
             let dh_key =
-                x25519::PublicKey::try_from(peer.dhKey.as_ref()).expect("Failed to parse dhKey");
-            let dkg_enc_key = DkgEncKey::from_bytes(peer.dkgKey.as_ref())
-                .expect("Blackbox from_bytes should work");
+                x25519::PublicKey::try_from(peer.dhKey.as_ref()).expect("Should parse dhKey bytes");
+            let dkg_enc_key =
+                DkgEncKey::from_bytes(peer.dkgKey.as_ref()).expect("Should parse dkgKey bytes");
             let sailfish_address = cliquenet::Address::try_from(peer.networkAddress.as_ref())
-                .expect("Failed to parse networkAddress");
+                .expect("Should parse networkAddress string");
             (sig_key, dh_key, dkg_enc_key, sailfish_address)
         })
         .collect::<Vec<_>>();

timeboost/src/conf.rs

@@ -1,9 +1,12 @@
+use alloy::providers::ProviderBuilder;
+use anyhow::Result;
 use bon::Builder;
 use cliquenet::{Address, AddressableCommittee};
-use multisig::{Keypair, x25519};
+use multisig::{Committee, Keypair, x25519};
 use timeboost_builder::{CertifierConfig, SubmitterConfig, robusta};
-use timeboost_config::ChainConfig;
-use timeboost_crypto::prelude::DkgDecKey;
+use timeboost_config::{ChainConfig, DECRYPTER_PORT_OFFSET};
+use timeboost_contract::{CommitteeMemberSol, KeyManager};
+use timeboost_crypto::prelude::{DkgDecKey, DkgEncKey};
 use timeboost_sequencer::SequencerConfig;
 use timeboost_types::{KeyStore, ThresholdKeyCell};
 
@@ -61,8 +64,95 @@ pub struct TimeboostConfig {
 }
 
 impl TimeboostConfig {
-    pub fn sequencer_config(&self) -> SequencerConfig {
-        SequencerConfig::builder()
+    pub async fn sequencer_config(&self) -> Result<SequencerConfig> {
+        let cur_cid: u64 = self.sailfish_committee.committee().id().into();
+
+        let (prev_sailfish, prev_decrypt) = if cur_cid == 0u64 {
+            (None, None)
+        } else {
+            // syncing with contract to get peer info about the previous committee
+            // largely adapted from binaries/timeboost.rs
+            // TODO: (alex) extrapolate the remaining logic into a common helper
+            let prev_cid = cur_cid - 1;
+
+            let provider =
+                ProviderBuilder::new().connect_http(self.chain_config.parent.rpc_url.clone());
+            let contract =
+                KeyManager::new(self.chain_config.parent.key_manager_contract, &provider);
+            let members: Vec<CommitteeMemberSol> =
+                contract.getCommitteeById(prev_cid).call().await?.members;
+
+            tracing::info!(label = %self.sign_keypair.public_key(), committee_id = %prev_cid, "prev committee info synced");
+
+            let peer_hosts_and_keys = members
+                .iter()
+                .map(|peer| {
+                    let sig_key = multisig::PublicKey::try_from(peer.sigKey.as_ref())
+                        .expect("Should parse sigKey bytes");
+                    let dh_key = x25519::PublicKey::try_from(peer.dhKey.as_ref())
+                        .expect("Should parse dhKey bytes");
+                    let dkg_enc_key = DkgEncKey::from_bytes(peer.dkgKey.as_ref())
+                        .expect("Should parse dkgKey bytes");
+                    let sailfish_address =
+                        cliquenet::Address::try_from(peer.networkAddress.as_ref())
+                            .expect("Should parse networkAddress string");
+                    (sig_key, dh_key, dkg_enc_key, sailfish_address)
+                })
+                .collect::<Vec<_>>();
+
+            let mut sailfish_peer_hosts_and_keys = Vec::new();
+            let mut decrypt_peer_hosts_and_keys = Vec::new();
+            let mut dkg_enc_keys = Vec::new();
+
+            for (signing_key, dh_key, dkg_enc_key, sailfish_addr) in
+                peer_hosts_and_keys.iter().cloned()
+            {
+                sailfish_peer_hosts_and_keys.push((signing_key, dh_key, sailfish_addr.clone()));
+                decrypt_peer_hosts_and_keys.push((
+                    signing_key,
+                    dh_key,
+                    sailfish_addr.clone().with_offset(DECRYPTER_PORT_OFFSET),
+                ));
+                dkg_enc_keys.push(dkg_enc_key.clone());
+            }
+
+            let sailfish_committee = {
+                let c = Committee::new(
+                    prev_cid,
+                    sailfish_peer_hosts_and_keys
+                        .iter()
+                        .enumerate()
+                        .map(|(i, (k, ..))| (i as u8, *k)),
+                );
+                AddressableCommittee::new(c, sailfish_peer_hosts_and_keys.iter().cloned())
+            };
+
+            let decrypt_committee = {
+                let c = Committee::new(
+                    prev_cid,
+                    decrypt_peer_hosts_and_keys
+                        .iter()
+                        .enumerate()
+                        .map(|(i, (k, ..))| (i as u8, *k)),
+                );
+                AddressableCommittee::new(c, decrypt_peer_hosts_and_keys.iter().cloned())
+            };
+
+            let key_store = KeyStore::new(
+                sailfish_committee.committee().clone(),
+                dkg_enc_keys
+                    .into_iter()
+                    .enumerate()
+                    .map(|(i, k)| (i as u8, k)),
+            );
+
+            (
+                Some(sailfish_committee),
+                Some((decrypt_committee, key_store)),
+            )
+        };
+
+        Ok(SequencerConfig::builder()
             .sign_keypair(self.sign_keypair.clone())
             .dh_keypair(self.dh_keypair.clone())
             .dkg_key(self.dkg_key.clone())
@@ -71,10 +161,12 @@ impl TimeboostConfig {
             .sailfish_committee(self.sailfish_committee.clone())
             .decrypt_committee((self.decrypt_committee.clone(), self.key_store.clone()))
             .recover(self.recover)
+            .maybe_previous_sailfish_committee(prev_sailfish)
+            .maybe_previous_decrypt_committee(prev_decrypt)
             .leash_len(self.leash_len)
             .threshold_dec_key(self.threshold_dec_key.clone())
             .chain_config(self.chain_config.clone())
-            .build()
+            .build())
     }
 
     pub fn certifier_config(&self) -> CertifierConfig {

timeboost/src/lib.rs

@@ -58,7 +58,7 @@ impl Timeboost {
     pub async fn new(cfg: TimeboostConfig) -> Result<Self> {
         let pro = Arc::new(PrometheusMetrics::default());
         let met = Arc::new(TimeboostMetrics::new(&*pro));
-        let seq = Sequencer::new(cfg.sequencer_config(), &*pro).await?;
+        let seq = Sequencer::new(cfg.sequencer_config().await?, &*pro).await?;
         let blk = Certifier::new(cfg.certifier_config(), &*pro).await?;
         let sub = Submitter::new(cfg.submitter_config(), &*pro);