1use std::path::PathBuf;
4use std::sync::{Arc, OnceLock};
5
6use parking_lot::RwLock;
7
8use ed25519_dalek::{SigningKey, VerifyingKey};
9
10use crate::crypto::pq::{MlDsaSigningKey, MlDsaVerifyingKey};
11
12#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
14pub enum CompositePairRole {
15 OAuth,
16 Policy,
17}
18
19#[derive(Clone, Copy, Debug, Eq, PartialEq)]
21pub enum CompositePairState {
22 Active,
23 Drain,
24}
25
26#[derive(Clone)]
28pub struct CompositeKeyPair {
29 kid: String,
30 ml_dsa: MlDsaVerifyingKey,
31 ed25519: VerifyingKey,
32 role: CompositePairRole,
33 state: CompositePairState,
34 not_before: i64,
35 expires_at: i64,
36 ml_dsa_signing: Option<Arc<MlDsaSigningKey>>,
37 ed25519_signing: Option<Arc<SigningKey>>,
38}
39
40impl CompositeKeyPair {
41 #[allow(clippy::too_many_arguments)]
42 pub fn signing(
43 kid: String,
44 ml_dsa: Arc<MlDsaSigningKey>,
45 ed25519: Arc<SigningKey>,
46 role: CompositePairRole,
47 state: CompositePairState,
48 not_before: i64,
49 expires_at: i64,
50 ) -> Self {
51 let ml_dsa_vk = ml_dsa::Keypair::verifying_key(&*ml_dsa).clone();
52 let ed25519_vk = ed25519.verifying_key();
53 Self {
54 kid,
55 ml_dsa: ml_dsa_vk,
56 ed25519: ed25519_vk,
57 role,
58 state,
59 not_before,
60 expires_at,
61 ml_dsa_signing: Some(ml_dsa),
62 ed25519_signing: Some(ed25519),
63 }
64 }
65
66 #[allow(clippy::too_many_arguments)]
67 pub fn verifying(
68 kid: String,
69 ml_dsa: MlDsaVerifyingKey,
70 ed25519: VerifyingKey,
71 role: CompositePairRole,
72 state: CompositePairState,
73 not_before: i64,
74 expires_at: i64,
75 ) -> Self {
76 Self {
77 kid,
78 ml_dsa,
79 ed25519,
80 role,
81 state,
82 not_before,
83 expires_at,
84 ml_dsa_signing: None,
85 ed25519_signing: None,
86 }
87 }
88
89 pub fn kid(&self) -> &str {
90 &self.kid
91 }
92 pub fn ml_dsa(&self) -> &MlDsaVerifyingKey {
93 &self.ml_dsa
94 }
95 pub fn ed25519(&self) -> &VerifyingKey {
96 &self.ed25519
97 }
98 pub fn role(&self) -> CompositePairRole {
99 self.role
100 }
101 pub fn state(&self) -> CompositePairState {
102 self.state
103 }
104 pub fn not_before(&self) -> i64 {
105 self.not_before
106 }
107 pub fn expires_at(&self) -> i64 {
108 self.expires_at
109 }
110
111 pub fn signing_keys(&self) -> Option<(Arc<MlDsaSigningKey>, Arc<SigningKey>)> {
112 Some((
113 self.ml_dsa_signing.as_ref()?.clone(),
114 self.ed25519_signing.as_ref()?.clone(),
115 ))
116 }
117}
118
119#[derive(Clone)]
121pub struct CompositeKeySetSnapshot {
122 version: u64,
123 component_digest: Arc<str>,
124 pairs: Arc<[CompositeKeyPair]>,
125}
126
127impl CompositeKeySetSnapshot {
128 pub fn version(&self) -> u64 {
129 self.version
130 }
131 pub fn component_digest(&self) -> &str {
132 &self.component_digest
133 }
134 pub fn pairs(&self) -> &[CompositeKeyPair] {
135 &self.pairs
136 }
137
138 pub fn pair(&self, kid: &str) -> Option<&CompositeKeyPair> {
139 self.pairs.iter().find(|pair| pair.kid == kid)
140 }
141
142 pub fn active_signing_pair(&self, role: CompositePairRole) -> Option<&CompositeKeyPair> {
143 self.pairs.iter().find(|pair| {
144 pair.role == role
145 && pair.state == CompositePairState::Active
146 && pair.ml_dsa_signing.is_some()
147 && pair.ed25519_signing.is_some()
148 })
149 }
150}
151
152pub struct CompositeKeySet {
154 snapshot: RwLock<Arc<CompositeKeySetSnapshot>>,
155 authority: RwLock<Option<CompositeAuthorityPaths>>,
156}
157
158#[derive(Clone)]
159struct CompositeAuthorityPaths {
160 ledger: PathBuf,
161 committed: PathBuf,
162 committed_ledger_prefix: PathBuf,
163 ledger_lock: PathBuf,
164}
165
166impl Default for CompositeKeySet {
167 fn default() -> Self {
168 Self {
169 snapshot: RwLock::new(Arc::new(CompositeKeySetSnapshot {
170 version: 0,
171 component_digest: Arc::from(""),
172 pairs: Arc::from([]),
173 })),
174 authority: RwLock::new(None),
175 }
176 }
177}
178
179impl CompositeKeySet {
180 pub fn snapshot(&self) -> Arc<CompositeKeySetSnapshot> {
181 self.snapshot.read().clone()
182 }
183
184 pub fn authority_configured(&self) -> bool {
189 self.authority.read().is_some()
190 }
191
192 pub fn configure_authority(
193 &self,
194 ledger: PathBuf,
195 committed: PathBuf,
196 committed_ledger_prefix: PathBuf,
197 ledger_lock: PathBuf,
198 ) {
199 *self.authority.write() = Some(CompositeAuthorityPaths {
200 ledger,
201 committed,
202 committed_ledger_prefix,
203 ledger_lock,
204 });
205 }
206
207 pub fn mint_snapshot(&self) -> anyhow::Result<Arc<CompositeKeySetSnapshot>> {
209 let (snapshot, _authority_lock) = self.mint_snapshot_locked()?;
210 Ok(snapshot)
211 }
212
213 fn mint_snapshot_locked(
214 &self,
215 ) -> anyhow::Result<(Arc<CompositeKeySetSnapshot>, std::fs::File)> {
216 use nix::fcntl::{flock, FlockArg};
217 use std::os::fd::AsRawFd;
218 let authority = self
219 .authority
220 .read()
221 .clone()
222 .ok_or_else(|| anyhow::anyhow!("composite authority is not configured"))?;
223 let lock = std::fs::OpenOptions::new()
224 .create(true)
225 .truncate(false)
226 .read(true)
227 .write(true)
228 .open(&authority.ledger_lock)?;
229 flock(lock.as_raw_fd(), FlockArg::LockShared)?;
230 let committed: serde_json::Value =
231 serde_json::from_slice(&std::fs::read(&authority.committed)?)?;
232 let committed_version = committed
233 .get("version")
234 .and_then(serde_json::Value::as_u64)
235 .ok_or_else(|| anyhow::anyhow!("committed composite version missing"))?;
236 let committed_digest = committed
237 .get("component_digest")
238 .and_then(serde_json::Value::as_str)
239 .filter(|digest| !digest.is_empty())
240 .ok_or_else(|| anyhow::anyhow!("committed component digest missing"))?;
241 let prefix_name = authority
242 .committed_ledger_prefix
243 .file_name()
244 .and_then(|name| name.to_str())
245 .ok_or_else(|| anyhow::anyhow!("committed ledger prefix has no file name"))?;
246 let committed_ledger = authority.committed_ledger_prefix.with_file_name(format!(
247 "{prefix_name}-{committed_version}-{committed_digest}.json"
248 ));
249 let ledger_bytes = match std::fs::read(&committed_ledger) {
250 Ok(bytes) => bytes,
251 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
252 std::fs::read(&authority.ledger)?
255 }
256 Err(error) => return Err(error.into()),
257 };
258 let ledger: serde_json::Value = serde_json::from_slice(&ledger_bytes)?;
259 let disk_version = ledger
260 .get("version")
261 .and_then(serde_json::Value::as_u64)
262 .ok_or_else(|| anyhow::anyhow!("composite ledger version missing"))?;
263 let disk_digest = ledger
264 .get("component_digest")
265 .and_then(serde_json::Value::as_str)
266 .filter(|digest| !digest.is_empty())
267 .ok_or_else(|| anyhow::anyhow!("composite ledger component digest missing"))?;
268 let snapshot = self.snapshot();
269 anyhow::ensure!(
270 snapshot.version == disk_version
271 && snapshot.version == committed_version
272 && snapshot.component_digest() == disk_digest
273 && snapshot.component_digest() == committed_digest,
274 "composite signing authority is stale or cutover is pending"
275 );
276 Ok((snapshot, lock))
277 }
278
279 pub fn attach_committed_signing_keys(
284 &self,
285 version: u64,
286 component_digest: &str,
287 pairs: Vec<CompositeKeyPair>,
288 ) -> anyhow::Result<()> {
289 let (observed, _authority_lock) = self.mint_snapshot_locked()?;
290 self.attach_signing_keys_to_snapshot(&observed, version, component_digest, pairs)
291 }
292
293 fn attach_signing_keys_to_snapshot(
294 &self,
295 observed: &Arc<CompositeKeySetSnapshot>,
296 version: u64,
297 component_digest: &str,
298 pairs: Vec<CompositeKeyPair>,
299 ) -> anyhow::Result<()> {
300 let mut guard = self.snapshot.write();
301 anyhow::ensure!(
302 Arc::ptr_eq(&guard, observed)
303 && guard.version == version
304 && guard.component_digest() == component_digest,
305 "committed composite snapshot changed before signer attachment"
306 );
307 anyhow::ensure!(
308 pairs.len() == guard.pairs.len(),
309 "composite pair set changed"
310 );
311 let mut seen = std::collections::HashSet::new();
312 let mut attached = Vec::with_capacity(pairs.len());
313 for pair in pairs {
314 anyhow::ensure!(seen.insert(pair.kid.clone()), "duplicate composite kid");
315 let current = guard
316 .pair(&pair.kid)
317 .ok_or_else(|| anyhow::anyhow!("signer pair is not committed"))?;
318 anyhow::ensure!(
319 pair.role == current.role
320 && pair.state == current.state
321 && pair.not_before == current.not_before
322 && pair.expires_at == current.expires_at
323 && pair.ed25519 == current.ed25519
324 && crate::crypto::pq::ml_dsa_vk_bytes(&pair.ml_dsa)
325 == crate::crypto::pq::ml_dsa_vk_bytes(¤t.ml_dsa),
326 "signer pair differs from committed public authority"
327 );
328 if let Some((pq, ed)) = pair.signing_keys() {
329 anyhow::ensure!(
330 ed.verifying_key() == current.ed25519
331 && crate::crypto::pq::ml_dsa_vk_bytes(&ml_dsa::Keypair::verifying_key(
332 &*pq
333 )) == crate::crypto::pq::ml_dsa_vk_bytes(¤t.ml_dsa),
334 "private signer does not match committed public pair"
335 );
336 attached.push(pair);
337 } else {
338 attached.push(current.clone());
340 }
341 }
342 *guard = Arc::new(CompositeKeySetSnapshot {
343 version,
344 component_digest: Arc::clone(&observed.component_digest),
345 pairs: attached.into(),
346 });
347 Ok(())
348 }
349
350 pub fn publish(
352 &self,
353 version: u64,
354 component_digest: String,
355 pairs: Vec<CompositeKeyPair>,
356 ) -> anyhow::Result<()> {
357 let mut guard = self.snapshot.write();
358 anyhow::ensure!(
359 version > guard.version,
360 "composite key-set version must increase"
361 );
362 anyhow::ensure!(
363 !component_digest.is_empty(),
364 "composite component digest must not be empty"
365 );
366 let mut kids = std::collections::HashSet::new();
367 let mut active_roles = std::collections::HashSet::new();
368 for pair in &pairs {
369 anyhow::ensure!(kids.insert(pair.kid.clone()), "duplicate composite kid");
370 if pair.state == CompositePairState::Active {
371 anyhow::ensure!(
372 active_roles.insert(pair.role),
373 "multiple active composite pairs for one issuer role"
374 );
375 }
376 anyhow::ensure!(
377 pair.kid == super::jwt::composite_kid(&pair.ml_dsa, &pair.ed25519),
378 "composite kid does not bind its exact key pair"
379 );
380 }
381 *guard = Arc::new(CompositeKeySetSnapshot {
382 version,
383 component_digest: Arc::from(component_digest),
384 pairs: pairs.into(),
385 });
386 Ok(())
387 }
388}
389
390static GLOBAL_COMPOSITE_KEY_SET: OnceLock<Arc<CompositeKeySet>> = OnceLock::new();
391
392pub fn global_composite_key_set() -> Arc<CompositeKeySet> {
393 GLOBAL_COMPOSITE_KEY_SET
394 .get_or_init(|| Arc::new(CompositeKeySet::default()))
395 .clone()
396}
397
398#[cfg(test)]
399#[allow(clippy::unwrap_used)]
400mod tests {
401 use super::*;
402 use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
403 use ed25519_dalek::Signer as _;
404 use std::sync::Barrier;
405
406 fn pair_from_keys(
407 pq: Arc<MlDsaSigningKey>,
408 ed: Arc<SigningKey>,
409 state: CompositePairState,
410 ) -> CompositeKeyPair {
411 let kid =
412 crate::auth::composite_kid(&ml_dsa::Keypair::verifying_key(&*pq), &ed.verifying_key());
413 CompositeKeyPair::signing(kid, pq, ed, CompositePairRole::OAuth, state, 0, i64::MAX)
414 }
415
416 fn pair(seed: u8) -> CompositeKeyPair {
417 let ed = Arc::new(SigningKey::from_bytes(&[seed; 32]));
418 let (pq, _) = crate::crypto::pq::ml_dsa_generate_keypair();
419 pair_from_keys(Arc::new(pq), ed, CompositePairState::Active)
420 }
421
422 fn mint(pair: &CompositeKeyPair) -> String {
423 let (pq, ed) = pair.signing_keys().unwrap();
424 let header = format!(
425 r#"{{"alg":"ML-DSA-65-Ed25519","typ":"at+jwt","kid":"{}"}}"#,
426 pair.kid()
427 );
428 let now = chrono::Utc::now().timestamp();
429 let claims = crate::auth::Claims::new("subject".to_owned(), now, now + 3600)
430 .with_audience(Some("resource".to_owned()));
431 let input = format!(
432 "{}.{}",
433 URL_SAFE_NO_PAD.encode(header),
434 URL_SAFE_NO_PAD.encode(serde_json::to_vec(&claims).unwrap())
435 );
436 let pq_signature = crate::crypto::pq::ml_dsa_sign(&pq, input.as_bytes());
437 let ed_signature = ed.sign(input.as_bytes());
438 let mut signature = pq_signature;
439 signature.extend_from_slice(&ed_signature.to_bytes());
440 format!("{}.{}", input, URL_SAFE_NO_PAD.encode(signature))
441 }
442
443 fn verify(token: &str, snapshot: &CompositeKeySetSnapshot) -> bool {
444 let Ok(dispatch) = crate::auth::parse_composite_dispatch(token, &["at+jwt"]) else {
445 return false;
446 };
447 let Some(pair) = snapshot.pair(dispatch.kid()) else {
448 return false;
449 };
450 crate::auth::jwt::decode_composite(
451 token,
452 pair.ml_dsa(),
453 pair.ed25519(),
454 Some("resource"),
455 &dispatch,
456 )
457 .is_ok()
458 }
459
460 #[test]
461 fn publication_is_atomic_across_mint_verify_and_jwks_barriers() {
462 let keys = Arc::new(CompositeKeySet::default());
463 let old = pair(1);
464 let old_kid = old.kid().to_owned();
465 keys.publish(1, "generation-1".into(), vec![old.clone()])
466 .unwrap();
467 let ed_promotion = Arc::new(Barrier::new(2));
468 let pq_promotion = Arc::new(Barrier::new(2));
469 let mint_barrier = Arc::new(Barrier::new(2));
470 let publication_barrier = Arc::new(Barrier::new(2));
471 let verify_barrier = Arc::new(Barrier::new(2));
472 let jwks_barrier = Arc::new(Barrier::new(2));
473
474 let reader_keys = Arc::clone(&keys);
475 let reader_ed = Arc::clone(&ed_promotion);
476 let reader_pq = Arc::clone(&pq_promotion);
477 let reader_mint = Arc::clone(&mint_barrier);
478 let reader_publication = Arc::clone(&publication_barrier);
479 let reader_verify = Arc::clone(&verify_barrier);
480 let reader_jwks = Arc::clone(&jwks_barrier);
481 let reader_old_kid = old_kid.clone();
482 let reader = std::thread::spawn(move || {
483 reader_ed.wait();
484 reader_pq.wait();
485 let mint_snapshot = reader_keys.snapshot();
486 let token = mint(
487 mint_snapshot
488 .active_signing_pair(CompositePairRole::OAuth)
489 .unwrap(),
490 );
491 reader_mint.wait();
492 reader_publication.wait();
493 let verify_snapshot = reader_keys.snapshot();
494 let verify_version = verify_snapshot.version();
495 let token_verified = verify(&token, &verify_snapshot);
496 reader_verify.wait();
497 let jwks_snapshot = reader_keys.snapshot();
498 let jwks_has_old = jwks_snapshot.pair(&reader_old_kid).is_some();
499 let jwks_len = jwks_snapshot.pairs().len();
500 reader_jwks.wait();
501 (
502 token,
503 verify_version,
504 token_verified,
505 jwks_has_old,
506 jwks_len,
507 )
508 });
509
510 let promoted_ed = Arc::new(SigningKey::from_bytes(&[2; 32]));
511 ed_promotion.wait();
512 let (promoted_pq, _) = crate::crypto::pq::ml_dsa_generate_keypair();
513 pq_promotion.wait();
514 let promoted = pair_from_keys(
515 Arc::new(promoted_pq),
516 promoted_ed,
517 CompositePairState::Active,
518 );
519 let promoted_kid = promoted.kid().to_owned();
520 mint_barrier.wait();
521 let mut old_drain = old;
522 old_drain.state = CompositePairState::Drain;
523 keys.publish(2, "generation-2".into(), vec![old_drain, promoted.clone()])
524 .unwrap();
525 publication_barrier.wait();
526 verify_barrier.wait();
527 jwks_barrier.wait();
528 let (old_token, verify_version, token_verified, jwks_has_old, jwks_len) =
529 reader.join().unwrap();
530 assert_eq!(verify_version, 2);
531 assert!(token_verified, "a returned token became unverifiable");
532 assert!(jwks_has_old);
533 assert_eq!(jwks_len, 2);
534
535 keys.publish(3, "generation-3".into(), vec![promoted])
538 .unwrap();
539 let after = keys.snapshot();
540 assert_eq!(after.version(), 3);
541 assert!(after.pair(&promoted_kid).is_some());
542 assert!(
543 after.pair(&old_kid).is_none(),
544 "evicted pair remained accepted"
545 );
546 assert!(!verify(&old_token, &after));
547 let new_token = mint(after.active_signing_pair(CompositePairRole::OAuth).unwrap());
548 assert!(verify(&new_token, &after));
549 }
550
551 #[test]
552 fn committed_signer_attachment_preserves_exact_authority_and_rejects_changes() {
553 let dir = std::env::temp_dir().join(format!("hyprstream-attach-{}", uuid::Uuid::new_v4()));
554 std::fs::create_dir_all(&dir).unwrap();
555 let keys = CompositeKeySet::default();
556 keys.configure_authority(
557 dir.join("ledger"),
558 dir.join("commit"),
559 dir.join("committed"),
560 dir.join("lock"),
561 );
562 let signing = pair(41);
563 let verifying = CompositeKeyPair::verifying(
564 signing.kid.clone(),
565 signing.ml_dsa.clone(),
566 signing.ed25519,
567 signing.role,
568 signing.state,
569 signing.not_before,
570 signing.expires_at,
571 );
572 keys.publish(1, "generation-1".into(), vec![verifying.clone()])
573 .unwrap();
574 assert!(
575 keys.attach_committed_signing_keys(1, "generation-1", vec![signing.clone()])
576 .is_err(),
577 "uncommitted authority gained a signer"
578 );
579 let committed = br#"{"version":1,"component_digest":"generation-1"}"#;
580 std::fs::write(dir.join("commit"), committed).unwrap();
581 std::fs::write(dir.join("committed-1-generation-1.json"), committed).unwrap();
582
583 for changed in [
584 {
585 let mut p = signing.clone();
586 p.role = CompositePairRole::Policy;
587 p
588 },
589 {
590 let mut p = signing.clone();
591 p.state = CompositePairState::Drain;
592 p
593 },
594 {
595 let mut p = signing.clone();
596 p.expires_at -= 1;
597 p
598 },
599 {
600 let mut p = signing.clone();
601 p.ed25519_signing = Some(Arc::new(SigningKey::from_bytes(&[42; 32])));
602 p
603 },
604 pair(43),
605 ] {
606 assert!(keys
607 .attach_committed_signing_keys(1, "generation-1", vec![changed])
608 .is_err());
609 assert!(keys
610 .snapshot()
611 .active_signing_pair(CompositePairRole::OAuth)
612 .is_none());
613 }
614 assert!(keys
615 .attach_committed_signing_keys(2, "generation-1", vec![signing.clone()])
616 .is_err());
617 assert!(keys
618 .attach_committed_signing_keys(1, "changed-digest", vec![signing.clone()])
619 .is_err());
620 keys.attach_committed_signing_keys(1, "generation-1", vec![signing.clone()])
621 .unwrap();
622 let restored = keys.mint_snapshot().unwrap();
623 assert_eq!(restored.version(), 1);
624 assert_eq!(restored.component_digest(), "generation-1");
625 assert!(verify(
626 &mint(
627 restored
628 .active_signing_pair(CompositePairRole::OAuth)
629 .unwrap()
630 ),
631 &restored
632 ));
633 keys.attach_committed_signing_keys(1, "generation-1", vec![verifying])
635 .unwrap();
636 assert!(keys
637 .snapshot()
638 .active_signing_pair(CompositePairRole::OAuth)
639 .is_some());
640 assert!(keys
641 .publish(1, "generation-1".into(), vec![signing.clone()])
642 .is_err());
643
644 let observed = keys.mint_snapshot().unwrap();
646 keys.publish(2, "generation-2".into(), vec![pair(44)])
647 .unwrap();
648 assert!(keys
649 .attach_signing_keys_to_snapshot(&observed, 1, "generation-1", vec![signing.clone()])
650 .is_err());
651 assert_eq!(keys.snapshot().version(), 2);
652 assert!(
653 keys.attach_committed_signing_keys(2, "generation-2", vec![signing])
654 .is_err(),
655 "memory ahead of committed disk gained a signer"
656 );
657 std::fs::remove_dir_all(dir).unwrap();
658 }
659
660 #[test]
661 fn mint_snapshot_fails_closed_for_missing_pending_and_stale_authority() {
662 let dir =
663 std::env::temp_dir().join(format!("hyprstream-composite-{}", uuid::Uuid::new_v4()));
664 std::fs::create_dir_all(&dir).unwrap();
665 let ledger = dir.join("ledger.json");
666 let committed = dir.join("committed");
667 let committed_ledger_prefix = dir.join("committed-ledger");
668 let keys = CompositeKeySet::default();
669 keys.configure_authority(
670 ledger.clone(),
671 committed.clone(),
672 committed_ledger_prefix.clone(),
673 dir.join("lock"),
674 );
675 keys.publish(1, "generation-1".into(), vec![pair(9)])
676 .unwrap();
677 assert!(keys.mint_snapshot().is_err());
678 std::fs::write(
679 &ledger,
680 br#"{"version":2,"component_digest":"generation-2"}"#,
681 )
682 .unwrap();
683 std::fs::write(
684 &committed,
685 br#"{"version":1,"component_digest":"generation-1"}"#,
686 )
687 .unwrap();
688 assert!(
689 keys.mint_snapshot().is_err(),
690 "legacy fallback accepted a pending mutable ledger"
691 );
692 std::fs::write(
693 dir.join("committed-ledger-1-generation-1.json"),
694 br#"{"version":1,"component_digest":"generation-1"}"#,
695 )
696 .unwrap();
697 assert_eq!(
698 keys.mint_snapshot().unwrap().version(),
699 1,
700 "pending mutable authority displaced the last committed snapshot"
701 );
702 std::fs::write(
703 &committed,
704 br#"{"version":2,"component_digest":"generation-2"}"#,
705 )
706 .unwrap();
707 assert!(keys.mint_snapshot().is_err(), "stale cache minted");
708 std::fs::write(
709 dir.join("committed-ledger-2-generation-2.json"),
710 br#"{"version":2,"component_digest":"generation-2"}"#,
711 )
712 .unwrap();
713 keys.publish(2, "generation-2".into(), vec![pair(10)])
714 .unwrap();
715 assert_eq!(keys.mint_snapshot().unwrap().version(), 2);
716 std::fs::remove_dir_all(dir).unwrap();
717 }
718}