absolutebi/serai
1
0
Fork 0
mirror of https://github.com/serai-dex/serai.git synced 2025-12-08 12:19:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add a processor API to the coordinator

Browse Source
This commit is contained in:
Luke Parker
2023-04-17 02:10:33 -04:00
parent 595cd6d404
commit 92a868e574
3 changed files with 139 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
coordinator/src/substrate.rs
View File

@@ -3,7 +3,6 @@ use std::collections::{HashSet, HashMap};
use zeroize::Zeroizing;
use transcript::{Transcript, RecommendedTranscript};
use ciphersuite::{group::GroupEncoding, Ciphersuite, Ristretto};
use frost::{Participant, ThresholdParams};
@@ -20,9 +19,9 @@ use serai_client::{
use tributary::Tributary;
use processor_messages::{SubstrateContext, key_gen::KeyGenId};
use processor_messages::{SubstrateContext, key_gen::KeyGenId, CoordinatorMessage};
use crate::{Db, MainDb, TributaryTransaction, P2p};
use crate::{Db, MainDb, P2p, processor::Processor};
async fn get_coin_key(serai: &Serai, set: ValidatorSet) -> Result<Option<Vec<u8>>, SeraiError> {
Ok(serai.get_keys(set).await?.map(|keys| keys.1.into_inner()))
@@ -46,10 +45,11 @@ async fn in_set(
))
}
async fn handle_new_set<D: Db, P: P2p>(
async fn handle_new_set<D: Db, Pro: Processor, P: P2p>(
db: &mut MainDb<D>,
key: &Zeroizing<<Ristretto as Ciphersuite>::F>,
p2p: &P,
processor: &mut Pro,
serai: &Serai,
block: &Block,
set: ValidatorSet,
@@ -69,21 +69,11 @@ async fn handle_new_set<D: Db, P: P2p>(
validators.insert(participant, amount.0 / set_data.bond.0);
}
// Calculate the genesis for this Tributary
let mut genesis = RecommendedTranscript::new(b"Serai Tributary Genesis");
// This locks it to a specific Serai chain
genesis.append_message(b"serai_block", block.hash());
genesis.append_message(b"session", set.session.0.to_le_bytes());
genesis.append_message(b"network", set.network.0.to_le_bytes());
let genesis = genesis.challenge(b"genesis");
let genesis_ref: &[u8] = genesis.as_ref();
let genesis = genesis_ref[.. 32].try_into().unwrap();
// TODO: Do something with this
let tributary = Tributary::<_, TributaryTransaction, _>::new(
let tributary = Tributary::<_, crate::tributary::Transaction, _>::new(
// TODO2: Use a DB on a dedicated volume
db.0.clone(),
genesis,
crate::tributary::genesis(block.hash(), set),
block.time().expect("Serai block didn't have a timestamp set"),
key.clone(),
validators,
@@ -93,22 +83,27 @@ async fn handle_new_set<D: Db, P: P2p>(
.unwrap();
// Trigger a DKG
// TODO: Send this to processor. Check how it handles it being fired multiple times
// TODO: Check how the processor handles thi being fired multiple times
// We already have a unique event ID based on block, event index (where event index is
// the one generated in this handle_block function)
// We could use that on this end and the processor end?
let msg = processor_messages::key_gen::CoordinatorMessage::GenerateKey {
id: KeyGenId { set, attempt: 0 },
params: ThresholdParams::new(t, n, i).unwrap(),
};
processor
.send(CoordinatorMessage::KeyGen(
processor_messages::key_gen::CoordinatorMessage::GenerateKey {
id: KeyGenId { set, attempt: 0 },
params: ThresholdParams::new(t, n, i).unwrap(),
},
))
.await;
}
Ok(())
}
async fn handle_key_gen<D: Db>(
async fn handle_key_gen<D: Db, Pro: Processor>(
db: &mut MainDb<D>,
key: &Zeroizing<<Ristretto as Ciphersuite>::F>,
processor: &mut Pro,
serai: &Serai,
block: &Block,
set: ValidatorSet,
@@ -119,25 +114,30 @@ async fn handle_key_gen<D: Db>(
.expect("KeyGen occurred for a set which doesn't exist")
.is_some()
{
// TODO: Send this to processor. Check how it handles it being fired multiple times
let msg = processor_messages::key_gen::CoordinatorMessage::ConfirmKeyPair {
context: SubstrateContext {
coin_latest_finalized_block: serai
.get_latest_block_for_network(block.hash(), set.network)
.await?
.unwrap_or(BlockHash([0; 32])), // TODO: Have the processor override this
},
// TODO: Check the DB for which attempt used this key pair
id: KeyGenId { set, attempt: todo!() },
};
// TODO: Check how the processor handles thi being fired multiple times
processor
.send(CoordinatorMessage::KeyGen(
processor_messages::key_gen::CoordinatorMessage::ConfirmKeyPair {
context: SubstrateContext {
coin_latest_finalized_block: serai
.get_latest_block_for_network(block.hash(), set.network)
.await?
.unwrap_or(BlockHash([0; 32])), // TODO: Have the processor override this
},
// TODO: Check the DB for which attempt used this key pair
id: KeyGenId { set, attempt: todo!() },
},
))
.await;
}
Ok(())
}
async fn handle_batch_and_burns<D: Db>(
async fn handle_batch_and_burns<D: Db, Pro: Processor>(
db: &mut MainDb<D>,
key: &Zeroizing<<Ristretto as Ciphersuite>::F>,
processor: &mut Pro,
serai: &Serai,
block: &Block,
) -> Result<(), SeraiError> {
@@ -170,17 +170,21 @@ async fn handle_batch_and_burns<D: Db>(
// the last batch will be the latest batch, so its block will be the latest block
batch_block.insert(network, network_block);
// TODO: Send this to processor. Check how it handles it being fired multiple times
let msg = processor_messages::coordinator::CoordinatorMessage::BatchSigned {
key: get_coin_key(
serai,
// TODO2
ValidatorSet { network, session: Session(0) },
)
.await?
.expect("ValidatorSet without keys signed a batch"),
block: network_block,
};
// TODO: Check how the processor handles thi being fired multiple times
processor
.send(CoordinatorMessage::Coordinator(
processor_messages::coordinator::CoordinatorMessage::BatchSigned {
key: get_coin_key(
serai,
// TODO2
ValidatorSet { network, session: Session(0) },
)
.await?
.expect("ValidatorSet without keys signed a batch"),
block: network_block,
},
))
.await;
} else {
panic!("Batch event wasn't Batch: {batch:?}");
}
@@ -224,18 +228,22 @@ async fn handle_batch_and_burns<D: Db>(
.expect("network had a batch/burn yet never set a latest block")
};
// TODO: Send this to processor. Check how it handles it being fired multiple times
let msg = processor_messages::substrate::CoordinatorMessage::SubstrateBlock {
context: SubstrateContext { coin_latest_finalized_block },
key: get_coin_key(
serai,
// TODO2
ValidatorSet { network, session: Session(0) },
)
.await?
.expect("batch/burn for network which never set keys"),
burns: burns.remove(&network).unwrap(),
};
// TODO: Check how the processor handles thi being fired multiple times
processor
.send(CoordinatorMessage::Substrate(
processor_messages::substrate::CoordinatorMessage::SubstrateBlock {
context: SubstrateContext { coin_latest_finalized_block },
key: get_coin_key(
serai,
// TODO2
ValidatorSet { network, session: Session(0) },
)
.await?
.expect("batch/burn for network which never set keys"),
burns: burns.remove(&network).unwrap(),
},
))
.await;
}
Ok(())
@@ -243,10 +251,11 @@ async fn handle_batch_and_burns<D: Db>(
// Handle a specific Substrate block, returning an error when it fails to get data
// (not blocking / holding)
async fn handle_block<D: Db, P: P2p>(
async fn handle_block<D: Db, Pro: Processor, P: P2p>(
db: &mut MainDb<D>,
key: &Zeroizing<<Ristretto as Ciphersuite>::F>,
p2p: &P,
processor: &mut Pro,
serai: &Serai,
block: Block,
) -> Result<(), SeraiError> {
@@ -263,7 +272,7 @@ async fn handle_block<D: Db, P: P2p>(
// stable)
if !db.handled_event(hash, event_id) {
if let ValidatorSetsEvent::NewSet { set } = new_set {
handle_new_set(db, key, p2p, serai, &block, set).await?;
handle_new_set(db, key, p2p, processor, serai, &block, set).await?;
} else {
panic!("NewSet event wasn't NewSet: {new_set:?}");
}
@@ -276,7 +285,7 @@ async fn handle_block<D: Db, P: P2p>(
for key_gen in serai.get_key_gen_events(hash).await? {
if !db.handled_event(hash, event_id) {
if let ValidatorSetsEvent::KeyGen { set, key_pair } = key_gen {
handle_key_gen(db, key, serai, &block, set, key_pair).await?;
handle_key_gen(db, key, processor, serai, &block, set, key_pair).await?;
} else {
panic!("KeyGen event wasn't KeyGen: {key_gen:?}");
}
@@ -291,17 +300,18 @@ async fn handle_block<D: Db, P: P2p>(
// This does break the uniqueness of (hash, event_id) -> one event, yet
// (network, (hash, event_id)) remains valid as a unique ID for an event
if !db.handled_event(hash, event_id) {
handle_batch_and_burns(db, key, serai, &block).await?;
handle_batch_and_burns(db, key, processor, serai, &block).await?;
}
db.handle_event(hash, event_id);
Ok(())
}
pub async fn handle_new_blocks<D: Db, P: P2p>(
pub async fn handle_new_blocks<D: Db, Pro: Processor, P: P2p>(
db: &mut MainDb<D>,
key: &Zeroizing<<Ristretto as Ciphersuite>::F>,
p2p: &P,
processor: &mut Pro,
serai: &Serai,
last_substrate_block: &mut u64,
) -> Result<(), SeraiError> {
@@ -318,11 +328,15 @@ pub async fn handle_new_blocks<D: Db, P: P2p>(
db,
key,
p2p,
processor,
serai,
if b == latest_number {
latest.take().unwrap()
} else {
serai.get_block_by_number(b).await?.unwrap()
serai
.get_block_by_number(b)
.await?
.expect("couldn't get block before the latest finalized block")
},
)
.await?;