Skip to content

Commit d23ba87

Browse files
patrick-ogradypatrick-ogrady
committed
fix linting
1 parent e20663c commit d23ba87

File tree

2 files changed

+57
-53
lines changed

2 files changed

+57
-53
lines changed

‎simulator/src/lib.rs‎

Lines changed: 49 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -84,15 +84,19 @@ impl Simulator {
8484
}
8585

8686
let mut state = self.state.write().unwrap();
87-
87+
8888
// Store block by digest
8989
state
9090
.blocks_by_digest
9191
.insert(notarized.block.digest(), notarized.block.clone());
9292

9393
// Store notarization
9494
let view = notarized.proof.view();
95-
if state.notarizations.insert(view, notarized.clone()).is_some() {
95+
if state
96+
.notarizations
97+
.insert(view, notarized.clone())
98+
.is_some()
99+
{
96100
return Ok(()); // Already exists
97101
}
98102

@@ -106,10 +110,7 @@ impl Simulator {
106110
pub fn get_notarization(&self, query: &str) -> Option<Notarized> {
107111
let state = self.state.read().unwrap();
108112
if query == LATEST {
109-
state
110-
.notarizations
111-
.last_key_value()
112-
.map(|(_, n)| n.clone())
113+
state.notarizations.last_key_value().map(|(_, n)| n.clone())
113114
} else {
114115
// Parse as hex-encoded index
115116
let raw = from_hex(query)?;
@@ -125,15 +126,19 @@ impl Simulator {
125126
}
126127

127128
let mut state = self.state.write().unwrap();
128-
129+
129130
// Store block by digest
130131
state
131132
.blocks_by_digest
132133
.insert(finalized.block.digest(), finalized.block.clone());
133134

134135
// Store finalization
135136
let view = finalized.proof.view();
136-
if state.finalizations.insert(view, finalized.clone()).is_some() {
137+
if state
138+
.finalizations
139+
.insert(view, finalized.clone())
140+
.is_some()
141+
{
137142
return Ok(()); // Already exists
138143
}
139144

@@ -147,10 +152,7 @@ impl Simulator {
147152
pub fn get_finalization(&self, query: &str) -> Option<Finalized> {
148153
let state = self.state.read().unwrap();
149154
if query == LATEST {
150-
state
151-
.finalizations
152-
.last_key_value()
153-
.map(|(_, f)| f.clone())
155+
state.finalizations.last_key_value().map(|(_, f)| f.clone())
154156
} else {
155157
// Parse as hex-encoded index
156158
let raw = from_hex(query)?;
@@ -161,7 +163,7 @@ impl Simulator {
161163

162164
pub fn get_block(&self, query: &str) -> Option<BlockResult> {
163165
let state = self.state.read().unwrap();
164-
166+
165167
if query == LATEST {
166168
// Return latest finalized block
167169
state
@@ -200,6 +202,7 @@ impl Simulator {
200202
}
201203
}
202204

205+
#[allow(clippy::large_enum_variant)]
203206
pub enum BlockResult {
204207
Block(Block),
205208
Finalized(Finalized),
@@ -378,20 +381,20 @@ mod tests {
378381
.iter()
379382
.map(|share| Notarize::<MinSig, _>::sign(NAMESPACE, share, proposal.clone()))
380383
.collect::<Vec<_>>();
381-
384+
382385
let proposal_partials = partials
383386
.iter()
384387
.map(|partial| partial.proposal_signature.clone())
385388
.collect::<Vec<_>>();
386389
let proposal_recovered =
387390
threshold_signature_recover::<MinSig, _>(3, &proposal_partials).unwrap();
388-
391+
389392
let seed_partials = partials
390393
.into_iter()
391394
.map(|partial| partial.seed_signature)
392395
.collect::<Vec<_>>();
393396
let seed_recovered = threshold_signature_recover::<MinSig, _>(3, &seed_partials).unwrap();
394-
397+
395398
Notarization::new(proposal, proposal_recovered, seed_recovered)
396399
}
397400

@@ -408,7 +411,7 @@ mod tests {
408411
.map(|partial| partial.seed_signature)
409412
.collect::<Vec<_>>();
410413
let seed_recovered = threshold_signature_recover::<MinSig, _>(3, &seed_partials).unwrap();
411-
414+
412415
let finalize_partials = shares
413416
.iter()
414417
.map(|share| Finalize::<MinSig, _>::sign(NAMESPACE, share, proposal.clone()))
@@ -419,7 +422,7 @@ mod tests {
419422
.collect::<Vec<_>>();
420423
let finalize_recovered =
421424
threshold_signature_recover::<MinSig, _>(3, &finalize_partials).unwrap();
422-
425+
423426
Finalization::new(proposal, finalize_recovered, seed_recovered)
424427
}
425428

@@ -448,8 +451,8 @@ mod tests {
448451
let (master_secret, identity) = ops::keypair::<_, MinSig>(&mut rng);
449452

450453
// Start server
451-
let (addr, _handle) = start_test_server(identity.clone()).await;
452-
let client = Client::new(&format!("http://{}", addr), identity.clone());
454+
let (addr, _handle) = start_test_server(identity).await;
455+
let client = Client::new(&format!("http://{addr}"), identity);
453456

454457
// Test seed upload and retrieval
455458
let seed = create_test_seed(&master_secret, 1);
@@ -467,18 +470,18 @@ mod tests {
467470
// Create network key for identity (what the simulator checks)
468471
let mut rng = StdRng::seed_from_u64(0);
469472
let (polynomial, shares) = dkg_ops::generate_shares::<_, MinSig>(&mut rng, None, 4, 3);
470-
let identity = poly::public::<MinSig>(&polynomial);
473+
let identity = *poly::public::<MinSig>(&polynomial);
471474

472475
// Start server
473-
let (addr, _handle) = start_test_server(identity.clone()).await;
474-
let client = Client::new(&format!("http://{}", addr), identity.clone());
476+
let (addr, _handle) = start_test_server(identity).await;
477+
let client = Client::new(&format!("http://{addr}"), identity);
475478

476479
// Test notarization
477480
let block = Block::new(hash(b"genesis"), 1, 1000);
478481
let proposal = Proposal::new(1, 0, block.digest());
479482
let notarization = create_notarization(&shares, proposal);
480483
let notarized = Notarized::new(notarization, block);
481-
484+
482485
client.notarized_upload(notarized.clone()).await.unwrap();
483486

484487
let retrieved = client.notarized_get(IndexQuery::Latest).await.unwrap();
@@ -493,18 +496,18 @@ mod tests {
493496
// Create network key for identity (what the simulator checks)
494497
let mut rng = StdRng::seed_from_u64(0);
495498
let (polynomial, shares) = dkg_ops::generate_shares::<_, MinSig>(&mut rng, None, 4, 3);
496-
let identity = poly::public::<MinSig>(&polynomial);
499+
let identity = *poly::public::<MinSig>(&polynomial);
497500

498501
// Start server
499-
let (addr, _handle) = start_test_server(identity.clone()).await;
500-
let client = Client::new(&format!("http://{}", addr), identity.clone());
502+
let (addr, _handle) = start_test_server(identity).await;
503+
let client = Client::new(&format!("http://{addr}"), identity);
501504

502505
// Test finalization
503506
let block = Block::new(hash(b"genesis"), 1, 1000);
504507
let proposal = Proposal::new(1, 0, block.digest());
505508
let finalization = create_finalization(&shares, proposal);
506509
let finalized = Finalized::new(finalization, block);
507-
510+
508511
client.finalized_upload(finalized.clone()).await.unwrap();
509512

510513
let retrieved = client.finalized_get(IndexQuery::Latest).await.unwrap();
@@ -519,18 +522,18 @@ mod tests {
519522
// Create network key for identity (what the simulator checks)
520523
let mut rng = StdRng::seed_from_u64(0);
521524
let (polynomial, shares) = dkg_ops::generate_shares::<_, MinSig>(&mut rng, None, 4, 3);
522-
let identity = poly::public::<MinSig>(&polynomial);
525+
let identity = *poly::public::<MinSig>(&polynomial);
523526

524527
// Start server
525-
let (addr, _handle) = start_test_server(identity.clone()).await;
526-
let client = Client::new(&format!("http://{}", addr), identity.clone());
528+
let (addr, _handle) = start_test_server(identity).await;
529+
let client = Client::new(&format!("http://{addr}"), identity);
527530

528531
// Submit finalized block
529532
let block = Block::new(hash(b"genesis"), 1, 1000);
530533
let proposal = Proposal::new(1, 0, block.digest());
531534
let finalization = create_finalization(&shares, proposal);
532535
let finalized = Finalized::new(finalization, block.clone());
533-
536+
534537
client.finalized_upload(finalized).await.unwrap();
535538

536539
// Test retrieval by latest
@@ -552,7 +555,10 @@ mod tests {
552555
}
553556

554557
// Test retrieval by digest
555-
let payload = client.block_get(Query::Digest(block.digest())).await.unwrap();
558+
let payload = client
559+
.block_get(Query::Digest(block.digest()))
560+
.await
561+
.unwrap();
556562
match payload {
557563
alto_client::consensus::Payload::Block(b) => {
558564
assert_eq!(b.digest(), block.digest());
@@ -568,8 +574,8 @@ mod tests {
568574
let (master_secret, identity) = ops::keypair::<_, MinSig>(&mut rng);
569575

570576
// Start server
571-
let (addr, _handle) = start_test_server(identity.clone()).await;
572-
let client = Client::new(&format!("http://{}", addr), identity.clone());
577+
let (addr, _handle) = start_test_server(identity).await;
578+
let client = Client::new(&format!("http://{addr}"), identity);
573579

574580
// Start listening
575581
let mut stream = client.listen().await.unwrap();
@@ -604,15 +610,15 @@ mod tests {
604610
let (_, identity2) = ops::keypair::<_, MinSig>(&mut rng);
605611

606612
// Start server with identity1
607-
let (addr, _handle) = start_test_server(identity1.clone()).await;
608-
613+
let (addr, _handle) = start_test_server(identity1).await;
614+
609615
// Create client with identity2 (different from server)
610-
let client = Client::new(&format!("http://{}", addr), identity2.clone());
616+
let client = Client::new(&format!("http://{addr}"), identity2);
611617

612618
// Upload a seed signed by identity1 (server will accept it)
613619
let seed = create_test_seed(&master_secret1, 1);
614620
client.seed_upload(seed).await.unwrap(); // This succeeds - server accepts it
615-
621+
616622
// Try to retrieve the seed - client will fail to verify since it expects identity2
617623
let result = client.seed_get(IndexQuery::Latest).await;
618624
assert!(result.is_err()); // Fails because client expects identity2 but seed is signed by identity1
@@ -628,14 +634,14 @@ mod tests {
628634
let (wrong_master_secret, _) = ops::keypair::<_, MinSig>(&mut rng);
629635

630636
// Start server
631-
let (addr, _handle) = start_test_server(identity.clone()).await;
632-
let client = Client::new(&format!("http://{}", addr), identity.clone());
637+
let (addr, _handle) = start_test_server(identity).await;
638+
let client = Client::new(&format!("http://{addr}"), identity);
633639

634640
// Create seed with wrong signature
635641
let bad_seed = create_test_seed(&wrong_master_secret, 1);
636-
642+
637643
// This should fail at the server because the signature doesn't match the identity
638644
let result = client.seed_upload(bad_seed).await;
639645
assert!(result.is_err());
640646
}
641-
}
647+
}

‎simulator/src/main.rs‎

Lines changed: 8 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,6 @@ use alto_simulator::{Api, Simulator};
22
use alto_types::Identity;
33
use clap::Parser;
44
use commonware_codec::DecodeExt;
5-
use commonware_utils::hex;
65
use std::sync::Arc;
76
use tracing::info;
87

@@ -12,7 +11,10 @@ struct Args {
1211
#[clap(short, long, default_value_t = 8080)]
1312
port: u16,
1413

15-
#[clap(long, help = "Identity public key in hex format (BLS12-381 public key)")]
14+
#[clap(
15+
long,
16+
help = "Identity public key in hex format (BLS12-381 public key)"
17+
)]
1618
identity: Option<String>,
1719
}
1820

@@ -28,10 +30,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
2830

2931
// Parse identity if provided
3032
let identity: Identity = if let Some(id_hex) = args.identity {
31-
let bytes = commonware_utils::from_hex(&id_hex)
32-
.ok_or("Invalid identity hex format")?;
33-
Identity::decode(&mut bytes.as_slice())
34-
.map_err(|_| "Failed to decode identity")?
33+
let bytes = commonware_utils::from_hex(&id_hex).ok_or("Invalid identity hex format")?;
34+
Identity::decode(&mut bytes.as_slice()).map_err(|_| "Failed to decode identity")?
3535
} else {
3636
// Generate a default identity for testing
3737
use commonware_cryptography::bls12381::primitives::{ops, variant::MinSig};
@@ -41,8 +41,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
4141
public
4242
};
4343

44-
info!("Using identity: {}", hex(&commonware_codec::Encode::encode(&identity).to_vec()));
45-
4644
// Initialize simulator
4745
let simulator = Arc::new(Simulator::new(identity));
4846
let api = Api::new(simulator);
@@ -51,8 +49,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
5149
// Start server
5250
let addr = format!("0.0.0.0:{}", args.port);
5351
let listener = tokio::net::TcpListener::bind(&addr).await?;
54-
info!("Listening on {}", addr);
52+
info!(?identity, ?addr, "started simulator");
5553
axum::serve(listener, app).await?;
5654

5755
Ok(())
58-
}
56+
}

0 commit comments

Comments
 (0)