diff --git a/README.md b/README.md index 3efacd5..137ff0c 100644 --- a/README.md +++ b/README.md @@ -131,6 +131,7 @@ Implemented and verified against the Go peer, byte for byte: | Monitoring response structures (`kt-wire::responses`) | §13.2–§13.4 | [`monitor.json`](interop/vectors/monitor.json) — contact, owner init, owner monitor | | Contact monitoring (`kt-tree::combined`) | §8.2, §12.3.4 | [`monitor.json`](interop/vectors/monitor.json) — 4 replayed, each consuming its proof exactly | | Owner initialization (`kt-tree::combined`) | §8.3, §12.3.5 | [`monitor.json`](interop/vectors/monitor.json) — replayed, consuming its proof exactly | +| Owner monitoring (`kt-tree::combined`) | §8.3, §12.3.6 | [`monitor.json`](interop/vectors/monitor.json) — replayed to exhaustion, §8.2 and §8.3 composed | **Refusing what the peer refuses.** [`tampered.json`](interop/vectors/tampered.json) holds 18 proofs and openings that @@ -198,7 +199,7 @@ against regression, not a target: what it mostly bought was covering every error type's `Display` — the text a verifier emits when it rejects something — which turned up one real inconsistency, a wrapped error that did not chain to its cause. -Interop work has turned up three bugs in the Go peer and nine gaps or ambiguities in +Interop work has turned up three bugs in the Go peer and ten gaps or ambiguities in the draft, one of them filed upstream because it cannot be settled from either source. Each is written up and given a stable identifier in [`docs/interop.md`](docs/interop.md), whose findings register is the tracker — nothing is filed upstream, by decision, and every entry is pinned by a committed vector so a filing diff --git a/crates/kt-tree/src/combined.rs b/crates/kt-tree/src/combined.rs index 608875d..5e6ce5a 100644 --- a/crates/kt-tree/src/combined.rs +++ b/crates/kt-tree/src/combined.rs @@ -361,6 +361,19 @@ impl<'a> Reader<'a> { .collect() } + /// Whether every element has been read. + /// + /// Needed by exactly one algorithm. §8.3's second algorithm says at step 4 that "the only stop + /// condition" from a user's perspective "is having consumed all of the Transparency Log's + /// response" — so there, running out of proof is a legitimate outcome rather than an error. It + /// is the one place in the protocol where the element count decides when the algorithm stops, + /// instead of the algorithm deciding what the element count should be. + #[must_use] + pub fn is_exhausted(&self) -> bool { + self.timestamps_used >= self.proof.timestamps.len() + && self.proofs_used >= self.proof.prefix_proofs.len() + } + /// Finishes reading, requiring that nothing was left over (§12.3). /// /// # Errors @@ -2882,6 +2895,14 @@ pub enum InitError { Ibst(ibst::Error), /// A ladder could not be computed. Ladder(ladder::Error), + /// Distinguishedness could not be decided from the timestamps available. + Distinguished(distinguished::Error), +} + +impl From for InitError { + fn from(err: distinguished::Error) -> Self { + Self::Distinguished(err) + } } impl From for InitError { @@ -2973,6 +2994,7 @@ impl core::fmt::Display for InitError { Self::Prefix(err) => write!(f, "evaluating a prefix tree proof: {err}"), Self::Ibst(err) => write!(f, "walking the search tree: {err}"), Self::Ladder(err) => write!(f, "computing a binary ladder: {err}"), + Self::Distinguished(err) => write!(f, "deciding distinguishedness: {err}"), } } } @@ -2984,6 +3006,7 @@ impl core::error::Error for InitError { Self::Prefix(err) => Some(err), Self::Ibst(err) => Some(err), Self::Ladder(err) => Some(err), + Self::Distinguished(err) => Some(err), _ => None, } } @@ -3271,3 +3294,547 @@ mod init_tests { assert!(core::error::Error::source(&errors[0]).is_none()); } } + +/// What owner monitoring established (§8.3's second algorithm). +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct OwnerMonitored { + /// The distinguished entries whose ladders were checked, in the order the walk reached them. + pub checked: Vec<(u64, HashValue)>, + /// The rightmost entry the walk got to before the proof ran out. + /// + /// §8.3 expects users to "repeatedly query the Transparency Log until they detect that the + /// above algorithm has either hit an unresolvable error or successfully reached the rightmost + /// distinguished log entry", so this is what the next request starts from. + pub reached: Option, +} + +/// Runs §8.3's second algorithm: an owner checking the recent distinguished entries. +/// +/// This is the only algorithm in the protocol whose stopping point is decided by the *proof* +/// rather than by the algorithm. Step 4 says the user's "only stop condition is having consumed +/// all of the Transparency Log's response" — the log is allowed to truncate, because §8.3 tells it +/// to limit how many entries it covers per response, and the user simply asks again. So exhaustion +/// is a legitimate outcome here, and only at step 4: running out anywhere else means the log sent +/// a proof that does not match its own shape. +/// +/// One consequence worth knowing: §12.3's exact-count rule cannot police this algorithm's reading +/// the way it polices the others. Where a search either consumes everything or reveals a +/// misreading, an owner monitor consumes until empty by construction. What still catches a +/// misreading is the ladders themselves — an element attributed to the wrong entry evaluates to a +/// prefix tree root that entry never had. +/// +/// `start` is the rightmost distinguished entry the owner has already verified. `expected` gives +/// the greatest version the owner believes existed as of a given log entry — *not* one global +/// version. §8.3 step 5 says the ladder targets "the greatest version of the label expected to +/// exist at this point according to the label owner's local state", and an owner has that state +/// because it created the versions itself: it knows which entry each one went into. Using the +/// global greatest everywhere gives ladders of the wrong length at every entry before the last, +/// since §5's series depends on its target. +/// +/// # Errors +/// +/// [`InitError`], shared with owner initialization: the two algorithms check the same things about +/// a ladder, and distinguishing their errors would be a distinction without a difference. +pub fn owner_monitor( + suite: CipherSuite, + size: u64, + window: u64, + start: u64, + expected: &impl Fn(u64) -> u32, + keys: &BTreeMap, + reader: &mut Reader<'_>, +) -> core::result::Result { + let last = size.saturating_sub(1); + let rightmost = reader.timestamp(last)?; + let mut checked = Vec::new(); + let mut reached = None; + let root = ibst::root(size)?; + owner_monitor_at( + suite, + size, + window, + start, + expected, + keys, + reader, + root, + (0, 0), + (last, rightmost), + &mut checked, + &mut reached, + )?; + Ok(OwnerMonitored { checked, reached }) +} + +/// §8.3's second algorithm at one log entry, recursing as its steps direct. +#[allow( + clippy::too_many_arguments, + reason = "the recursion's own state: the tree, the log's parameters, the owner's position, \ + the §6.1 brackets, and the two accumulators. Bundling them would obscure which \ + parameter each numbered step reads" +)] +fn owner_monitor_at( + suite: CipherSuite, + size: u64, + window: u64, + start: u64, + expected: &impl Fn(u64) -> u32, + keys: &BTreeMap, + reader: &mut Reader<'_>, + current: u64, + left: (u64, u64), + right: (u64, u64), + checked: &mut Vec<(u64, HashValue)>, + reached: &mut Option, +) -> core::result::Result<(), InitError> { + // Step 1. Only distinguished entries are checked here — §8.3 says as much, and points out that + // this is why an owner runs §8.2 alongside: between two reference points, only contact + // monitoring notices anything. + if !distinguished::is_distinguished(window, left, right)? { + return Ok(()); + } + + // Step 2: entries at or before what the owner has already verified need no further checking, + // but the walk still has to get past them to reach the ones that do. + if current <= start { + if let Ok(child) = ibst::right(current, size) { + let timestamp = reader.timestamp(current)?; + owner_monitor_at( + suite, + size, + window, + start, + expected, + keys, + reader, + child, + (current, timestamp), + right, + checked, + reached, + )?; + } + return Ok(()); + } + + // Step 3: the left subtree first, so the walk covers the older distinguished entries before + // the newer ones — which is what lets the log truncate at step 4 and the user resume. + if !ibst::is_leaf(current) { + let child = ibst::left(current)?; + let timestamp = reader.timestamp(current)?; + owner_monitor_at( + suite, + size, + window, + start, + expected, + keys, + reader, + child, + left, + (current, timestamp), + checked, + reached, + )?; + } + + // Step 4: the stop condition. For a user it is exhaustion, and nothing else. + if reader.is_exhausted() { + return Ok(()); + } + + // Step 5. The entry's own timestamp comes first, and §12.3.6 does not say so: it lists "the + // timestamp for each log entry that causes the algorithm to recurse" and, separately, a proof + // for each entry reaching step 5. But an entry with a proof and no timestamp cannot be placed + // in the log tree at all — §11.8's leaf is the hash of a timestamp *and* a prefix tree root, + // and §12.3 ties `inclusion` to "all leaf nodes whose timestamp was provided". Compare + // §12.3.3, which lists both for every entry a fixed-version search touches. Measured against + // the peer: it sends them, in this position. Recorded as `DRAFT-10`. + reader.timestamp(current)?; + + // A full ladder for the version the owner expects to be greatest *here*. + let greatest = expected(current); + let versions = ladder::search_binary_ladder(greatest, greatest, &[], &[])?; + let proof = reader.prefix_proof(current)?; + let used = versions + .get(..proof.results.len()) + .ok_or(InitError::LadderLength { + position: current, + expected: versions.len(), + actual: proof.results.len(), + })?; + let ordering = ladder::interpret_search_ladder(used, greatest, &proof.results)?; + if ordering != core::cmp::Ordering::Equal { + return Err(InitError::LadderInconsistent { + position: current, + claimed: greatest, + exists: true, + }); + } + let mut entries = Vec::new(); + for (version, result) in used.iter().zip(proof.results.iter()) { + let key = keys.get(version).ok_or(InitError::MissingLadderKey { + position: current, + version: *version, + })?; + entries.push(if result.is_inclusion() { + prefix::SearchEntry::included( + key.vrf_output, + key.commitment.ok_or(InitError::MissingCommitment { + position: current, + version: *version, + })?, + ) + } else { + prefix::SearchEntry::absent(key.vrf_output) + }); + } + let root = prefix::evaluate(suite, &entries, proof)?; + reader.establish_root(current, root)?; + checked.push((current, root)); + *reached = Some(current); + + // Step 6. + if let Ok(child) = ibst::right(current, size) { + let timestamp = reader.timestamp(current)?; + owner_monitor_at( + suite, + size, + window, + start, + expected, + keys, + reader, + child, + (current, timestamp), + right, + checked, + reached, + )?; + } + Ok(()) +} + +#[cfg(test)] +#[allow( + clippy::arithmetic_side_effects, + clippy::indexing_slicing, + clippy::panic, + clippy::unwrap_used, + reason = "tests fail loudly by panicking; the lints protect the library paths" +)] +mod owner_monitor_tests { + use super::search_tests::{commitment_for, key_for, tree_at}; + use super::*; + use kt_wire::proofs::InclusionProof; + + const SUITE: CipherSuite = CipherSuite::Kt128Sha256Ed25519; + + /// Everything an owner holds after initialization: its own versions, and every version a + /// search ladder for any of them reaches — including ones that never existed, which is why + /// those have no commitment. + fn owner_keys(greatest: u32) -> BTreeMap { + let mut keys = BTreeMap::new(); + for version in 0..=greatest { + for rung in ladder::search_binary_ladder(version, version, &[], &[]).unwrap() { + keys.entry(rung).or_insert(LadderKey { + vrf_output: key_for(rung), + commitment: (rung <= greatest).then(|| commitment_for(rung)), + }); + } + } + keys + } + + /// Entries far enough apart that a small window makes most of them distinguished, which is the + /// only shape where §8.3's walk reaches step 5 at all. + fn spaced(size: u64) -> Vec { + (0..size).map(|i| 1_700_000_000_000 + i * 100).collect() + } + + /// Builds the proof for §8.3's walk, in §12.3.6's order plus the step-5 timestamps §12.3.6 + /// omits (see `DRAFT-10`). `limit` caps how many ladders the log includes, which is the + /// truncation §8.3 permits. + fn build_walk( + size: u64, + window: u64, + start: u64, + expected: &impl Fn(u64) -> u32, + stamps: &[u64], + limit: usize, + ) -> CombinedTreeProof { + let last = size - 1; + let mut timestamps: Vec = Vec::new(); + let mut seen: Vec = Vec::new(); + let mut proofs = Vec::new(); + let mut proved: Vec = Vec::new(); + + // The view update first, as every operation does. + for entry in ibst::frontier(size).unwrap() { + if !seen.contains(&entry) { + timestamps.push(stamps[entry as usize]); + seen.push(entry); + } + } + + #[allow( + clippy::too_many_arguments, + reason = "the walk's own state, mirroring the library recursion it builds proofs for" + )] + fn walk( + size: u64, + window: u64, + start: u64, + expected: &impl Fn(u64) -> u32, + stamps: &[u64], + limit: usize, + current: u64, + left: (u64, u64), + right: (u64, u64), + timestamps: &mut Vec, + seen: &mut Vec, + proofs: &mut Vec, + proved: &mut Vec, + ) { + if !distinguished::is_distinguished(window, left, right).unwrap() { + return; + } + let push = |entry: u64, timestamps: &mut Vec, seen: &mut Vec| { + if !seen.contains(&entry) { + timestamps.push(stamps[entry as usize]); + seen.push(entry); + } + }; + if current <= start { + if let Ok(child) = ibst::right(current, size) { + push(current, timestamps, seen); + walk( + size, + window, + start, + expected, + stamps, + limit, + child, + (current, stamps[current as usize]), + right, + timestamps, + seen, + proofs, + proved, + ); + } + return; + } + if !ibst::is_leaf(current) { + let child = ibst::left(current).unwrap(); + push(current, timestamps, seen); + walk( + size, + window, + start, + expected, + stamps, + limit, + child, + left, + (current, stamps[current as usize]), + timestamps, + seen, + proofs, + proved, + ); + } + if proofs.len() >= limit { + // The log has sent as much as it intends to; §8.3 lets it stop here. + return; + } + push(current, timestamps, seen); + let target = expected(current); + let versions = ladder::search_binary_ladder(target, target, &[], &[]).unwrap(); + let searches: Vec = versions.iter().map(|v| key_for(*v)).collect(); + proofs.push(tree_at(current).prove(SUITE, &searches).unwrap()); + proved.push(current); + if let Ok(child) = ibst::right(current, size) { + push(current, timestamps, seen); + walk( + size, + window, + start, + expected, + stamps, + limit, + child, + (current, stamps[current as usize]), + right, + timestamps, + seen, + proofs, + proved, + ); + } + } + + walk( + size, + window, + start, + expected, + stamps, + limit, + ibst::root(size).unwrap(), + (0, 0), + (last, stamps[last as usize]), + &mut timestamps, + &mut seen, + &mut proofs, + &mut proved, + ); + + let mut owed: Vec = seen + .iter() + .copied() + .filter(|entry| !proved.contains(entry)) + .collect(); + owed.sort_unstable(); + let prefix_roots = owed + .iter() + .map(|entry| tree_at(*entry).root(SUITE)) + .collect(); + + CombinedTreeProof { + timestamps, + prefix_proofs: proofs, + prefix_roots, + inclusion: InclusionProof::new(Vec::new()), + } + } + + /// The whole walk, checking a ladder at every distinguished entry past the owner's start. + #[test] + fn an_owner_walks_the_distinguished_entries() { + let size = 7_u64; + let window = 50_u64; + let start = 1_u64; + let stamps = spaced(size); + let expected = |entry: u64| u32::try_from(entry).unwrap_or(6).min(6); + let proof = build_walk(size, window, start, &expected, &stamps, usize::MAX); + assert!( + proof.prefix_proofs.len() > 1, + "the walk should reach several entries" + ); + + let retained = Retained::none(); + let mut reader = Reader::new(&proof, &retained); + for entry in ibst::frontier(size).unwrap() { + reader.timestamp(entry).unwrap(); + } + let monitored = owner_monitor( + SUITE, + size, + window, + start, + &expected, + &owner_keys(6), + &mut reader, + ) + .unwrap(); + assert_eq!(monitored.checked.len(), proof.prefix_proofs.len()); + for (position, root) in &monitored.checked { + assert_eq!(*root, tree_at(*position).root(SUITE), "entry {position}"); + } + for position in reader.entries_owed_roots() { + reader.prefix_root(position).unwrap(); + } + reader.finish().unwrap(); + } + + /// §8.3 lets the log truncate: "the Transparency Log SHOULD limit the number of distinguished + /// log entries that it provides binary ladders for in a single response", and step 4 makes + /// exhaustion the user's stop condition. So a short proof is a valid answer, not an error — + /// the user just asks again from where it got to. + #[test] + fn a_truncated_response_is_an_answer_not_an_error() { + let size = 7_u64; + let window = 50_u64; + let start = 1_u64; + let stamps = spaced(size); + let expected = |entry: u64| u32::try_from(entry).unwrap_or(6).min(6); + let full = build_walk(size, window, start, &expected, &stamps, usize::MAX); + let short = build_walk(size, window, start, &expected, &stamps, 2); + assert!(short.prefix_proofs.len() < full.prefix_proofs.len()); + + let retained = Retained::none(); + let mut reader = Reader::new(&short, &retained); + for entry in ibst::frontier(size).unwrap() { + reader.timestamp(entry).unwrap(); + } + let monitored = owner_monitor( + SUITE, + size, + window, + start, + &expected, + &owner_keys(6), + &mut reader, + ) + .unwrap(); + assert_eq!(monitored.checked.len(), 2); + assert!(monitored.reached.is_some(), "the walk got somewhere"); + for position in reader.entries_owed_roots() { + reader.prefix_root(position).unwrap(); + } + reader.finish().unwrap(); + } + + /// A ladder that does not place the expected version as the greatest. For an owner this is the + /// alarm: someone else has created a version of a label the owner controls. + #[test] + fn a_ladder_inconsistent_with_the_owners_state_is_refused() { + let size = 7_u64; + let window = 50_u64; + let start = 1_u64; + let stamps = spaced(size); + let honest = |entry: u64| u32::try_from(entry).unwrap_or(6).min(6); + let proof = build_walk(size, window, start, &honest, &stamps, usize::MAX); + + // The owner believes version 0 is the greatest everywhere, so every ladder the log built + // for a later version now disagrees with its state. + let stale = |_: u64| 0_u32; + let retained = Retained::none(); + let mut reader = Reader::new(&proof, &retained); + for entry in ibst::frontier(size).unwrap() { + reader.timestamp(entry).unwrap(); + } + let refused = owner_monitor( + SUITE, + size, + window, + start, + &stale, + &owner_keys(6), + &mut reader, + ); + // Which refusal depends on how far the two states have diverged: a ladder for a much + // smaller version is *shorter*, so the mismatch surfaces as a length disagreement before + // the interpretation is even reached. Both are the same finding — the log's ladders do not + // describe the history the owner believes in — so the test accepts either. + assert!( + matches!( + refused, + Err(InitError::LadderInconsistent { .. }) + | Err(InitError::LadderLength { .. }) + | Err(InitError::Ladder(_)) + ), + "expected a refusal, got {refused:?}" + ); + } + + #[test] + fn the_distinguished_error_is_reported() { + use alloc::string::ToString; + let wrapped = InitError::from(distinguished::Error::NonMonotonic { left: 1, right: 2 }); + assert!(!wrapped.to_string().is_empty()); + assert!(core::error::Error::source(&wrapped).is_some()); + } +} diff --git a/docs/interop.md b/docs/interop.md index 6ceed4b..ed254ca 100644 --- a/docs/interop.md +++ b/docs/interop.md @@ -112,7 +112,7 @@ disagrees: Steps 1 through 6 are done, step 7 apart from the combined tree, step 9, and §6.1 out of step 8. -Eighteen vector files pass from the Rust side — 6697 checks across 787 cases — and +Eighteen vector files pass from the Rust side — 6706 checks across 789 cases — and `from-kt.json` runs the other way: 209 artifacts built by the Rust side, 109 of which katie must accept and 100 of which it must reject. "Agrees" here means a committed vector asserts it, not that the two implementations were eyeballed. @@ -181,6 +181,29 @@ visits. It does not have to. §6.1 brackets a node by the timestamps of the entr of it in the search tree, and a descent maintains exactly those bounds as it goes — so distinguishedness along a search path is decidable from the path itself. +### The one algorithm the proof stops rather than the algorithm stopping the proof + +§8.3's second algorithm inverts the relationship every other operation has with its proof. Step 4 +says the user's "only stop condition is having consumed all of the Transparency Log's response" — +because §8.3 tells the log to limit how many distinguished entries it covers, and the user simply +asks again. So the element count decides when the walk stops, rather than the walk deciding what +the element count should be. + +That costs the verification technique its teeth. Everywhere else, §12.3's exact-count rule turns a +misreading of the ordering into a leftover element; here the walk consumes whatever it is given by +construction. What still catches a misreading is the ladders: an element attributed to the wrong +entry evaluates to a prefix tree root that entry never had. The check is recorded as reading "to +exhaustion" rather than "exactly" so the page does not overstate what it establishes. + +Two things had to be right before the recorded case would replay, and neither is in §8.3's text +where a reader would look for it. The step 5 ladder targets "the greatest version expected to exist +at this point according to the label owner's local state" — *per entry*, from the owner's own record +of when it created each version, not one global greatest; using the global version gives ladders of +the wrong length at every entry but the last. And the owner needs VRF outputs for versions that +have never existed, because a ladder for version 3 reaches for version 7: §8.3 step 3 supplies +exactly that set during initialization, and a client retains it. The second was nearly filed as a +gap before finding the sentence that covers it. + ### An owner looks backwards, everyone else looks forward §8.3's first algorithm is the one operation that walks *left*. A searcher descends toward a @@ -617,6 +640,21 @@ versions. Measured against katie: for a seven-entry log with greatest version 6, either implementation — but the draft never says the results are a prefix, and it is the first thing an implementer gets wrong. +**[DRAFT-10] §12.3.6 omits the timestamps without which its own proof cannot be rooted.** For +owner monitoring it lists "the timestamp for each log entry that causes the second algorithm of +§8.3 to recurse either left or right" and, separately, "for each log entry that reaches step 5, a +`PrefixProof`". An entry that reaches step 5 without causing a recursion therefore gets a proof +and no timestamp — and cannot be placed in the log tree at all, because §11.8's leaf is the hash +of a timestamp *and* a prefix tree root, and §12.3 ties `inclusion` to "the values of all leaf +nodes whose timestamp was provided in `timestamps`". Compare §12.3.3, which for a fixed-version +search lists both the timestamp and the proof for every entry the algorithm touches. + +Resolved by measurement rather than filed: the peer sends those timestamps, immediately before +the entry's ladder, and a verifier that expects them consumes the proof exactly. Pinned by +`monitor.json`'s `owner-monitor-reaches-step-5` case, which is the only recorded case where an +entry reaches step 5 without recursing. Worth an editorial issue if the register is ever filed — +an implementer following §12.3.6 literally builds a proof that no client can root. + **[NOTE-03] `opening` sits in a different place in the two implementations.** The draft puts `opaque opening[Nc]` inside `CommitmentValue`; katie keeps it outside the struct and writes it to the HMAC first. Same bytes, different factoring — the vectors @@ -690,7 +728,8 @@ courtesy rather than a necessity. | `DRAFT-08` | §6.3 cannot verify the response that means "this label does not exist" | draft | `search.json` `label-does-not-exist` | tracked locally | | `NOTE-01` | katie's search ladder is target-indexed, Appendix B's greatest-indexed — equivalent | neither | generator's 131×131 grid; Rust tests | no action | | `NOTE-04` | a per-entry ladder's results are a *prefix* of the verifier's ladder, because the log stops on the local greatest version | neither | `search.json`, all five greatest-version cases | no action | -| `DRAFT-09` | Nothing says when a monitoring ladder deduplicates against `left_inclusion`; the two readings fail against each other | draft | `monitor.json`, three §8.2 replays under the empty-set reading | **filed**: [draft-protocol#48](https://github.com/ietf-wg-keytrans/draft-protocol/issues/48) | +| `DRAFT-09` | Nothing says when a monitoring ladder deduplicates against `left_inclusion`; the two readings fail against each other | draft | `monitor.json`, §8.2 replays under the empty-set reading | **filed**: [draft-protocol#48](https://github.com/ietf-wg-keytrans/draft-protocol/issues/48) | +| `DRAFT-10` | §12.3.6 omits the timestamp of an entry that reaches step 5 without recursing, so its own proof cannot be rooted | draft | `monitor.json` `owner-monitor-reaches-step-5` | tracked locally; resolved by measurement | | `NOTE-03` | `opening` sits inside `CommitmentValue` in the draft, outside it in katie | neither | `commitment.json` records both | no action | Two ground rules for anything added here. A finding is only a finding once a committed diff --git a/interop/go/cmd/gen/monitor.go b/interop/go/cmd/gen/monitor.go index edd0541..680c34c 100644 --- a/interop/go/cmd/gen/monitor.go +++ b/interop/go/cmd/gen/monitor.go @@ -29,12 +29,15 @@ import ( "context" "encoding/hex" "fmt" + "sort" + "time" "github.com/Bren2010/katie/crypto/commitments" "github.com/Bren2010/katie/crypto/suites" "github.com/Bren2010/katie/crypto/vrf" "github.com/Bren2010/katie/crypto/vrf/edwards25519" "github.com/Bren2010/katie/tree/transparency" + "github.com/Bren2010/katie/tree/transparency/math" "github.com/Bren2010/katie/tree/transparency/structs" ) @@ -139,7 +142,8 @@ func monitorVectors(sha string) (*File, error) { if err != nil { return nil, fmt.Errorf("case %q: parsing the VRF key: %w", spec.name, err) } - known, kerr := knownVersions(cs, tree, vrfPrivate, []byte(spec.label), spec.entries) + known, kerr := knownVersions( + cs, tree, vrfPrivate, []byte(spec.label), spec.entries, spec.greatestVersion) if kerr != nil { return nil, fmt.Errorf("case %q: %w", spec.name, kerr) } @@ -222,6 +226,13 @@ func monitorCases() []monitorCase { }, } + // The same log, with the entries spaced out in real time and a window small enough that most + // of them are distinguished. §7.1 requires a maximum lifetime to exceed the window; there is + // none here, so only the window matters. + spaced := growing + spaced.window = 50 + spaced.spacing = 100 * time.Millisecond + return []monitorCase{ { name: "contact-one-version", @@ -244,6 +255,17 @@ func monitorCases() []monitorCase { label: alice, entries: []mapEntry{{position: 2, version: 2}}, }, + { + // The same spaced log the owner-monitor case uses, so a pure contact monitor over a + // map entry that §6.1 makes distinguished can be compared against the composed + // operation. §8.2 step 1 says a distinguished map entry is left alone with no ladder; + // this records what the peer actually sends. + name: "contact-distinguished-map-entry", + operation: "contact", + log: spaced, + label: alice, + entries: []mapEntry{{position: 5, version: 5}}, + }, { name: "contact-two-versions", operation: "contact", @@ -275,6 +297,21 @@ func monitorCases() []monitorCase { start: 3, greatestVersion: ptr(uint32(6)), }, + { + // The shape where §8.3's second algorithm reaches step 5 at all. With a week-long + // window only the root of a seven-entry log is distinguished, so a walk starting at + // the root goes right, finds nothing distinguished, and stops having checked no + // ladders — which is what `owner-monitor` above does. Spacing the entries out and + // shrinking the window makes several entries distinguished, so there are reference + // points to the right of the owner's start for the walk to actually check. + name: "owner-monitor-reaches-step-5", + operation: "owner-monitor", + log: spaced, + label: alice, + entries: []mapEntry{{position: 5, version: 5}}, + start: 1, + greatestVersion: ptr(uint32(6)), + }, } } @@ -291,44 +328,76 @@ func knownVersions( vrfKey vrf.PrivateKey, label []byte, entries []mapEntry, + advertised *uint32, ) ([]map[string]any, error) { + // The greatest version the owner knows of: the largest in its monitoring map, or the one it + // advertises, whichever is larger. An owner monitor targets the advertised version, which can + // be ahead of anything still in the map. greatest := uint32(0) for _, entry := range entries { if entry.version > greatest { greatest = entry.version } } + if advertised != nil && *advertised > greatest { + greatest = *advertised + } - out := make([]map[string]any, 0, int(greatest)+1) + // Every version the owner would hold after initialization: the ones it created, plus every + // version that appears in a search binary ladder for any of them. §8.3 step 3 makes the log + // supply VRF proofs for exactly that set during owner init, and a client retains them — which + // is why an owner monitoring later can check a ladder lookup for a version that has never + // existed, such as the 7 that a ladder for version 3 reaches for. + wanted := make(map[uint32]struct{}) for version := uint32(0); version <= greatest; version++ { + wanted[version] = struct{}{} + for _, rung := range math.SearchBinaryLadder(version, version, nil, nil) { + wanted[rung] = struct{}{} + } + } + versions := make([]uint32, 0, len(wanted)) + for version := range wanted { + versions = append(versions, version) + } + sort.Slice(versions, func(i, j int) bool { return versions[i] < versions[j] }) + + out := make([]map[string]any, 0, len(versions)) + for _, version := range versions { alpha, err := structs.Marshal(&structs.VrfInput{Label: label, Version: version}) if err != nil { return nil, fmt.Errorf("marshalling the VRF input for version %d: %w", version, err) } output, _ := vrfKey.Prove(alpha) - target := version - res, err := tree.Search(context.Background(), &structs.SearchRequest{ - Label: label, - Version: &target, - }) - if err != nil { - return nil, fmt.Errorf("searching for version %d: %w", version, err) - } - commitmentValue, err := structs.Marshal(&structs.CommitmentValue{ - Label: label, - Version: version, - Update: res.Value, - }) - if err != nil { - return nil, fmt.Errorf("marshalling the commitment value for version %d: %w", version, err) - } - out = append(out, map[string]any{ + entry := map[string]any{ "version": version, "vrf_output": hex.EncodeToString(output), - "commitment": hex.EncodeToString( - commitments.Commit(cs, res.Opening, commitmentValue)), - }) + } + // A commitment only where the version exists. §13.3 step 2 makes the same point about + // owner initialization: a VRF proof is provided for versions that do not exist, so that + // their absence can be checked, and there is nothing to commit to. + if version <= greatest { + target := version + res, err := tree.Search(context.Background(), &structs.SearchRequest{ + Label: label, + Version: &target, + }) + if err != nil { + return nil, fmt.Errorf("searching for version %d: %w", version, err) + } + commitmentValue, err := structs.Marshal(&structs.CommitmentValue{ + Label: label, + Version: version, + Update: res.Value, + }) + if err != nil { + return nil, fmt.Errorf( + "marshalling the commitment value for version %d: %w", version, err) + } + entry["commitment"] = hex.EncodeToString( + commitments.Commit(cs, res.Opening, commitmentValue)) + } + out = append(out, entry) } return out, nil } diff --git a/interop/report/src/check.rs b/interop/report/src/check.rs index 5c01bf0..68db222 100644 --- a/interop/report/src/check.rs +++ b/interop/report/src/check.rs @@ -1467,6 +1467,13 @@ fn monitor_suite(dir: &Path) -> Result { replay_contact_monitor(case, &bytes, mode).unwrap_or_else(|detail| detail), )); } + if case.input.operation == "owner-monitor" { + checks.push(Check::new( + "replaying §8.3's second algorithm reads the proof to exhaustion (§12.3.6)", + "the walk ran to the end of the proof", + replay_owner_monitor(case, &bytes, mode).unwrap_or_else(|detail| detail), + )); + } if case.input.operation == "owner-init" { checks.push(Check::new( "replaying §8.3's first algorithm consumes the proof exactly (§12.3.5)", @@ -1537,16 +1544,21 @@ fn replay_contact_monitor( .and_then(|bytes| { HashValue::from_slice(&bytes).map_err(|err| format!("vrf_output: {err}")) })?; - let commitment = hex::decode(&known.commitment) - .map_err(|err| format!("version {}: commitment: {err}", known.version)) - .and_then(|bytes| { - HashValue::from_slice(&bytes).map_err(|err| format!("commitment: {err}")) - })?; + let commitment = match &known.commitment { + None => None, + Some(value) => Some( + hex::decode(value) + .map_err(|err| format!("version {}: commitment: {err}", known.version)) + .and_then(|bytes| { + HashValue::from_slice(&bytes).map_err(|err| format!("commitment: {err}")) + })?, + ), + }; keys.insert( known.version, combined::LadderKey { vrf_output, - commitment: Some(commitment), + commitment, }, ); } @@ -1710,6 +1722,121 @@ fn replay_owner_init( .map_err(|err| format!("§12.3: {err}")) } +/// Replays §8.3's second algorithm over a recorded owner monitoring response. +/// +/// The check here is weaker than for the other algorithms, and says so. §8.3 step 4 makes +/// exhaustion the user's stop condition, so the walk consumes whatever it is given by +/// construction and §12.3's exact-count rule cannot reveal a misreading. What can is the ladders: +/// an element attributed to the wrong entry evaluates to a prefix tree root that entry never had, +/// and the root check catches it. +fn replay_owner_monitor( + case: &crate::vectors::Case, + bytes: &[u8], + mode: DeploymentMode, +) -> Result { + let suite = CipherSuite::Kt128Sha256Ed25519; + let mut dec = Decoder::new(bytes); + let response = OwnerMonitorResponse::decode_with(&mut dec, mode) + .map_err(|err| format!("decode failed: {err}"))?; + + let greatest = case + .input + .greatest_version + .ok_or_else(|| "the request advertised no greatest version".to_owned())?; + + // An owner holds the search keys and commitments for the versions it knows about, exactly as a + // contact monitor does — a monitoring response carries neither. + let mut keys = BTreeMap::new(); + for known in &case.input.known_versions { + let vrf_output = hex::decode(&known.vrf_output) + .map_err(|err| format!("version {}: vrf_output: {err}", known.version)) + .and_then(|bytes| { + HashValue::from_slice(&bytes).map_err(|err| format!("vrf_output: {err}")) + })?; + let commitment = match &known.commitment { + None => None, + Some(value) => Some( + hex::decode(value) + .map_err(|err| format!("version {}: commitment: {err}", known.version)) + .and_then(|bytes| { + HashValue::from_slice(&bytes).map_err(|err| format!("commitment: {err}")) + })?, + ), + }; + keys.insert( + known.version, + combined::LadderKey { + vrf_output, + commitment, + }, + ); + } + + let size = case.expect.tree_size; + let retained = combined::Retained::none(); + let mut reader = combined::Reader::new(&response.monitor, &retained); + for position in ibst::frontier(size).map_err(|err| format!("frontier: {err}"))? { + reader + .timestamp(position) + .map_err(|err| format!("view update at entry {position}: {err}"))?; + } + + // §13.4's proof is §8.2's algorithm followed by §8.3's second, so the contact half runs first + // over the same map the request carried. + let map: Vec = case + .input + .entries + .iter() + .map(|entry| combined::MapEntry { + position: entry.position, + version: entry.version, + }) + .collect(); + combined::contact_monitor( + suite, + size, + case.input.monitoring_window, + &map, + &keys, + &mut reader, + ) + .map_err(|err| format!("§8.2 half: {err}"))?; + + // §8.3 step 5 targets the greatest version the owner expects at each entry, from its own + // record of when it created them. In this log version `v` went in at entry `v`, so an owner + // that knows up to `greatest` expects `min(entry, greatest)` — which is the local state a real + // owner has because it made the updates. + let expected = |entry: u64| { + u32::try_from(entry) + .map(|version| version.min(greatest)) + .unwrap_or(greatest) + }; + let monitored = combined::owner_monitor( + suite, + size, + case.input.monitoring_window, + case.input.start, + &expected, + &keys, + &mut reader, + ) + .map_err(|err| format!("§8.3: {err}"))?; + + for position in reader.entries_owed_roots() { + reader + .prefix_root(position) + .map_err(|err| format!("prefix root for entry {position}: {err}"))?; + } + // How far the walk got is reported in the case's description rather than compared: §8.3 lets + // the log truncate, so "reached entry N" is the log's choice of response size, not a claim a + // verifier can check. + let _ = monitored.reached; + reader + .finish() + .map(|()| "the walk ran to the end of the proof".to_owned()) + .map_err(|err| format!("§12.3: {err}")) +} + /// §6.1: which log entries are distinguished. fn distinguished_suite(dir: &Path) -> Result { const FILE: &str = "distinguished.json"; diff --git a/interop/report/src/report.rs b/interop/report/src/report.rs index 61d5fd2..ec9edf2 100644 --- a/interop/report/src/report.rs +++ b/interop/report/src/report.rs @@ -519,9 +519,11 @@ pub fn coverage_table() -> Vec { "kt-tree::combined", &["monitor.json"], ), - todo( + verified( "§8.3 second algorithm, §12.3.6", "Owner monitoring: the recursive walk over recent distinguished entries", + "kt-tree::combined", + &["monitor.json"], ), todo("§9, §13.5", "Updating a label"), todo( diff --git a/interop/report/src/vectors.rs b/interop/report/src/vectors.rs index be1d8a7..313b63a 100644 --- a/interop/report/src/vectors.rs +++ b/interop/report/src/vectors.rs @@ -469,8 +469,10 @@ pub struct KnownVersion { pub version: u32, /// Its VRF output — the prefix tree search key, hex. pub vrf_output: String, - /// The commitment to the label's value at that version, hex. - pub commitment: String, + /// The commitment to the label's value at that version, hex — absent for versions that do not + /// exist, which a ladder still looks up in order to prove their absence. + #[serde(default)] + pub commitment: Option, } /// `monitor.json` expectations. diff --git a/interop/vectors/monitor.json b/interop/vectors/monitor.json index 4e5adf9..e7d880b 100644 --- a/interop/vectors/monitor.json +++ b/interop/vectors/monitor.json @@ -18,44 +18,52 @@ } ], "entry_timestamps": [ - 1785339686380, - 1785339686381, - 1785339686381, - 1785339686381, - 1785339686382, - 1785339686382, - 1785339686382 + 1785340634579, + 1785340634580, + 1785340634580, + 1785340634581, + 1785340634581, + 1785340634582, + 1785340634582 ], "known_versions": [ { - "commitment": "b0336b56fb045047783a5b71de714beba8d2c4b162129e3a71bbafac180d0254", + "commitment": "449255b8c67d5df30eb78b7be416e8f01bb2e1c525de2f8fb89edac345b1a4f9", "version": 0, "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, { - "commitment": "c03037a87d2a278e1d8f4a47e7679103f6c46425ab9d9fe09c977742c9e95b9b", + "commitment": "8289fd49b7903c8019cb4cb6a789e0beb6d16513cc826c4b2ff95653c53ae0a7", "version": 1, "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, { - "commitment": "0f795843644f1f09a03d1bcdef748b47b3fa3833251703579ac3072c34d10a7c", + "commitment": "87513a27fc159ca2fb5c6aafeec6249ecf62939ee40c5d6451848e60c1033d0d", "version": 2, "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" }, { - "commitment": "4a3466829141fceea9643f23d73569a8f4669caeb9d5c1942ac9251fe6efea96", + "commitment": "db30521c01a77530ea45a8af2fee6aa6293b98739dfe901d3dec9603cc5ec5d8", "version": 3, "vrf_output": "ef0582ede742f1d47079dad60b655a3e4bab73d2bf1da0b3d6db7a833f132fee" }, { - "commitment": "1b67c8374aab6e6ba7327d5b9745fd0bbf964aa520eef3c00bebbdff14b84162", + "commitment": "060ef4f0009146c2c369aa728fa21887d6923095545b8bf1e89ebcc1a3b7d78c", "version": 4, "vrf_output": "f9177f084968b05e8b34978d8f50108baad4083600b51f944dc54460e0d850ae" }, { - "commitment": "7a6f96f0dfb01a69434e488314944a563e356ec30de946e33d58320e174faa7e", + "commitment": "6ca5ae2845a5c8d9b9dd2a414acb10354b377a7c76ac1d0465080c1594be6320", "version": 5, "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" + }, + { + "version": 6, + "vrf_output": "599424025a070d0e48913585265a30210ffe3416005c77c2354094f14c6358a1" + }, + { + "version": 7, + "vrf_output": "80e204b5356fa5a4e88a74d22763e8212b9e2882397e69aaf852a7010f23f672" } ], "label": "616c696365406578616d706c652e636f6d", @@ -126,23 +134,23 @@ "vrf_public_key": "555f469c22188e90015bdd85b889678d459f86bdf8f7bd34971b10b9b3858609" }, "expect": { - "full_tree_head": "0200000000000000070040cf32e1d39a3c095aa140b2c9703a1d1ebc49aaca0e5f957563affd1a64df6f3194bcb2711799f836ff7fd8d09a5f513e4bc92fd4ccb5f9d91f300cb6b4f47e07", + "full_tree_head": "0200000000000000070040c9c3deb97798c1a89d1060f7dc7b9d11241232e5942508b43ecf60e4af350f88774287803e213461ac94cf815d64ea41d50d31e1738e5e22fe20cfb246f36301", "inclusion": [ - "048f041915995e643478ecb3d84686b17c6dd80956621b797817a3c26be22ea8", - "6d8d6f155b0db62f8d5551bca2838eee2bb17128bb6d7649a8fb09839d592f48", - "257f69d6f02709f6f9b9ac1c91a303b661c71c680e8717badcbce571c8265dc2" + "76dcca241fe88a97fbcec83b9c5fd52139055eb075cb178489f3647f87cc4595", + "ae9954a130f8372d12011840e85717ecf720700f1b553e5aa0ac3708f80397bd", + "4824510a0c3a3006da71f5780156423f9b4fe766350b3ea9d25e40de622db157" ], "prefix_proofs": [], "prefix_roots": [ - "a9b0f46ac6787ad3d77ada4fea9dce69ea5257dd1d8923ff096bbba73811e7b4", - "f2a26b415ec49f80b69d02cf22efa745eb32486e0f75a05063c6af1a900326db", - "7f534c061b557cbce054dcf225672cac58a82199249b56a193fcb8b58dacb06d" + "f384a311d9e1b0328b95282f865b4e51ecc512caddf21eda19e03fe5d2b7a3f7", + "90927c3422a97428ccf640eabcb5b8adf5835342e9d33285545d3cebc1be7728", + "23161f76dfd4c49312985d710c21d3dd8cfa42281196c607fa060cb65bf74489" ], - "response": "0200000000000000070040cf32e1d39a3c095aa140b2c9703a1d1ebc49aaca0e5f957563affd1a64df6f3194bcb2711799f836ff7fd8d09a5f513e4bc92fd4ccb5f9d91f300cb6b4f47e07030000019fae89aded0000019fae89adee0000019fae89adee0003a9b0f46ac6787ad3d77ada4fea9dce69ea5257dd1d8923ff096bbba73811e7b4f2a26b415ec49f80b69d02cf22efa745eb32486e0f75a05063c6af1a900326db7f534c061b557cbce054dcf225672cac58a82199249b56a193fcb8b58dacb06d0003048f041915995e643478ecb3d84686b17c6dd80956621b797817a3c26be22ea86d8d6f155b0db62f8d5551bca2838eee2bb17128bb6d7649a8fb09839d592f48257f69d6f02709f6f9b9ac1c91a303b661c71c680e8717badcbce571c8265dc2", + "response": "0200000000000000070040c9c3deb97798c1a89d1060f7dc7b9d11241232e5942508b43ecf60e4af350f88774287803e213461ac94cf815d64ea41d50d31e1738e5e22fe20cfb246f36301030000019fae9825d50000019fae9825d60000019fae9825d60003f384a311d9e1b0328b95282f865b4e51ecc512caddf21eda19e03fe5d2b7a3f790927c3422a97428ccf640eabcb5b8adf5835342e9d33285545d3cebc1be772823161f76dfd4c49312985d710c21d3dd8cfa42281196c607fa060cb65bf74489000376dcca241fe88a97fbcec83b9c5fd52139055eb075cb178489f3647f87cc4595ae9954a130f8372d12011840e85717ecf720700f1b553e5aa0ac3708f80397bd4824510a0c3a3006da71f5780156423f9b4fe766350b3ea9d25e40de622db157", "timestamps": [ - 1785339686381, - 1785339686382, - 1785339686382 + 1785340634581, + 1785340634582, + 1785340634582 ], "tree_size": 7 } @@ -157,29 +165,33 @@ } ], "entry_timestamps": [ - 1785339686392, - 1785339686392, - 1785339686392, - 1785339686392, - 1785339686393, - 1785339686393, - 1785339686393 + 1785340634595, + 1785340634595, + 1785340634595, + 1785340634596, + 1785340634596, + 1785340634596, + 1785340634597 ], "known_versions": [ { - "commitment": "505d3528c83a644b96527a94a98bb6dd6987d8e990b84ed2af9f9fbb3ac99844", + "commitment": "51eccdd5bab285820be4d953c590cbcb1cfe7226c7df2e49ae5ee0dcd8513016", "version": 0, "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, { - "commitment": "20e17486b5fc64b41b8a37dcb1289fa856f97c65a24ef433cfe79590961448ad", + "commitment": "700bb7ab4b02cf67af5776d39827daedbbeed19a1687bc0a216cb5dfa5901f78", "version": 1, "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, { - "commitment": "45ce397d587363d1e00dc08808b11415172584da2ea8e04e1b240c72a4c474db", + "commitment": "3133479aa12fbf7261c6cd9dd81535e11a2105a7d013b4036df93dc58235023e", "version": 2, "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" + }, + { + "version": 3, + "vrf_output": "ef0582ede742f1d47079dad60b655a3e4bab73d2bf1da0b3d6db7a833f132fee" } ], "label": "616c696365406578616d706c652e636f6d", @@ -250,19 +262,19 @@ "vrf_public_key": "555f469c22188e90015bdd85b889678d459f86bdf8f7bd34971b10b9b3858609" }, "expect": { - "full_tree_head": "02000000000000000700401a956142b93030e645ee27f30ebe7163d4454350313eccc558125d8f6f8d25570f0e98ef8bdaf4c6af877633e8bbd4bcc45716f5448a89e8e5fb1e6681288e06", + "full_tree_head": "02000000000000000700403d1d331a10a8782003013c0270e5ddd1e90a85427854f12d2892a775c2bb96e695ee7b62b8552cf6d263077dcef4f54f97e9b8e74a920a7e0d09bfffc380fa02", "inclusion": [ - "bc72dffc5fa928ba3cdbd5d23c9ca4ae0fff1a82665b12ead87ba39a5eb9a885", - "3161b271674bd7975e778d64787b5cd76770eedb52b2797493178adc70946719", - "c943bc1787ea6f9981da4bdde06bf41f40f3f089bac14359e9d618c2509c0aed" + "866ae7bc5d76b8192f5e0a9913690341db60d1b05337aac25a60952944968c75", + "656418f1bf5bbeaf8e3c916e412d6829a6dd3f6e9fe3ba17b719ee9f04978863", + "1af18d9fad5faec8b81a7078985e3d34d77c6fb460468811ccc0fdb0c551f7a1" ], "prefix_proofs": [ { "elements": [ "0000000000000000000000000000000000000000000000000000000000000000", - "ebd1aec3e4ba248a6d25375543d327073bfdb3a815c93dc38a8e43b7b3f27f68" + "787f5df75796fd62321e66ace208977cf69546dcd6104dbd05bc10a00a3d5114" ], - "encoding": "0301040102010100020000000000000000000000000000000000000000000000000000000000000000ebd1aec3e4ba248a6d25375543d327073bfdb3a815c93dc38a8e43b7b3f27f68", + "encoding": "0301040102010100020000000000000000000000000000000000000000000000000000000000000000787f5df75796fd62321e66ace208977cf69546dcd6104dbd05bc10a00a3d5114", "results": [ { "depth": 4, @@ -280,16 +292,163 @@ } ], "prefix_roots": [ - "4f9ea91c341733984ec241b620d24d3670bbc6e176de2bf075e22757a6483920", - "77dd41fd1f9ad83d537c8bfa0bce8b1068bc950f9a0b1b343d516b7d4f9b8d5a", - "b1518f6b7d14c2a97633949766af2d6b4c97f884356e97a76bc3a65ccbbaf456" + "b3fcc3d9d732501853b3831a40a3e30b5dd26bc06b7c6ef5693e50fc663efaee", + "ff094e927d4b849ecd158be4d10cba21bfa639dbf2c04674bfe7c444871a4dec", + "f71f1e353f44856f4b55d761e91b4c726095a28209e31b58a56683a269bd3dbd" + ], + "response": "02000000000000000700403d1d331a10a8782003013c0270e5ddd1e90a85427854f12d2892a775c2bb96e695ee7b62b8552cf6d263077dcef4f54f97e9b8e74a920a7e0d09bfffc380fa02040000019fae9825e40000019fae9825e40000019fae9825e50000019fae9825e3010301040102010100020000000000000000000000000000000000000000000000000000000000000000787f5df75796fd62321e66ace208977cf69546dcd6104dbd05bc10a00a3d511403b3fcc3d9d732501853b3831a40a3e30b5dd26bc06b7c6ef5693e50fc663efaeeff094e927d4b849ecd158be4d10cba21bfa639dbf2c04674bfe7c444871a4decf71f1e353f44856f4b55d761e91b4c726095a28209e31b58a56683a269bd3dbd0003866ae7bc5d76b8192f5e0a9913690341db60d1b05337aac25a60952944968c75656418f1bf5bbeaf8e3c916e412d6829a6dd3f6e9fe3ba17b719ee9f049788631af18d9fad5faec8b81a7078985e3d34d77c6fb460468811ccc0fdb0c551f7a1", + "timestamps": [ + 1785340634596, + 1785340634596, + 1785340634597, + 1785340634595 + ], + "tree_size": 7 + } + }, + { + "name": "contact-distinguished-map-entry", + "input": { + "entries": [ + { + "position": 5, + "version": 5 + } + ], + "entry_timestamps": [ + 1785340634602, + 1785340634703, + 1785340634804, + 1785340634906, + 1785340635007, + 1785340635109, + 1785340635211 + ], + "known_versions": [ + { + "commitment": "ed0442e8f52dd96d69f729e65db3f7df799a9976481f558121ac842c682cbcc4", + "version": 0, + "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" + }, + { + "commitment": "ad85c73fa0980b476fb30806e8032faaed64706769b96a5068789ad300a333de", + "version": 1, + "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" + }, + { + "commitment": "80da5631a4687fdfe8c66840de9d527cdbcf70edd9de0c2d99e19524ab34c4d4", + "version": 2, + "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" + }, + { + "commitment": "1995f4ade0c13d5097fb7acece47c24ce259df4c0e33d6eca2b84fd013bc25e1", + "version": 3, + "vrf_output": "ef0582ede742f1d47079dad60b655a3e4bab73d2bf1da0b3d6db7a833f132fee" + }, + { + "commitment": "d8322879d64543c73e0702a7de4940f1cf5b1fc80ba5972dba0e6537b9156898", + "version": 4, + "vrf_output": "f9177f084968b05e8b34978d8f50108baad4083600b51f944dc54460e0d850ae" + }, + { + "commitment": "d229f4f9c18a75af0a5da805e383e633d19356a2ada51d225b7d1cff450de279", + "version": 5, + "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" + }, + { + "version": 6, + "vrf_output": "599424025a070d0e48913585265a30210ffe3416005c77c2354094f14c6358a1" + }, + { + "version": 7, + "vrf_output": "80e204b5356fa5a4e88a74d22763e8212b9e2882397e69aaf852a7010f23f672" + } + ], + "label": "616c696365406578616d706c652e636f6d", + "maximum_lifetime": 0, + "mode": 1, + "monitoring_window": 50, + "mutations": [ + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d31" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d32" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d33" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d34" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d35" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d36" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d37" + } + ] + } + ], + "operation": "contact", + "signature_public_key": "e2fe2a39b7326642827d6d82d497622cd6c297fe78270eaa436b01f086b6f3cb", + "start": 0, + "vrf_public_key": "555f469c22188e90015bdd85b889678d459f86bdf8f7bd34971b10b9b3858609" + }, + "expect": { + "full_tree_head": "020000000000000007004011c9b9b9054570a06107e6412a39eb15c4c54f487587ff9c833fd46fd0de50bdbcd26b8af329428e36ef53a79f8645c93df88107fa04ef231a79f94bebe5c000", + "inclusion": [ + "67f15be88056757515ba06cdcf67bc835fdf758d06932539b04d0e4d4b4576da", + "62879dd252e1e60775e6d57c80e04ad07c5201a62cd609a9d5cbc48f6198e2db", + "78f223cbd4da7b8d72ddd3ec3e1a1e2cbc4f4fe6c75b36127bce9c7ffb5dd7d6" + ], + "prefix_proofs": [], + "prefix_roots": [ + "9f4a50ba010f545918f5592c790786767f78219ff430a867eb538cc8444e72b3", + "0791e4af854e3e8efc43ebed690eb0a7bb9bf9d469fd808126962c0910346d7a", + "1ed3c37e3ac2ed9038800fde8b7441d9f82864c438408bf91823f8a50c281d6c" ], - "response": "02000000000000000700401a956142b93030e645ee27f30ebe7163d4454350313eccc558125d8f6f8d25570f0e98ef8bdaf4c6af877633e8bbd4bcc45716f5448a89e8e5fb1e6681288e06040000019fae89adf80000019fae89adf90000019fae89adf90000019fae89adf8010301040102010100020000000000000000000000000000000000000000000000000000000000000000ebd1aec3e4ba248a6d25375543d327073bfdb3a815c93dc38a8e43b7b3f27f68034f9ea91c341733984ec241b620d24d3670bbc6e176de2bf075e22757a648392077dd41fd1f9ad83d537c8bfa0bce8b1068bc950f9a0b1b343d516b7d4f9b8d5ab1518f6b7d14c2a97633949766af2d6b4c97f884356e97a76bc3a65ccbbaf4560003bc72dffc5fa928ba3cdbd5d23c9ca4ae0fff1a82665b12ead87ba39a5eb9a8853161b271674bd7975e778d64787b5cd76770eedb52b2797493178adc70946719c943bc1787ea6f9981da4bdde06bf41f40f3f089bac14359e9d618c2509c0aed", + "response": "020000000000000007004011c9b9b9054570a06107e6412a39eb15c4c54f487587ff9c833fd46fd0de50bdbcd26b8af329428e36ef53a79f8645c93df88107fa04ef231a79f94bebe5c000030000019fae98271a0000019fae9827e50000019fae98284b00039f4a50ba010f545918f5592c790786767f78219ff430a867eb538cc8444e72b30791e4af854e3e8efc43ebed690eb0a7bb9bf9d469fd808126962c0910346d7a1ed3c37e3ac2ed9038800fde8b7441d9f82864c438408bf91823f8a50c281d6c000367f15be88056757515ba06cdcf67bc835fdf758d06932539b04d0e4d4b4576da62879dd252e1e60775e6d57c80e04ad07c5201a62cd609a9d5cbc48f6198e2db78f223cbd4da7b8d72ddd3ec3e1a1e2cbc4f4fe6c75b36127bce9c7ffb5dd7d6", "timestamps": [ - 1785339686392, - 1785339686393, - 1785339686393, - 1785339686392 + 1785340634906, + 1785340635109, + 1785340635211 ], "tree_size": 7 } @@ -308,49 +467,53 @@ } ], "entry_timestamps": [ - 1785339686398, - 1785339686398, - 1785339686399, - 1785339686399, - 1785339686399, - 1785339686399, - 1785339686400 + 1785340635223, + 1785340635223, + 1785340635224, + 1785340635224, + 1785340635224, + 1785340635225, + 1785340635225 ], "known_versions": [ { - "commitment": "f96724460e148f7e986c057c4a1d4222a0183b34f99182d705812566b982aae6", + "commitment": "17ce261da80f2688c8250c61e7e8cff02bba8c2523406bea874960fef67cdece", "version": 0, "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, { - "commitment": "12eadf596c27876b8be5620af69f23c654445f48cfa546bfd6c7c16ffb3cdb67", + "commitment": "13cfb42b42aac19da0672813bae8b18c4a8a26ec353979033cf7d0b3ee24c1ae", "version": 1, "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, { - "commitment": "a390ae49303887c640aea6fc52b3accf1a30ecd6083777c16414bbfcad3cb4a3", + "commitment": "588ea86685c178e9e63fac06c7dd34d0fa9f3beea7af5567bb87cfcfeb015c93", "version": 2, "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" }, { - "commitment": "f7bfac5d9eed02ef7a8845f1b8cee1d3f4386b0b1e1c11eb589fb96a643c293e", + "commitment": "13781622012e69cd6256f7ecec7db7e38dadf41661486ee72ae638ffaf8dd35f", "version": 3, "vrf_output": "ef0582ede742f1d47079dad60b655a3e4bab73d2bf1da0b3d6db7a833f132fee" }, { - "commitment": "97703498895ec9b6bf4f9f93e66d3a869321991675672ad4fa89adf31aa2aead", + "commitment": "33007ce5862ff74b8f30de8566230c81ad4c7aa1d41054eaaac36b00de57e246", "version": 4, "vrf_output": "f9177f084968b05e8b34978d8f50108baad4083600b51f944dc54460e0d850ae" }, { - "commitment": "65a7cec57ab0cf50e4694e954ff08d1790f4abf4bac025ccf3962c04bf978b98", + "commitment": "65a2594c7136080303db169dcc1aaee52d33c2fc8d6178669b5bfc2b78e3a0d5", "version": 5, "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, { - "commitment": "a22e83ac80a62eda9bd3029f0d126e2288661675427042b4a8517c80d6b2363a", + "commitment": "0d9d15e964d85a70b062c9c240212e373f612a2de42eb725ae9046f1908175d4", "version": 6, "vrf_output": "599424025a070d0e48913585265a30210ffe3416005c77c2354094f14c6358a1" + }, + { + "version": 7, + "vrf_output": "80e204b5356fa5a4e88a74d22763e8212b9e2882397e69aaf852a7010f23f672" } ], "label": "616c696365406578616d706c652e636f6d", @@ -421,21 +584,21 @@ "vrf_public_key": "555f469c22188e90015bdd85b889678d459f86bdf8f7bd34971b10b9b3858609" }, "expect": { - "full_tree_head": "0200000000000000070040c4a62779e81c159704e7f8f63136d3fdb4f17dc328e993179cf726a37d1c4438d30b1d3a32cef898064a60d3192cc959100ebb9553c635f5ec28dbfd66d95f09", + "full_tree_head": "020000000000000007004075c18da8ef52537be1f92a0fb97ef6c7f010f67a5b3a6b6f66ae131cfe3d4cf90a361dc9ae14990835da215cf7d8d8a6bc444197acaf973aca25bdd33bf53406", "inclusion": [ - "261163c99c12155f28d8be89e1ff39ef64b62d36408496047a5b48f5e7b3d227", - "2691f137d5b337d11b27b7d5c44abcf80535c06fc8a0459bed13c5a0bba80266", - "6e4f398baa6636b7e7d5b7de443b2e129631abbc423fc2810ff8fb7565eaf948" + "0d237d66512300b573cafd684939907fb1dadcec6ca5494ddf01464662a81b54", + "dc49c2616ece7d47fec107fbe6c4143618569f362bb9c9a37200384d4ef76395", + "52c1848f3355ceb1d4788812166ae36a99c328a3efe386e3c05b1270da2d7172" ], "prefix_proofs": [ { "elements": [ - "32bf607e337cf5998daba575b3ff28eed1a10a2c4552e604a159db87b9f30252", - "0bbe24daf49ad9f0a00a823dc17766a7bcfe4812c95622a374b6e6ed50c97bc8", + "afc9400f5d50eaaa4088cc50854abf714d1d9d8ceb729a670aded19d32a8a354", + "2fa04acae4e06ea20ab760e567d3b16f830fac74b696b2b2cd3400839a6b2ae2", "0000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000000" ], - "encoding": "040106010301040106000432bf607e337cf5998daba575b3ff28eed1a10a2c4552e604a159db87b9f302520bbe24daf49ad9f0a00a823dc17766a7bcfe4812c95622a374b6e6ed50c97bc800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "encoding": "0401060103010401060004afc9400f5d50eaaa4088cc50854abf714d1d9d8ceb729a670aded19d32a8a3542fa04acae4e06ea20ab760e567d3b16f830fac74b696b2b2cd3400839a6b2ae200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "results": [ { "depth": 6, @@ -457,14 +620,14 @@ } ], "prefix_roots": [ - "5f1b2c32038a4c4607c239660689a28cdbe78a4dbe5365321a84c19ef0c8a0dd", - "df6543f32871d8a17f56d7db62fb7b4f279599e75feb1c0a7ad92353e0467c4b" + "58613030462c55c932927680a09cc51ab0e24b41c9db2bbcf07992c5460a5bfd", + "22ec41fc651ad10aaad5f8c636cc397f3e9d1ee35e9c642856dcad6d71d98af7" ], - "response": "0200000000000000070040c4a62779e81c159704e7f8f63136d3fdb4f17dc328e993179cf726a37d1c4438d30b1d3a32cef898064a60d3192cc959100ebb9553c635f5ec28dbfd66d95f09030000019fae89adff0000019fae89adff0000019fae89ae0001040106010301040106000432bf607e337cf5998daba575b3ff28eed1a10a2c4552e604a159db87b9f302520bbe24daf49ad9f0a00a823dc17766a7bcfe4812c95622a374b6e6ed50c97bc800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025f1b2c32038a4c4607c239660689a28cdbe78a4dbe5365321a84c19ef0c8a0dddf6543f32871d8a17f56d7db62fb7b4f279599e75feb1c0a7ad92353e0467c4b0003261163c99c12155f28d8be89e1ff39ef64b62d36408496047a5b48f5e7b3d2272691f137d5b337d11b27b7d5c44abcf80535c06fc8a0459bed13c5a0bba802666e4f398baa6636b7e7d5b7de443b2e129631abbc423fc2810ff8fb7565eaf948", + "response": "020000000000000007004075c18da8ef52537be1f92a0fb97ef6c7f010f67a5b3a6b6f66ae131cfe3d4cf90a361dc9ae14990835da215cf7d8d8a6bc444197acaf973aca25bdd33bf53406030000019fae9828580000019fae9828590000019fae982859010401060103010401060004afc9400f5d50eaaa4088cc50854abf714d1d9d8ceb729a670aded19d32a8a3542fa04acae4e06ea20ab760e567d3b16f830fac74b696b2b2cd3400839a6b2ae2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000258613030462c55c932927680a09cc51ab0e24b41c9db2bbcf07992c5460a5bfd22ec41fc651ad10aaad5f8c636cc397f3e9d1ee35e9c642856dcad6d71d98af700030d237d66512300b573cafd684939907fb1dadcec6ca5494ddf01464662a81b54dc49c2616ece7d47fec107fbe6c4143618569f362bb9c9a37200384d4ef7639552c1848f3355ceb1d4788812166ae36a99c328a3efe386e3c05b1270da2d7172", "timestamps": [ - 1785339686399, - 1785339686399, - 1785339686400 + 1785340635224, + 1785340635225, + 1785340635225 ], "tree_size": 7 } @@ -479,44 +642,52 @@ } ], "entry_timestamps": [ - 1785339686411, - 1785339686411, - 1785339686412, - 1785339686412, - 1785339686412, - 1785339686413, - 1785339686413 + 1785340635237, + 1785340635237, + 1785340635237, + 1785340635237, + 1785340635238, + 1785340635238, + 1785340635238 ], "known_versions": [ { - "commitment": "7fe5c323757139d06dc0ae6ef8e0d6466200bec8b6c9f0a449e2aa284c49a93b", + "commitment": "08ceee05f2ec9aa69e2b3e8616815b80e7e91ef7c4498e537f97024b33bbc319", "version": 0, "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, { - "commitment": "5f8eb7b68a3c8b87b5e25dc8d0beed845280e3c629d4fa1aaa0c4e16ce3cf938", + "commitment": "02b1919e10f47599ef75ada1c0f5b37177a2e8870b082da17f56d4aac93994d4", "version": 1, "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, { - "commitment": "164d09ef1e28e8388038897f5d067a0beb0edb088a83fa02c270358784f823a2", + "commitment": "1fb80b73ba19d349968c7c9a5ac2a9cc45098393972bb57bca056c8c62dc863a", "version": 2, "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" }, { - "commitment": "c199b072a0393c95b1bfed685d100e9c326dee99fd98e6a1e30ed81678142b4b", + "commitment": "fe8609349001d6517832f5bf5cb77183d76d57e31a27fe4994ddf23e8ad03204", "version": 3, "vrf_output": "ef0582ede742f1d47079dad60b655a3e4bab73d2bf1da0b3d6db7a833f132fee" }, { - "commitment": "14a53e1f299fda7bf9489c0e50f4f9ec341d5a98ac3ceca169a35953c0ae581f", + "commitment": "a4af9dd5c064176f42133b2ba300d1ff0fe29e33b9a26095f26cb63f84a82a58", "version": 4, "vrf_output": "f9177f084968b05e8b34978d8f50108baad4083600b51f944dc54460e0d850ae" }, { - "commitment": "d1e161e2443f6f008a7ca6890fe1cfcac1ad40bd39e4dd621dd982503218fdc2", + "commitment": "af1a20ae4b12f2f80c30167420be6a2faf38578413cce595be96ebe441574b94", "version": 5, "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" + }, + { + "version": 6, + "vrf_output": "599424025a070d0e48913585265a30210ffe3416005c77c2354094f14c6358a1" + }, + { + "version": 7, + "vrf_output": "80e204b5356fa5a4e88a74d22763e8212b9e2882397e69aaf852a7010f23f672" } ], "label": "616c696365406578616d706c652e636f6d", @@ -588,15 +759,15 @@ "vrf_public_key": "555f469c22188e90015bdd85b889678d459f86bdf8f7bd34971b10b9b3858609" }, "expect": { - "full_tree_head": "020000000000000007004004f18b6f6924462b762fe3892536016ddfeb98421739daf8a7b9571c5cc259a1b92f77c2d78e13d7cffa1ca077586b6e31b088fa039864413d9b5858503bc903", + "full_tree_head": "020000000000000007004033472a88df543ec17a8781265e8ee7e0f3dd4d2b08f5ed80237edd9080aca95c0576b2387e9779a331f42657a96a12dd4ee507900899795ccb942f9246a6d60f", "inclusion": [], "prefix_proofs": [], "prefix_roots": [ - "f99ed84da00fe0de8a62977dc14dfb1c0f7114cdff3fb7e41b795403df94d532" + "b446b51ad0ad3c73729da7deb2b0c4e18e57351d859bdfca054d73ff3951271c" ], - "response": "020000000000000007004004f18b6f6924462b762fe3892536016ddfeb98421739daf8a7b9571c5cc259a1b92f77c2d78e13d7cffa1ca077586b6e31b088fa039864413d9b5858503bc903010000019fae89ae0d0001f99ed84da00fe0de8a62977dc14dfb1c0f7114cdff3fb7e41b795403df94d5320000", + "response": "020000000000000007004033472a88df543ec17a8781265e8ee7e0f3dd4d2b08f5ed80237edd9080aca95c0576b2387e9779a331f42657a96a12dd4ee507900899795ccb942f9246a6d60f010000019fae9828660001b446b51ad0ad3c73729da7deb2b0c4e18e57351d859bdfca054d73ff3951271c0000", "timestamps": [ - 1785339686413 + 1785340635238 ], "tree_size": 7 } @@ -606,19 +777,23 @@ "input": { "entries": [], "entry_timestamps": [ - 1785339686421, - 1785339686421, - 1785339686421, - 1785339686421, - 1785339686422, - 1785339686422, - 1785339686422 + 1785340635246, + 1785340635246, + 1785340635246, + 1785340635247, + 1785340635247, + 1785340635247, + 1785340635247 ], "known_versions": [ { - "commitment": "ced6974ad492d7b02b237baaadb82b0e8c3bb6615edaaa0b452faa1a31df1b1c", + "commitment": "4899033f93f321d87f49f7180b7f94f693b7e19f52dce2cf3adc79477f7bda22", "version": 0, "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" + }, + { + "version": 1, + "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" } ], "label": "616c696365406578616d706c652e636f6d", @@ -691,15 +866,15 @@ "expect": { "binary_ladder": [ { - "commitment": "ced6974ad492d7b02b237baaadb82b0e8c3bb6615edaaa0b452faa1a31df1b1c", + "commitment": "4899033f93f321d87f49f7180b7f94f693b7e19f52dce2cf3adc79477f7bda22", "proof": "f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00" }, { - "commitment": "7f1b61ba13d58aefd81ae3e064b98504d7bca0f88b340107d20d7c7e912d766e", + "commitment": "c4fdc8aa054d763c508351e477a10d90f583cedc46bda100ac9429ae5fbee897", "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" }, { - "commitment": "f7ba2e70df4c765912550395c1ad9a6da862859f8bbbbb0a5de38623e91dca5b", + "commitment": "ab2ffd6880fe80c6f852d4b9e7ed5516826623bce8d620beee2d123563f59722", "proof": "783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c" }, { @@ -712,22 +887,22 @@ "proof": "26fa91c612726fab2892d9d4bd0f73d52f623d1e536dd405e66fb3fb6c5cb157ac15cffa6eb16f43f72685f8f9b641d097435b4df6f5e3173987f2cec4d7c7506d20083e4c1037957595afa23e123409" } ], - "full_tree_head": "020000000000000007004080492ba66f7001cdb2b5ffb16446b97843ea445a660d727ee6b2d92f6fba2cc8037715f9267ae5f231abb68ef3c34972e717028ccf313ac3dfc46b142e227e0c", + "full_tree_head": "0200000000000000070040b76fc65ec19f291fc179591c8f20c2ac740c9b7647583295ef22e679bcb8dc8e04853dbc13043aabf5c9a0d96b6e29dfba9779f74817560990cc09140b99d800", "greatest_versions": [ 3 ], "inclusion": [ - "cab08f1e8938075e1ca97a6ad9562711f64528d57f89c5d2f9d7d23adcb1b19a", - "e9695c04daef58db9636bb1761136c2519c64a981050f1ec9895a0c248b0ef0f", - "9ce076326c003d2e5a233bc3031c3e359b8ed778225e1b48d97e11ab0e9de098" + "e998085e327400e893bb2ab7d6964e45028a4337f83bb9751a02ff956970e0d3", + "975717af978f48037cdd6670c97652731c71d4922585d8074189f95f84010f3e", + "62501f2df175ac776c0979506d0f3754732243f7634a6ed536709f859cf0c25e" ], "prefix_proofs": [ { "elements": [ - "1f49cafc262b96932e3b7691efd12c8cc137cafceb121f4c4d938d5b647156fa", + "cdfd629b2a6faa997bafde0b6d0e9932667b014031445a7d8815806b8d205822", "0000000000000000000000000000000000000000000000000000000000000000" ], - "encoding": "0601040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f7f1b61ba13d58aefd81ae3e064b98504d7bca0f88b340107d20d7c7e912d766e0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f7f1b61ba13d58aefd81ae3e064b98504d7bca0f88b340107d20d7c7e912d766e0202fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3ced6974ad492d7b02b237baaadb82b0e8c3bb6615edaaa0b452faa1a31df1b1c0400021f49cafc262b96932e3b7691efd12c8cc137cafceb121f4c4d938d5b647156fa0000000000000000000000000000000000000000000000000000000000000000", + "encoding": "0601040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fc4fdc8aa054d763c508351e477a10d90f583cedc46bda100ac9429ae5fbee8970202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fc4fdc8aa054d763c508351e477a10d90f583cedc46bda100ac9429ae5fbee8970202fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e34899033f93f321d87f49f7180b7f94f693b7e19f52dce2cf3adc79477f7bda22040002cdfd629b2a6faa997bafde0b6d0e9932667b014031445a7d8815806b8d2058220000000000000000000000000000000000000000000000000000000000000000", "results": [ { "depth": 4, @@ -744,7 +919,7 @@ { "depth": 2, "leaf": { - "commitment": "7f1b61ba13d58aefd81ae3e064b98504d7bca0f88b340107d20d7c7e912d766e", + "commitment": "c4fdc8aa054d763c508351e477a10d90f583cedc46bda100ac9429ae5fbee897", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -752,7 +927,7 @@ { "depth": 2, "leaf": { - "commitment": "7f1b61ba13d58aefd81ae3e064b98504d7bca0f88b340107d20d7c7e912d766e", + "commitment": "c4fdc8aa054d763c508351e477a10d90f583cedc46bda100ac9429ae5fbee897", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -760,7 +935,7 @@ { "depth": 4, "leaf": { - "commitment": "ced6974ad492d7b02b237baaadb82b0e8c3bb6615edaaa0b452faa1a31df1b1c", + "commitment": "4899033f93f321d87f49f7180b7f94f693b7e19f52dce2cf3adc79477f7bda22", "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, "result_type": 2 @@ -769,14 +944,14 @@ } ], "prefix_roots": [ - "54b04f5e65cc3b331c38c92431da25f2df6515bc7c252f367ad312646f9c11eb", - "e360c45be9e2c402b086895868b511d8fd610a60ac519b59045e86f29859576d" + "607b632a9aafaf731c709e41bdb9d2d76633c1fc45bd6e3bea7b5d9686d7f9f5", + "2baeda55193fc66ca6f4e698cdaf967054c0ede720f46fe19ec5b1e4919ea439" ], - "response": "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", + "response": "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", "timestamps": [ - 1785339686421, - 1785339686422, - 1785339686422 + 1785340635247, + 1785340635247, + 1785340635247 ], "tree_size": 7 } @@ -791,45 +966,54 @@ } ], "entry_timestamps": [ - 1785339686425, - 1785339686426, - 1785339686426, - 1785339686426, - 1785339686426, - 1785339686427, - 1785339686427 + 1785340635251, + 1785340635251, + 1785340635251, + 1785340635252, + 1785340635252, + 1785340635252, + 1785340635252 ], "greatest_version": 6, "known_versions": [ { - "commitment": "c11d03dffd90dc8b89a6013dbbb5e3397e4f5cff1a6207fc59fefff565360983", + "commitment": "e6af5239f3705d4d502c7e40ba28af1b154a70a489bbbb743b04c38ca68b9f76", "version": 0, "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, { - "commitment": "1d8ba46eec1a942157268972bc1eed30de22a1f50dd57c07848331045aee6384", + "commitment": "b678a0ae8eab79260517d2af71bc5f8629e01a8265dd6b88d001090164662c9d", "version": 1, "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, { - "commitment": "e66faeccd193991d72dcb558d37b83a557be27f27fa50b0b92a01ef11e867c35", + "commitment": "00a49defa1212084ce713e80c2ff1d79fc1202f1101584703607c1006f1d0961", "version": 2, "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" }, { - "commitment": "6be37940d7f53c3ea707f22b24062329baf9f922d50326f1d63a9b1d34eb3b2d", + "commitment": "64341059877483f2096b1f3342d536ceb827f3f72afae5ec1c27e9bf2cfd724a", "version": 3, "vrf_output": "ef0582ede742f1d47079dad60b655a3e4bab73d2bf1da0b3d6db7a833f132fee" }, { - "commitment": "503f59b87668d54a937d233a84810fe325535a08d5235a86bd65c3a76ba8b38c", + "commitment": "531775bf58d7b451acf77617062aebd8b6e7bf54136e62838dbda1b6f11a1256", "version": 4, "vrf_output": "f9177f084968b05e8b34978d8f50108baad4083600b51f944dc54460e0d850ae" }, { - "commitment": "3b65d9946a95def079acfa75d078ce52a630158e11c8b32cc8adb46102a6a1e7", + "commitment": "e47f76e65e5774e2383116eab8e68ddf0fbbee15b40d1a5132a1565f3d68c9d9", "version": 5, "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" + }, + { + "commitment": "cb5bd4b2e9ef4c7e24e6c1d444337c902b086de48239231c76ff6674684cc7f4", + "version": 6, + "vrf_output": "599424025a070d0e48913585265a30210ffe3416005c77c2354094f14c6358a1" + }, + { + "version": 7, + "vrf_output": "80e204b5356fa5a4e88a74d22763e8212b9e2882397e69aaf852a7010f23f672" } ], "label": "616c696365406578616d706c652e636f6d", @@ -900,23 +1084,368 @@ "vrf_public_key": "555f469c22188e90015bdd85b889678d459f86bdf8f7bd34971b10b9b3858609" }, "expect": { - "full_tree_head": "02000000000000000700400ad9c3cad33ebcaadcbe513ce18a50761798d4118a3ed7d3cf6e489b71cf68998666d9b74c7e65647838ea071f37dedb6b857a22566b9619a2a3e380e2266a00", + "full_tree_head": "02000000000000000700402177d7969c9375530fc534de87fd21ba986dcc6fdbb226f8fd5713cb6e6356d88b32e6dc35d82cca50cb4421c745ace8db9eb499b681ea041eca00f14653a40f", "inclusion": [ - "f960fc4701181223adc7f5e3a57c88388f293dabdd4ab8b4dd326d8392d1ee6e", - "1011b5913c1ff4edf9bbcb5533970367f0696c22e49081fb2f598aa0499f7ff7", - "61142b27f71d2ee7f94c513bc5bcd31c707178e4c0af482ee8ec54c8f492e2bb" + "2021fda0d57154e9cc7d62562d181d7ae7bec45f75e9e59df58dcb9dd26df952", + "97ca06ebe06487ab3fed631d5fca56ebcad91463bdccb5c5b0545a8ad34c77a1", + "1b1e0c65278544da2320347d50472accee17f3fa9026f7165cc018e062b728fc" ], "prefix_proofs": [], "prefix_roots": [ - "4eb9cf137616d17ba24072991faf4ea63d041b2ca156188f251a30f1d7514154", - "c06363f18f361ec6dcf0cc3d5c2761e60da1c5677186e2b05d251b16aeea5656", - "5f8a4b36c57763df0a250f80ed86fc84fd2981a03c949bbccf43ed4f65843294" + "5261d9024b49fa472cbe1f1448e1ba21ed4c6b7a9dcad89c90819e1889bcc700", + "252d5fa5591ef3a9a437be66efcfb8f71fe6c58f8aafb478a8fbfa9d73bda94c", + "a73b6b31601e749f7c5e2e49f6c0c5615f9f9ef55919d7433e05caa08929ac00" + ], + "response": "02000000000000000700402177d7969c9375530fc534de87fd21ba986dcc6fdbb226f8fd5713cb6e6356d88b32e6dc35d82cca50cb4421c745ace8db9eb499b681ea041eca00f14653a40f030000019fae9828740000019fae9828740000019fae98287400035261d9024b49fa472cbe1f1448e1ba21ed4c6b7a9dcad89c90819e1889bcc700252d5fa5591ef3a9a437be66efcfb8f71fe6c58f8aafb478a8fbfa9d73bda94ca73b6b31601e749f7c5e2e49f6c0c5615f9f9ef55919d7433e05caa08929ac0000032021fda0d57154e9cc7d62562d181d7ae7bec45f75e9e59df58dcb9dd26df95297ca06ebe06487ab3fed631d5fca56ebcad91463bdccb5c5b0545a8ad34c77a11b1e0c65278544da2320347d50472accee17f3fa9026f7165cc018e062b728fc", + "timestamps": [ + 1785340635252, + 1785340635252, + 1785340635252 + ], + "tree_size": 7 + } + }, + { + "name": "owner-monitor-reaches-step-5", + "input": { + "entries": [ + { + "position": 5, + "version": 5 + } + ], + "entry_timestamps": [ + 1785340635260, + 1785340635360, + 1785340635462, + 1785340635564, + 1785340635666, + 1785340635767, + 1785340635869 + ], + "greatest_version": 6, + "known_versions": [ + { + "commitment": "ded52cab47906fc745f16dd244fd8e3c2744acea333b36097f5a23a1e47d07b5", + "version": 0, + "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" + }, + { + "commitment": "c251e7b73aa4ee628a8837b513a41dad7b467bd94d1d45112e27327dd6ee769a", + "version": 1, + "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" + }, + { + "commitment": "5965795a8345cfdd990b9dd991eb27e7641129544e1e8c5469aa57cfa6673ab5", + "version": 2, + "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" + }, + { + "commitment": "366e715075704d3c68ec2e5f67615b42aee4c10a6c2953727056d68c3f95efc1", + "version": 3, + "vrf_output": "ef0582ede742f1d47079dad60b655a3e4bab73d2bf1da0b3d6db7a833f132fee" + }, + { + "commitment": "82dd11271483571eeccd38c72de1690f6d7a0817629c909c570a0c07735e251b", + "version": 4, + "vrf_output": "f9177f084968b05e8b34978d8f50108baad4083600b51f944dc54460e0d850ae" + }, + { + "commitment": "b2dcee71e4ce697f43980816087607974cc6839a7559dcdc1852f57f93a3cd1f", + "version": 5, + "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" + }, + { + "commitment": "6eb941d6fe37b895d0cd86d7ae7b485d6f6bebe2894e5903f5b16094d5d4d018", + "version": 6, + "vrf_output": "599424025a070d0e48913585265a30210ffe3416005c77c2354094f14c6358a1" + }, + { + "version": 7, + "vrf_output": "80e204b5356fa5a4e88a74d22763e8212b9e2882397e69aaf852a7010f23f672" + } + ], + "label": "616c696365406578616d706c652e636f6d", + "maximum_lifetime": 0, + "mode": 1, + "monitoring_window": 50, + "mutations": [ + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d31" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d32" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d33" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d34" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d35" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d36" + } + ] + }, + { + "add": [ + { + "label": "616c696365406578616d706c652e636f6d", + "value": "616c6963652d37" + } + ] + } + ], + "operation": "owner-monitor", + "signature_public_key": "e2fe2a39b7326642827d6d82d497622cd6c297fe78270eaa436b01f086b6f3cb", + "start": 1, + "vrf_public_key": "555f469c22188e90015bdd85b889678d459f86bdf8f7bd34971b10b9b3858609" + }, + "expect": { + "full_tree_head": "0200000000000000070040fe2b41964ab691ba832da19f394a0f3ac01db44114f8ddcd3e27d8d5ca98f8d4860b1ada1bfbedafab3807bba6963ad94475674e7dce5385438836a6dad0b309", + "inclusion": [ + "2fe0f356f4e85febc2d0e5b2b6cc9cbefcd106b271aaad0e4bf0b78adce995b6" + ], + "prefix_proofs": [ + { + "elements": [], + "encoding": "040102010202fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3ded52cab47906fc745f16dd244fd8e3c2744acea333b36097f5a23a1e47d07b50201010000", + "results": [ + { + "depth": 2, + "result_type": 1 + }, + { + "depth": 2, + "result_type": 1 + }, + { + "depth": 2, + "leaf": { + "commitment": "ded52cab47906fc745f16dd244fd8e3c2744acea333b36097f5a23a1e47d07b5", + "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" + }, + "result_type": 2 + }, + { + "depth": 1, + "result_type": 1 + } + ] + }, + { + "elements": [ + "22da6b106f6ee71baa2f26989f1613a2668b5cae8451dce07995fdd5ab0629a9", + "0000000000000000000000000000000000000000000000000000000000000000" + ], + "encoding": "0601040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fc251e7b73aa4ee628a8837b513a41dad7b467bd94d1d45112e27327dd6ee769a0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fc251e7b73aa4ee628a8837b513a41dad7b467bd94d1d45112e27327dd6ee769a0202fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3ded52cab47906fc745f16dd244fd8e3c2744acea333b36097f5a23a1e47d07b504000222da6b106f6ee71baa2f26989f1613a2668b5cae8451dce07995fdd5ab0629a90000000000000000000000000000000000000000000000000000000000000000", + "results": [ + { + "depth": 4, + "result_type": 1 + }, + { + "depth": 2, + "result_type": 1 + }, + { + "depth": 4, + "result_type": 1 + }, + { + "depth": 2, + "leaf": { + "commitment": "c251e7b73aa4ee628a8837b513a41dad7b467bd94d1d45112e27327dd6ee769a", + "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" + }, + "result_type": 2 + }, + { + "depth": 2, + "leaf": { + "commitment": "c251e7b73aa4ee628a8837b513a41dad7b467bd94d1d45112e27327dd6ee769a", + "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" + }, + "result_type": 2 + }, + { + "depth": 4, + "leaf": { + "commitment": "ded52cab47906fc745f16dd244fd8e3c2744acea333b36097f5a23a1e47d07b5", + "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" + }, + "result_type": 2 + } + ] + }, + { + "elements": [ + "22da6b106f6ee71baa2f26989f1613a2668b5cae8451dce07995fdd5ab0629a9", + "0000000000000000000000000000000000000000000000000000000000000000", + "0000000000000000000000000000000000000000000000000000000000000000" + ], + "encoding": "0601060102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fc251e7b73aa4ee628a8837b513a41dad7b467bd94d1d45112e27327dd6ee769a0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fc251e7b73aa4ee628a8837b513a41dad7b467bd94d1d45112e27327dd6ee769a020106000322da6b106f6ee71baa2f26989f1613a2668b5cae8451dce07995fdd5ab0629a900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "results": [ + { + "depth": 6, + "result_type": 1 + }, + { + "depth": 2, + "result_type": 1 + }, + { + "depth": 4, + "result_type": 1 + }, + { + "depth": 2, + "leaf": { + "commitment": "c251e7b73aa4ee628a8837b513a41dad7b467bd94d1d45112e27327dd6ee769a", + "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" + }, + "result_type": 2 + }, + { + "depth": 2, + "leaf": { + "commitment": "c251e7b73aa4ee628a8837b513a41dad7b467bd94d1d45112e27327dd6ee769a", + "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" + }, + "result_type": 2 + }, + { + "depth": 6, + "result_type": 1 + } + ] + }, + { + "elements": [ + "0000000000000000000000000000000000000000000000000000000000000000", + "0000000000000000000000000000000000000000000000000000000000000000", + "af032ef7eda961fb40119d3c124df42235546c9249e9ca04a7b239e3f841ea61" + ], + "encoding": "06010601030104028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8b2dcee71e4ce697f43980816087607974cc6839a7559dcdc1852f57f93a3cd1f0301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e455965795a8345cfdd990b9dd991eb27e7641129544e1e8c5469aa57cfa6673ab501000300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000af032ef7eda961fb40119d3c124df42235546c9249e9ca04a7b239e3f841ea61", + "results": [ + { + "depth": 6, + "result_type": 1 + }, + { + "depth": 3, + "result_type": 1 + }, + { + "depth": 4, + "result_type": 1 + }, + { + "depth": 3, + "leaf": { + "commitment": "b2dcee71e4ce697f43980816087607974cc6839a7559dcdc1852f57f93a3cd1f", + "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" + }, + "result_type": 2 + }, + { + "depth": 3, + "result_type": 1 + }, + { + "depth": 1, + "leaf": { + "commitment": "5965795a8345cfdd990b9dd991eb27e7641129544e1e8c5469aa57cfa6673ab5", + "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" + }, + "result_type": 2 + } + ] + }, + { + "elements": [ + "0000000000000000000000000000000000000000000000000000000000000000", + "22da6b106f6ee71baa2f26989f1613a2668b5cae8451dce07995fdd5ab0629a9", + "0000000000000000000000000000000000000000000000000000000000000000", + "0000000000000000000000000000000000000000000000000000000000000000", + "0000000000000000000000000000000000000000000000000000000000000000", + "af032ef7eda961fb40119d3c124df42235546c9249e9ca04a7b239e3f841ea61" + ], + "encoding": "06010601030104028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8b2dcee71e4ce697f43980816087607974cc6839a7559dcdc1852f57f93a3cd1f03010301040006000000000000000000000000000000000000000000000000000000000000000022da6b106f6ee71baa2f26989f1613a2668b5cae8451dce07995fdd5ab0629a9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000af032ef7eda961fb40119d3c124df42235546c9249e9ca04a7b239e3f841ea61", + "results": [ + { + "depth": 6, + "result_type": 1 + }, + { + "depth": 3, + "result_type": 1 + }, + { + "depth": 4, + "result_type": 1 + }, + { + "depth": 3, + "leaf": { + "commitment": "b2dcee71e4ce697f43980816087607974cc6839a7559dcdc1852f57f93a3cd1f", + "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" + }, + "result_type": 2 + }, + { + "depth": 3, + "result_type": 1 + }, + { + "depth": 4, + "result_type": 1 + } + ] + } + ], + "prefix_roots": [ + "48a2928ab1eb4f1fd049065234b41996440eda6a9a3d22db1c29df02bffb53f0" ], - "response": "02000000000000000700400ad9c3cad33ebcaadcbe513ce18a50761798d4118a3ed7d3cf6e489b71cf68998666d9b74c7e65647838ea071f37dedb6b857a22566b9619a2a3e380e2266a00030000019fae89ae1a0000019fae89ae1b0000019fae89ae1b00034eb9cf137616d17ba24072991faf4ea63d041b2ca156188f251a30f1d7514154c06363f18f361ec6dcf0cc3d5c2761e60da1c5677186e2b05d251b16aeea56565f8a4b36c57763df0a250f80ed86fc84fd2981a03c949bbccf43ed4f658432940003f960fc4701181223adc7f5e3a57c88388f293dabdd4ab8b4dd326d8392d1ee6e1011b5913c1ff4edf9bbcb5533970367f0696c22e49081fb2f598aa0499f7ff761142b27f71d2ee7f94c513bc5bcd31c707178e4c0af482ee8ec54c8f492e2bb", + "response": "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", "timestamps": [ - 1785339686426, - 1785339686427, - 1785339686427 + 1785340635564, + 1785340635767, + 1785340635869, + 1785340635360, + 1785340635462, + 1785340635666 ], "tree_size": 7 } diff --git a/interop/vectors/search.json b/interop/vectors/search.json index 8de5ae6..fba9dea 100644 --- a/interop/vectors/search.json +++ b/interop/vectors/search.json @@ -12,13 +12,13 @@ "name": "greatest-version-first-search", "input": { "entry_timestamps": [ - 1785339684512, - 1785339684513, - 1785339684513, - 1785339684513, - 1785339684513, - 1785339684514, - 1785339684514 + 1785340632706, + 1785340632706, + 1785340632706, + 1785340632707, + 1785340632707, + 1785340632707, + 1785340632707 ], "label": "616c696365406578616d706c652e636f6d", "max_ahead": 10000, @@ -94,42 +94,42 @@ "expect": { "binary_ladder": [ { - "commitment": "17482232f830231cf463cedc9a84e170ec2c6fb3ea2cde68d5454504aa6dc13d", + "commitment": "5019302d96fae104e70ca046fab8736b65bebee2f7243b5a6253ebf1a36c43b2", "proof": "f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00" }, { - "commitment": "3c6073e82d616fb7d9e80e970979cbae262806d4eb63b703a83b224c4684611f", + "commitment": "b1783bee1e90eb4c5c1c47e2b2435c0533ce8a2e99ddd0d246c8cf0f1d9aa95f", "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" }, { - "commitment": "5329bc92188b64245ecaf18a379778b80688ec000f05db7df5b8c092362921ee", + "commitment": "c1ecf7fe174b997e1d0f4dbef2fe40106e67113fdc2b4d73457c960b15841b11", "proof": "783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c" }, { "proof": "26fa91c612726fab2892d9d4bd0f73d52f623d1e536dd405e66fb3fb6c5cb157ac15cffa6eb16f43f72685f8f9b641d097435b4df6f5e3173987f2cec4d7c7506d20083e4c1037957595afa23e123409" }, { - "commitment": "74a08366c2a6f9f78c9b9afb6b9e789910a59245d73b1bfb2e0c5bcd04a4047c", + "commitment": "52270e23b27643569fa405662985c103996ad953255d4fccfd529fca916600e5", "proof": "e8064efcdf44e6573edc6fdfb948d4d36439d9e825e1e2d4b8b6ceddb5780bf5cb1207e328983ca5b32ff580ad6a1c96b080d6ee0290932ddb84ff37db88380cd470f7dddbf4e7dda6cc76c74592f603" }, { "proof": "79f3efd60d574baf99ba8351653f86889db173fc5321dbf9738f1fbb84e5fd442f8b21447179087c71097be04beecb9954b83f1c2e3e7346743de7e75ee452a0f1295f7844782688166c0e4c3ea7330a" } ], - "full_tree_head": "0200000000000000070040e59e1ca2474c86320004aab7bbba41f7e35e648963af0de212a5bd70c67126d3c9dd73ab4a8f704695aba4f182e97e1859b5d6cabb66b658bf4b152979ee2c0d", + "full_tree_head": "0200000000000000070040a9fb5baab632c9e28f9c3644b7e7231fdef2e53a35e691935832ef62ceb15af2f1d566cb8dd579c682be4dbc388f98fb0ab193fe3012d7e367958dcd2b50a60a", "inclusion": [ - "2ae8aa1aa9de309b1618096b3a9b93fcdb7baae46baa50f69232c785860fdf1e", - "81d658f2a951e89d00791f9594126ab1e9b2dbafb9716a25fd0d2ad6119dfbbd", - "c144d7de476b49ebbf66f546cd4b1d8beca4bf941dd69fba49dff78b4721313d" + "fe5d5ec2e5a002b6830031697af2dff269824b770d6c33586f5cb4e08b22a78f", + "0ba141695440b038f5300cee49c24e3992ff902d59e7dbd4558909e7529d9002", + "6612d1d4dba32cf7e112aae4cf31b119a7b79ffeb67513b0a04bd4e6823a358a" ], - "opening": "4287ccd29247668b2659fcea98faf298", + "opening": "37beded31b05b5bee0596d84c5b0432f", "prefix_proofs": [ { "elements": [ - "8323d9841ca091374fbdfb6940785bb5b73623c87bf0a2740e9fd6136a03a36b", + "dc477e2bb44b533cce9c26c9eca4d758480b6f5aaf08c39f69bde2bfce9ff9f7", "0000000000000000000000000000000000000000000000000000000000000000" ], - "encoding": "0501040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f3c6073e82d616fb7d9e80e970979cbae262806d4eb63b703a83b224c4684611f0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f3c6073e82d616fb7d9e80e970979cbae262806d4eb63b703a83b224c4684611f0200028323d9841ca091374fbdfb6940785bb5b73623c87bf0a2740e9fd6136a03a36b0000000000000000000000000000000000000000000000000000000000000000", + "encoding": "0501040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fb1783bee1e90eb4c5c1c47e2b2435c0533ce8a2e99ddd0d246c8cf0f1d9aa95f0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fb1783bee1e90eb4c5c1c47e2b2435c0533ce8a2e99ddd0d246c8cf0f1d9aa95f020002dc477e2bb44b533cce9c26c9eca4d758480b6f5aaf08c39f69bde2bfce9ff9f70000000000000000000000000000000000000000000000000000000000000000", "results": [ { "depth": 4, @@ -146,7 +146,7 @@ { "depth": 2, "leaf": { - "commitment": "3c6073e82d616fb7d9e80e970979cbae262806d4eb63b703a83b224c4684611f", + "commitment": "b1783bee1e90eb4c5c1c47e2b2435c0533ce8a2e99ddd0d246c8cf0f1d9aa95f", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -154,7 +154,7 @@ { "depth": 2, "leaf": { - "commitment": "3c6073e82d616fb7d9e80e970979cbae262806d4eb63b703a83b224c4684611f", + "commitment": "b1783bee1e90eb4c5c1c47e2b2435c0533ce8a2e99ddd0d246c8cf0f1d9aa95f", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -163,16 +163,16 @@ }, { "elements": [ - "a9c8d2783dff2ba4ea1cce0842a6d8f840ef6add7f15f1837209c422f35cb4dc", - "75eb839148494d571246f04b14b770d666d2674d6553d591e71ed0fd367c9662", - "5e4c7a989ba90008ef33701f84bc9693b0cd04e391a03de35b5d740f74edae06" + "13f9281e656b5af9c3265360a7327cf526e60c6ea515553062f0bc16d0348e45", + "8a93bfc064557eb188fa700dd0a7a456d79bf5f6c906c7e3d3cbb14e79fe2d4e", + "11224370bc6af2190c6c4a289423a5b62ba502abe87c919e52983a45c8931154" ], - "encoding": "03028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba874a08366c2a6f9f78c9b9afb6b9e789910a59245d73b1bfb2e0c5bcd04a4047c0301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e452be9546163fe6eb37c01ad1689a57da16d6b19225e12fab1ee3c14efb7c34497020003a9c8d2783dff2ba4ea1cce0842a6d8f840ef6add7f15f1837209c422f35cb4dc75eb839148494d571246f04b14b770d666d2674d6553d591e71ed0fd367c96625e4c7a989ba90008ef33701f84bc9693b0cd04e391a03de35b5d740f74edae06", + "encoding": "03028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba852270e23b27643569fa405662985c103996ad953255d4fccfd529fca916600e50301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45257131fba847ad4edd67447637017ebcdcf28daf11cfbf27214120edd0d3182202000313f9281e656b5af9c3265360a7327cf526e60c6ea515553062f0bc16d0348e458a93bfc064557eb188fa700dd0a7a456d79bf5f6c906c7e3d3cbb14e79fe2d4e11224370bc6af2190c6c4a289423a5b62ba502abe87c919e52983a45c8931154", "results": [ { "depth": 3, "leaf": { - "commitment": "74a08366c2a6f9f78c9b9afb6b9e789910a59245d73b1bfb2e0c5bcd04a4047c", + "commitment": "52270e23b27643569fa405662985c103996ad953255d4fccfd529fca916600e5", "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, "result_type": 2 @@ -184,7 +184,7 @@ { "depth": 2, "leaf": { - "commitment": "2be9546163fe6eb37c01ad1689a57da16d6b19225e12fab1ee3c14efb7c34497", + "commitment": "257131fba847ad4edd67447637017ebcdcf28daf11cfbf27214120edd0d31822", "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" }, "result_type": 2 @@ -193,18 +193,18 @@ }, { "elements": [ - "a9c8d2783dff2ba4ea1cce0842a6d8f840ef6add7f15f1837209c422f35cb4dc", - "fbefdc294da5ed6a7dfc62688742d9a8a7d5b280a930c83076f3a9ae6af0b39a", + "13f9281e656b5af9c3265360a7327cf526e60c6ea515553062f0bc16d0348e45", + "f8a967951f65082e676ec968e2323328d2d24d3b70bc1175c436865ba2de0abb", "0000000000000000000000000000000000000000000000000000000000000000", - "75eb839148494d571246f04b14b770d666d2674d6553d591e71ed0fd367c9662", - "5e4c7a989ba90008ef33701f84bc9693b0cd04e391a03de35b5d740f74edae06" + "8a93bfc064557eb188fa700dd0a7a456d79bf5f6c906c7e3d3cbb14e79fe2d4e", + "11224370bc6af2190c6c4a289423a5b62ba502abe87c919e52983a45c8931154" ], - "encoding": "02028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba874a08366c2a6f9f78c9b9afb6b9e789910a59245d73b1bfb2e0c5bcd04a4047c0301040005a9c8d2783dff2ba4ea1cce0842a6d8f840ef6add7f15f1837209c422f35cb4dcfbefdc294da5ed6a7dfc62688742d9a8a7d5b280a930c83076f3a9ae6af0b39a000000000000000000000000000000000000000000000000000000000000000075eb839148494d571246f04b14b770d666d2674d6553d591e71ed0fd367c96625e4c7a989ba90008ef33701f84bc9693b0cd04e391a03de35b5d740f74edae06", + "encoding": "02028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba852270e23b27643569fa405662985c103996ad953255d4fccfd529fca916600e5030104000513f9281e656b5af9c3265360a7327cf526e60c6ea515553062f0bc16d0348e45f8a967951f65082e676ec968e2323328d2d24d3b70bc1175c436865ba2de0abb00000000000000000000000000000000000000000000000000000000000000008a93bfc064557eb188fa700dd0a7a456d79bf5f6c906c7e3d3cbb14e79fe2d4e11224370bc6af2190c6c4a289423a5b62ba502abe87c919e52983a45c8931154", "results": [ { "depth": 3, "leaf": { - "commitment": "74a08366c2a6f9f78c9b9afb6b9e789910a59245d73b1bfb2e0c5bcd04a4047c", + "commitment": "52270e23b27643569fa405662985c103996ad953255d4fccfd529fca916600e5", "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, "result_type": 2 @@ -217,11 +217,11 @@ } ], "prefix_roots": [], - "response": "0200000000000000070040e59e1ca2474c86320004aab7bbba41f7e35e648963af0de212a5bd70c67126d3c9dd73ab4a8f704695aba4f182e97e1859b5d6cabb66b658bf4b152979ee2c0d000000064287ccd29247668b2659fcea98faf29800000007616c6963652d3706f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f000117482232f830231cf463cedc9a84e170ec2c6fb3ea2cde68d5454504aa6dc13d414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02013c6073e82d616fb7d9e80e970979cbae262806d4eb63b703a83b224c4684611f783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c015329bc92188b64245ecaf18a379778b80688ec000f05db7df5b8c092362921ee26fa91c612726fab2892d9d4bd0f73d52f623d1e536dd405e66fb3fb6c5cb157ac15cffa6eb16f43f72685f8f9b641d097435b4df6f5e3173987f2cec4d7c7506d20083e4c1037957595afa23e12340900e8064efcdf44e6573edc6fdfb948d4d36439d9e825e1e2d4b8b6ceddb5780bf5cb1207e328983ca5b32ff580ad6a1c96b080d6ee0290932ddb84ff37db88380cd470f7dddbf4e7dda6cc76c74592f6030174a08366c2a6f9f78c9b9afb6b9e789910a59245d73b1bfb2e0c5bcd04a4047c79f3efd60d574baf99ba8351653f86889db173fc5321dbf9738f1fbb84e5fd442f8b21447179087c71097be04beecb9954b83f1c2e3e7346743de7e75ee452a0f1295f7844782688166c0e4c3ea7330a00030000019fae89a6a10000019fae89a6a20000019fae89a6a2030501040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f3c6073e82d616fb7d9e80e970979cbae262806d4eb63b703a83b224c4684611f0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f3c6073e82d616fb7d9e80e970979cbae262806d4eb63b703a83b224c4684611f0200028323d9841ca091374fbdfb6940785bb5b73623c87bf0a2740e9fd6136a03a36b000000000000000000000000000000000000000000000000000000000000000003028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba874a08366c2a6f9f78c9b9afb6b9e789910a59245d73b1bfb2e0c5bcd04a4047c0301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e452be9546163fe6eb37c01ad1689a57da16d6b19225e12fab1ee3c14efb7c34497020003a9c8d2783dff2ba4ea1cce0842a6d8f840ef6add7f15f1837209c422f35cb4dc75eb839148494d571246f04b14b770d666d2674d6553d591e71ed0fd367c96625e4c7a989ba90008ef33701f84bc9693b0cd04e391a03de35b5d740f74edae0602028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba874a08366c2a6f9f78c9b9afb6b9e789910a59245d73b1bfb2e0c5bcd04a4047c0301040005a9c8d2783dff2ba4ea1cce0842a6d8f840ef6add7f15f1837209c422f35cb4dcfbefdc294da5ed6a7dfc62688742d9a8a7d5b280a930c83076f3a9ae6af0b39a000000000000000000000000000000000000000000000000000000000000000075eb839148494d571246f04b14b770d666d2674d6553d591e71ed0fd367c96625e4c7a989ba90008ef33701f84bc9693b0cd04e391a03de35b5d740f74edae060000032ae8aa1aa9de309b1618096b3a9b93fcdb7baae46baa50f69232c785860fdf1e81d658f2a951e89d00791f9594126ab1e9b2dbafb9716a25fd0d2ad6119dfbbdc144d7de476b49ebbf66f546cd4b1d8beca4bf941dd69fba49dff78b4721313d", + "response": "0200000000000000070040a9fb5baab632c9e28f9c3644b7e7231fdef2e53a35e691935832ef62ceb15af2f1d566cb8dd579c682be4dbc388f98fb0ab193fe3012d7e367958dcd2b50a60a0000000637beded31b05b5bee0596d84c5b0432f00000007616c6963652d3706f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00015019302d96fae104e70ca046fab8736b65bebee2f7243b5a6253ebf1a36c43b2414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf0201b1783bee1e90eb4c5c1c47e2b2435c0533ce8a2e99ddd0d246c8cf0f1d9aa95f783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c01c1ecf7fe174b997e1d0f4dbef2fe40106e67113fdc2b4d73457c960b15841b1126fa91c612726fab2892d9d4bd0f73d52f623d1e536dd405e66fb3fb6c5cb157ac15cffa6eb16f43f72685f8f9b641d097435b4df6f5e3173987f2cec4d7c7506d20083e4c1037957595afa23e12340900e8064efcdf44e6573edc6fdfb948d4d36439d9e825e1e2d4b8b6ceddb5780bf5cb1207e328983ca5b32ff580ad6a1c96b080d6ee0290932ddb84ff37db88380cd470f7dddbf4e7dda6cc76c74592f6030152270e23b27643569fa405662985c103996ad953255d4fccfd529fca916600e579f3efd60d574baf99ba8351653f86889db173fc5321dbf9738f1fbb84e5fd442f8b21447179087c71097be04beecb9954b83f1c2e3e7346743de7e75ee452a0f1295f7844782688166c0e4c3ea7330a00030000019fae981e830000019fae981e830000019fae981e83030501040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fb1783bee1e90eb4c5c1c47e2b2435c0533ce8a2e99ddd0d246c8cf0f1d9aa95f0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fb1783bee1e90eb4c5c1c47e2b2435c0533ce8a2e99ddd0d246c8cf0f1d9aa95f020002dc477e2bb44b533cce9c26c9eca4d758480b6f5aaf08c39f69bde2bfce9ff9f7000000000000000000000000000000000000000000000000000000000000000003028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba852270e23b27643569fa405662985c103996ad953255d4fccfd529fca916600e50301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45257131fba847ad4edd67447637017ebcdcf28daf11cfbf27214120edd0d3182202000313f9281e656b5af9c3265360a7327cf526e60c6ea515553062f0bc16d0348e458a93bfc064557eb188fa700dd0a7a456d79bf5f6c906c7e3d3cbb14e79fe2d4e11224370bc6af2190c6c4a289423a5b62ba502abe87c919e52983a45c893115402028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba852270e23b27643569fa405662985c103996ad953255d4fccfd529fca916600e5030104000513f9281e656b5af9c3265360a7327cf526e60c6ea515553062f0bc16d0348e45f8a967951f65082e676ec968e2323328d2d24d3b70bc1175c436865ba2de0abb00000000000000000000000000000000000000000000000000000000000000008a93bfc064557eb188fa700dd0a7a456d79bf5f6c906c7e3d3cbb14e79fe2d4e11224370bc6af2190c6c4a289423a5b62ba502abe87c919e52983a45c8931154000003fe5d5ec2e5a002b6830031697af2dff269824b770d6c33586f5cb4e08b22a78f0ba141695440b038f5300cee49c24e3992ff902d59e7dbd4558909e7529d90026612d1d4dba32cf7e112aae4cf31b119a7b79ffeb67513b0a04bd4e6823a358a", "timestamps": [ - 1785339684513, - 1785339684514, - 1785339684514 + 1785340632707, + 1785340632707, + 1785340632707 ], "tree_size": 7, "version": 6 @@ -231,13 +231,13 @@ "name": "greatest-version-with-advertised-size", "input": { "entry_timestamps": [ - 1785339684515, - 1785339684516, - 1785339684516, - 1785339684516, - 1785339684516, - 1785339684516, - 1785339684517 + 1785340632709, + 1785340632709, + 1785340632709, + 1785340632710, + 1785340632710, + 1785340632710, + 1785340632710 ], "label": "616c696365406578616d706c652e636f6d", "last": 4, @@ -314,40 +314,40 @@ "expect": { "binary_ladder": [ { - "commitment": "3e233147421d0d2e197770308d512e5a2904149a1ce9506afd7a7d053ed3a663", + "commitment": "e940036e55895f2b17eca16c8a5f69f830a1390e3c5b03014d969b6c8501f3f0", "proof": "f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00" }, { - "commitment": "adf72e6df3f5682b2e1dcc4330eb0d635a7e8976a7481c919166b888ff01daf1", + "commitment": "4e1fa58a25714e4b0225b5b28ea2faac9ae238891bef18fe3981f44a2c8fe261", "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" }, { - "commitment": "4b4ed8f4e895c20460f33231e7dd8f2cefa3160e83d6712efa43462cff00937b", + "commitment": "219ca3c75f046284d87ec40df4fc4d692256f08012e6ec865dc7f241b39a8713", "proof": "783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c" }, { "proof": "26fa91c612726fab2892d9d4bd0f73d52f623d1e536dd405e66fb3fb6c5cb157ac15cffa6eb16f43f72685f8f9b641d097435b4df6f5e3173987f2cec4d7c7506d20083e4c1037957595afa23e123409" }, { - "commitment": "858f7f17a04a6d724fa407ea92981881e1b3285631eea5078d00818fb9102c40", + "commitment": "546da0f117364ec5a0e555b26a86d1e6d0ca0df041a00ddc88fb7b67673d2776", "proof": "e8064efcdf44e6573edc6fdfb948d4d36439d9e825e1e2d4b8b6ceddb5780bf5cb1207e328983ca5b32ff580ad6a1c96b080d6ee0290932ddb84ff37db88380cd470f7dddbf4e7dda6cc76c74592f603" }, { "proof": "79f3efd60d574baf99ba8351653f86889db173fc5321dbf9738f1fbb84e5fd442f8b21447179087c71097be04beecb9954b83f1c2e3e7346743de7e75ee452a0f1295f7844782688166c0e4c3ea7330a" } ], - "full_tree_head": "02000000000000000700401b18997d28db81e4e34d575ab11d967739dbd9c0dfc0a53a3382c38e8dbaad18b0e6bcdfc3216ac788a865a690ab5139bf570866528c9b1a33e3455d509d780d", + "full_tree_head": "0200000000000000070040448dab3282e10369e05330e5d3bb0652e70e084daa82f7062cbd9b0851d4145c05dca2e40438d2b8d947aa77639ee720ec6cb028260e0c09dc2648588aa36503", "inclusion": [ - "9a36b2c4eca9aec6d391398091bc7e12fd22f25c022f3de2561253800baed99a" + "4d66c92ff1a24e5ebb9678634c8c641de9649b9b4dce891b563653bbaf1589d7" ], - "opening": "7a8b3d1fe77451e467db3eb964d01f9e", + "opening": "3485da070777b330a8bfc2899ae36ed1", "prefix_proofs": [ { "elements": [ - "d099b8b17c0f260f27bbe8392f3490c457cf2b913388d5eaa54a13119d962f1c", + "3f3de394ab1d9abc814aa2940cf430376f8a087ab37e8898018236dd39fd8a4c", "0000000000000000000000000000000000000000000000000000000000000000" ], - "encoding": "0501040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fadf72e6df3f5682b2e1dcc4330eb0d635a7e8976a7481c919166b888ff01daf10202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fadf72e6df3f5682b2e1dcc4330eb0d635a7e8976a7481c919166b888ff01daf1020002d099b8b17c0f260f27bbe8392f3490c457cf2b913388d5eaa54a13119d962f1c0000000000000000000000000000000000000000000000000000000000000000", + "encoding": "0501040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f4e1fa58a25714e4b0225b5b28ea2faac9ae238891bef18fe3981f44a2c8fe2610202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f4e1fa58a25714e4b0225b5b28ea2faac9ae238891bef18fe3981f44a2c8fe2610200023f3de394ab1d9abc814aa2940cf430376f8a087ab37e8898018236dd39fd8a4c0000000000000000000000000000000000000000000000000000000000000000", "results": [ { "depth": 4, @@ -364,7 +364,7 @@ { "depth": 2, "leaf": { - "commitment": "adf72e6df3f5682b2e1dcc4330eb0d635a7e8976a7481c919166b888ff01daf1", + "commitment": "4e1fa58a25714e4b0225b5b28ea2faac9ae238891bef18fe3981f44a2c8fe261", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -372,7 +372,7 @@ { "depth": 2, "leaf": { - "commitment": "adf72e6df3f5682b2e1dcc4330eb0d635a7e8976a7481c919166b888ff01daf1", + "commitment": "4e1fa58a25714e4b0225b5b28ea2faac9ae238891bef18fe3981f44a2c8fe261", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -381,16 +381,16 @@ }, { "elements": [ - "9c99168e7df15d244fd5f0a7ec23cbe9a87313d0b633d559ef97123beb942548", - "2f8462b098b5f409d90afd5ffe159ba0925997292ed2e6229cbaaa911a886e54", - "05623cdb8d366f2c64f6095098300cbf99ba8e3b32239038bc5616739d19f9a1" + "636ab9f164afce6e31cb87e78113f23bc97e01900e8197eddf1fdd1b436853e3", + "f4cf3e32875ca4b30eb89921049fe554231c2b99a57cb525e6de0cb21e23bad0", + "8ea63c2832d91df49387b49834b802cf7357923f3ec08ab3c0cf7b4edaf117e5" ], - "encoding": "03028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8858f7f17a04a6d724fa407ea92981881e1b3285631eea5078d00818fb9102c400301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45d7ef6c4cc16104d52c73e0bc8f53a774898f939b9db3c7097c755b69045e94c80200039c99168e7df15d244fd5f0a7ec23cbe9a87313d0b633d559ef97123beb9425482f8462b098b5f409d90afd5ffe159ba0925997292ed2e6229cbaaa911a886e5405623cdb8d366f2c64f6095098300cbf99ba8e3b32239038bc5616739d19f9a1", + "encoding": "03028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8546da0f117364ec5a0e555b26a86d1e6d0ca0df041a00ddc88fb7b67673d27760301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45a69121856a5151e1d77e32f5c0e247067b0573a1381026a85bbb5db05f609952020003636ab9f164afce6e31cb87e78113f23bc97e01900e8197eddf1fdd1b436853e3f4cf3e32875ca4b30eb89921049fe554231c2b99a57cb525e6de0cb21e23bad08ea63c2832d91df49387b49834b802cf7357923f3ec08ab3c0cf7b4edaf117e5", "results": [ { "depth": 3, "leaf": { - "commitment": "858f7f17a04a6d724fa407ea92981881e1b3285631eea5078d00818fb9102c40", + "commitment": "546da0f117364ec5a0e555b26a86d1e6d0ca0df041a00ddc88fb7b67673d2776", "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, "result_type": 2 @@ -402,7 +402,7 @@ { "depth": 2, "leaf": { - "commitment": "d7ef6c4cc16104d52c73e0bc8f53a774898f939b9db3c7097c755b69045e94c8", + "commitment": "a69121856a5151e1d77e32f5c0e247067b0573a1381026a85bbb5db05f609952", "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" }, "result_type": 2 @@ -411,18 +411,18 @@ }, { "elements": [ - "9c99168e7df15d244fd5f0a7ec23cbe9a87313d0b633d559ef97123beb942548", - "5f059b8e91ea03a16bad75032d41f3be821e1fc17fb0c6043d02438e4c3d2428", + "636ab9f164afce6e31cb87e78113f23bc97e01900e8197eddf1fdd1b436853e3", + "5ef59df4f12ffd0f15d469e92c2d6064397296d699a713455dd3029501463db4", "0000000000000000000000000000000000000000000000000000000000000000", - "2f8462b098b5f409d90afd5ffe159ba0925997292ed2e6229cbaaa911a886e54", - "05623cdb8d366f2c64f6095098300cbf99ba8e3b32239038bc5616739d19f9a1" + "f4cf3e32875ca4b30eb89921049fe554231c2b99a57cb525e6de0cb21e23bad0", + "8ea63c2832d91df49387b49834b802cf7357923f3ec08ab3c0cf7b4edaf117e5" ], - "encoding": "02028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8858f7f17a04a6d724fa407ea92981881e1b3285631eea5078d00818fb9102c4003010400059c99168e7df15d244fd5f0a7ec23cbe9a87313d0b633d559ef97123beb9425485f059b8e91ea03a16bad75032d41f3be821e1fc17fb0c6043d02438e4c3d242800000000000000000000000000000000000000000000000000000000000000002f8462b098b5f409d90afd5ffe159ba0925997292ed2e6229cbaaa911a886e5405623cdb8d366f2c64f6095098300cbf99ba8e3b32239038bc5616739d19f9a1", + "encoding": "02028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8546da0f117364ec5a0e555b26a86d1e6d0ca0df041a00ddc88fb7b67673d27760301040005636ab9f164afce6e31cb87e78113f23bc97e01900e8197eddf1fdd1b436853e35ef59df4f12ffd0f15d469e92c2d6064397296d699a713455dd3029501463db40000000000000000000000000000000000000000000000000000000000000000f4cf3e32875ca4b30eb89921049fe554231c2b99a57cb525e6de0cb21e23bad08ea63c2832d91df49387b49834b802cf7357923f3ec08ab3c0cf7b4edaf117e5", "results": [ { "depth": 3, "leaf": { - "commitment": "858f7f17a04a6d724fa407ea92981881e1b3285631eea5078d00818fb9102c40", + "commitment": "546da0f117364ec5a0e555b26a86d1e6d0ca0df041a00ddc88fb7b67673d2776", "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, "result_type": 2 @@ -435,10 +435,10 @@ } ], "prefix_roots": [], - "response": "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", + "response": "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", "timestamps": [ - 1785339684517, - 1785339684516 + 1785340632710, + 1785340632710 ], "tree_size": 7, "version": 6 @@ -448,13 +448,13 @@ "name": "greatest-version-single-version-label", "input": { "entry_timestamps": [ - 1785339684518, - 1785339684518, - 1785339684519, - 1785339684519, - 1785339684519, - 1785339684519, - 1785339684520 + 1785340632712, + 1785340632712, + 1785340632712, + 1785340632712, + 1785340632713, + 1785340632713, + 1785340632713 ], "label": "626f62406578616d706c652e636f6d", "max_ahead": 10000, @@ -536,20 +536,20 @@ "proof": "f4f1731a9622a7d2e073010a0f633b7a7480ed6ec7d1b7b139f070ded0837c6d37ad8fe5463defe0cf800861a66f5ac1d413a5bcfd5e1de2f3c5234a90a68e35f6ee818bd00ddeb7307b3a1718f5e003" } ], - "full_tree_head": "02000000000000000700405e4e0c9c071d006b776c4d0f7246e589123260b585f85a10a1c53816b55fe4b0596c220a6f4c46a37a43aa66688021072e7db76114160b885a85212d2e4e420b", + "full_tree_head": "0200000000000000070040a6cd0be7d0d145ac6703e81d67c949f50607ea7ac07775192bb69c1c24f6b7edc233829a27f595f0bcbec19c911f0756d5adb299e2864b384b44db553cd93e0b", "inclusion": [ - "a11905b6ad03b86c27cce47627256b4579bda0a72a0217aeefc696e0bfe44e17", - "028624dc7da3a76bbfe273f2c465b5043c17275d7464eab8b5fcac9d90215426", - "e78ba59a452e0750eed89322ae5f298fa7035d5357677b5224d1cae175d5299d" + "558519d43c734ce4ede3bd4a3a4f6eb585d94cab26ab9912abd58b22e6cf25f7", + "53f6d08a95efe1df164d718ff099801dc03f49a2340d1dd3461779083d67a6dd", + "1103cce6b3427c443cb52fcd24aa853f003e4c140c62b5c082791a005999387d" ], - "opening": "4d850a20f7f14e3a0caa9b5674c91d7a", + "opening": "816587d0ed00715e22e1147db9a3f452", "prefix_proofs": [ { "elements": [ - "c661736e2cd81458d041e6a23c3a519d805c6b1eaabc61119dbba8dda29845f5", - "72b8c20ee05f36e8a7dbf9f55f9436d23dd45c494aa596fdc39221db347b173c" + "50384e3cc532f1917a2a14468ceef8efe65fc08983a07f7fda1659201134d5b5", + "0268507a5d8ddbc017383ef49e7dcf3d0b4c449a2b079f69f54c8b5a6d0c9648" ], - "encoding": "02010202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fd1a31c655c8b84ea08a536eb997726891d3990d222039bb42b9a8943eb8f4552020002c661736e2cd81458d041e6a23c3a519d805c6b1eaabc61119dbba8dda29845f572b8c20ee05f36e8a7dbf9f55f9436d23dd45c494aa596fdc39221db347b173c", + "encoding": "02010202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fe6c5c17ae48e3ea9e6e8f511f5c28d8f21323f29753ae798a84e0e54894b79ab02000250384e3cc532f1917a2a14468ceef8efe65fc08983a07f7fda1659201134d5b50268507a5d8ddbc017383ef49e7dcf3d0b4c449a2b079f69f54c8b5a6d0c9648", "results": [ { "depth": 2, @@ -558,7 +558,7 @@ { "depth": 2, "leaf": { - "commitment": "d1a31c655c8b84ea08a536eb997726891d3990d222039bb42b9a8943eb8f4552", + "commitment": "e6c5c17ae48e3ea9e6e8f511f5c28d8f21323f29753ae798a84e0e54894b79ab", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -567,16 +567,16 @@ }, { "elements": [ - "fad1553711485e69c6d33e6944e711d8f777d76c27a8bbd55107777c921230e5", - "c546e4b6635484f8472d9d01a629305ca52faf257246e587087a2bfe882fc5e1", - "f0f447ea2cc6220a5dae6d897e5370c60d4802ba2bb3a9f8f23be69f89d52580" + "8725c70ae0d823817b5dca2679395aeddcf1805aa5e7e68e83fc1a76dde8637c", + "aee98a365856b5cf5ecda58b7220f203fd67156088f696b832a5948ae641f1d9", + "e3939702e0e69223cfac390de01437af712dc6a0a9850d9c27e9f3c867d7cd69" ], - "encoding": "0102a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fd1a31c655c8b84ea08a536eb997726891d3990d222039bb42b9a8943eb8f4552030003fad1553711485e69c6d33e6944e711d8f777d76c27a8bbd55107777c921230e5c546e4b6635484f8472d9d01a629305ca52faf257246e587087a2bfe882fc5e1f0f447ea2cc6220a5dae6d897e5370c60d4802ba2bb3a9f8f23be69f89d52580", + "encoding": "0102a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fe6c5c17ae48e3ea9e6e8f511f5c28d8f21323f29753ae798a84e0e54894b79ab0300038725c70ae0d823817b5dca2679395aeddcf1805aa5e7e68e83fc1a76dde8637caee98a365856b5cf5ecda58b7220f203fd67156088f696b832a5948ae641f1d9e3939702e0e69223cfac390de01437af712dc6a0a9850d9c27e9f3c867d7cd69", "results": [ { "depth": 3, "leaf": { - "commitment": "d1a31c655c8b84ea08a536eb997726891d3990d222039bb42b9a8943eb8f4552", + "commitment": "e6c5c17ae48e3ea9e6e8f511f5c28d8f21323f29753ae798a84e0e54894b79ab", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -585,16 +585,16 @@ }, { "elements": [ - "6ced636741e99978fff9f25765fcf06afe773822e5a26e5e7f233b1ad358618e", - "c546e4b6635484f8472d9d01a629305ca52faf257246e587087a2bfe882fc5e1", - "f0f447ea2cc6220a5dae6d897e5370c60d4802ba2bb3a9f8f23be69f89d52580" + "907547d42b213adc369025ea69ee3c61a3a388d04c5f36ee1e8f35950b58d71a", + "aee98a365856b5cf5ecda58b7220f203fd67156088f696b832a5948ae641f1d9", + "e3939702e0e69223cfac390de01437af712dc6a0a9850d9c27e9f3c867d7cd69" ], - "encoding": "0102a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fd1a31c655c8b84ea08a536eb997726891d3990d222039bb42b9a8943eb8f45520300036ced636741e99978fff9f25765fcf06afe773822e5a26e5e7f233b1ad358618ec546e4b6635484f8472d9d01a629305ca52faf257246e587087a2bfe882fc5e1f0f447ea2cc6220a5dae6d897e5370c60d4802ba2bb3a9f8f23be69f89d52580", + "encoding": "0102a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fe6c5c17ae48e3ea9e6e8f511f5c28d8f21323f29753ae798a84e0e54894b79ab030003907547d42b213adc369025ea69ee3c61a3a388d04c5f36ee1e8f35950b58d71aaee98a365856b5cf5ecda58b7220f203fd67156088f696b832a5948ae641f1d9e3939702e0e69223cfac390de01437af712dc6a0a9850d9c27e9f3c867d7cd69", "results": [ { "depth": 3, "leaf": { - "commitment": "d1a31c655c8b84ea08a536eb997726891d3990d222039bb42b9a8943eb8f4552", + "commitment": "e6c5c17ae48e3ea9e6e8f511f5c28d8f21323f29753ae798a84e0e54894b79ab", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -603,11 +603,11 @@ } ], "prefix_roots": [], - "response": "02000000000000000700405e4e0c9c071d006b776c4d0f7246e589123260b585f85a10a1c53816b55fe4b0596c220a6f4c46a37a43aa66688021072e7db76114160b885a85212d2e4e420b000000004d850a20f7f14e3a0caa9b5674c91d7a00000005626f622d31021cfe4094661cd115c04be0c885e8f5d1a223195bd4eb8c012cebdfb8d039c825470e056ca834618373a9c92c2a716e75eee517652f2d0580dd44750bb47ecb8c1e906187bdb596c146d4d7abed149a0a00f4f1731a9622a7d2e073010a0f633b7a7480ed6ec7d1b7b139f070ded0837c6d37ad8fe5463defe0cf800861a66f5ac1d413a5bcfd5e1de2f3c5234a90a68e35f6ee818bd00ddeb7307b3a1718f5e00300030000019fae89a6a70000019fae89a6a70000019fae89a6a80302010202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fd1a31c655c8b84ea08a536eb997726891d3990d222039bb42b9a8943eb8f4552020002c661736e2cd81458d041e6a23c3a519d805c6b1eaabc61119dbba8dda29845f572b8c20ee05f36e8a7dbf9f55f9436d23dd45c494aa596fdc39221db347b173c0102a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fd1a31c655c8b84ea08a536eb997726891d3990d222039bb42b9a8943eb8f4552030003fad1553711485e69c6d33e6944e711d8f777d76c27a8bbd55107777c921230e5c546e4b6635484f8472d9d01a629305ca52faf257246e587087a2bfe882fc5e1f0f447ea2cc6220a5dae6d897e5370c60d4802ba2bb3a9f8f23be69f89d525800102a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fd1a31c655c8b84ea08a536eb997726891d3990d222039bb42b9a8943eb8f45520300036ced636741e99978fff9f25765fcf06afe773822e5a26e5e7f233b1ad358618ec546e4b6635484f8472d9d01a629305ca52faf257246e587087a2bfe882fc5e1f0f447ea2cc6220a5dae6d897e5370c60d4802ba2bb3a9f8f23be69f89d52580000003a11905b6ad03b86c27cce47627256b4579bda0a72a0217aeefc696e0bfe44e17028624dc7da3a76bbfe273f2c465b5043c17275d7464eab8b5fcac9d90215426e78ba59a452e0750eed89322ae5f298fa7035d5357677b5224d1cae175d5299d", + "response": "0200000000000000070040a6cd0be7d0d145ac6703e81d67c949f50607ea7ac07775192bb69c1c24f6b7edc233829a27f595f0bcbec19c911f0756d5adb299e2864b384b44db553cd93e0b00000000816587d0ed00715e22e1147db9a3f45200000005626f622d31021cfe4094661cd115c04be0c885e8f5d1a223195bd4eb8c012cebdfb8d039c825470e056ca834618373a9c92c2a716e75eee517652f2d0580dd44750bb47ecb8c1e906187bdb596c146d4d7abed149a0a00f4f1731a9622a7d2e073010a0f633b7a7480ed6ec7d1b7b139f070ded0837c6d37ad8fe5463defe0cf800861a66f5ac1d413a5bcfd5e1de2f3c5234a90a68e35f6ee818bd00ddeb7307b3a1718f5e00300030000019fae981e880000019fae981e890000019fae981e890302010202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fe6c5c17ae48e3ea9e6e8f511f5c28d8f21323f29753ae798a84e0e54894b79ab02000250384e3cc532f1917a2a14468ceef8efe65fc08983a07f7fda1659201134d5b50268507a5d8ddbc017383ef49e7dcf3d0b4c449a2b079f69f54c8b5a6d0c96480102a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fe6c5c17ae48e3ea9e6e8f511f5c28d8f21323f29753ae798a84e0e54894b79ab0300038725c70ae0d823817b5dca2679395aeddcf1805aa5e7e68e83fc1a76dde8637caee98a365856b5cf5ecda58b7220f203fd67156088f696b832a5948ae641f1d9e3939702e0e69223cfac390de01437af712dc6a0a9850d9c27e9f3c867d7cd690102a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fe6c5c17ae48e3ea9e6e8f511f5c28d8f21323f29753ae798a84e0e54894b79ab030003907547d42b213adc369025ea69ee3c61a3a388d04c5f36ee1e8f35950b58d71aaee98a365856b5cf5ecda58b7220f203fd67156088f696b832a5948ae641f1d9e3939702e0e69223cfac390de01437af712dc6a0a9850d9c27e9f3c867d7cd69000003558519d43c734ce4ede3bd4a3a4f6eb585d94cab26ab9912abd58b22e6cf25f753f6d08a95efe1df164d718ff099801dc03f49a2340d1dd3461779083d67a6dd1103cce6b3427c443cb52fcd24aa853f003e4c140c62b5c082791a005999387d", "timestamps": [ - 1785339684519, - 1785339684519, - 1785339684520 + 1785340632712, + 1785340632713, + 1785340632713 ], "tree_size": 7, "version": 0 @@ -617,13 +617,13 @@ "name": "fixed-version-first", "input": { "entry_timestamps": [ - 1785339684520, - 1785339684521, - 1785339684521, - 1785339684521, - 1785339684521, - 1785339684521, - 1785339684522 + 1785340632714, + 1785340632714, + 1785340632714, + 1785340632715, + 1785340632715, + 1785340632715, + 1785340632715 ], "label": "616c696365406578616d706c652e636f6d", "max_ahead": 10000, @@ -703,24 +703,24 @@ "proof": "f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00" }, { - "commitment": "95af14a73dd9baec5c5c0f4a2563a459ad829de0f90f1ebf92d189381718c6c4", + "commitment": "13e44c320985aa35f6c3418694b90b375f5e3cb635daa7eaf121488ad3704351", "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" } ], - "full_tree_head": "020000000000000007004056b765194d402924cb9093bf4078dac607b80f6667de38684f242d7b4497b0e303d9b3887cb8f487c65e0e9e82de591a733ec3ae0f4bd3ff77cc6f3e31373b0c", + "full_tree_head": "020000000000000007004024db298706f32a083a0cf8661d37031dba0e29facc36f22f6fb92af567b6266d835cd5b42fd2bbceb7fd32fe42e106c9ca0b3e53425c2bfe978ce15978d9ae08", "inclusion": [ - "a82c3e68675b3aa3d12bcad2026b196bafffd57e6187914565cfb2c5ee4dd1a0", - "dc168454bfff63742300ff0d0de357b772d288e4b173cfede993b459bf8e36ac" + "9e9de5df2a753436897bd4979a65e48626a238e217d8d85bebc42bc5e46e77d5", + "5ffd669667b9a53b762adc0ee168e45621951690bbaf5e7de0ec700e2aea98f6" ], - "opening": "419e288fc19a46665c575fa4bc20841f", + "opening": "4f7436097b408b849a2f5d6aea817178", "prefix_proofs": [ { "elements": [ - "09e61aab75d1fc1e689b8828477ffa875b352d7873b450a71d0695ba104cffa8", + "f216fa69ab6b93d0e748290eb3750b001ccefc9dded8277e0e3f3ffd22dd4ba6", "0000000000000000000000000000000000000000000000000000000000000000", - "c9ae69b0176d16bf8d2a1a4d53896ade09966457f729b1467c0d7861a8eee559" + "90dc90af0c433f2b7dbe7e9a6e619d6ccdb4d888905b7e2c526177dba96f539d" ], - "encoding": "0201040102000309e61aab75d1fc1e689b8828477ffa875b352d7873b450a71d0695ba104cffa80000000000000000000000000000000000000000000000000000000000000000c9ae69b0176d16bf8d2a1a4d53896ade09966457f729b1467c0d7861a8eee559", + "encoding": "02010401020003f216fa69ab6b93d0e748290eb3750b001ccefc9dded8277e0e3f3ffd22dd4ba6000000000000000000000000000000000000000000000000000000000000000090dc90af0c433f2b7dbe7e9a6e619d6ccdb4d888905b7e2c526177dba96f539d", "results": [ { "depth": 4, @@ -734,9 +734,9 @@ }, { "elements": [ - "ef8c35daf0caab5041faddeead32f18c51e43263316c516a890e3ce2dfa26a1a" + "36d535a3ec723f0ab87ca0d4911583cbc96f288745e73d7ee6bebdb43cb64485" ], - "encoding": "02010201020001ef8c35daf0caab5041faddeead32f18c51e43263316c516a890e3ce2dfa26a1a", + "encoding": "0201020102000136d535a3ec723f0ab87ca0d4911583cbc96f288745e73d7ee6bebdb43cb64485", "results": [ { "depth": 2, @@ -750,9 +750,9 @@ }, { "elements": [ - "ef8c35daf0caab5041faddeead32f18c51e43263316c516a890e3ce2dfa26a1a" + "36d535a3ec723f0ab87ca0d4911583cbc96f288745e73d7ee6bebdb43cb64485" ], - "encoding": "02010102fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3715290b51d4bb3646b2c930c468c69682d970648df6efdf40a9ea9bf33edfb15010001ef8c35daf0caab5041faddeead32f18c51e43263316c516a890e3ce2dfa26a1a", + "encoding": "02010102fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e37b23938253cd548c27b39c93fab34ebd71dfe18941e66d7c50ef05c93b8bb10801000136d535a3ec723f0ab87ca0d4911583cbc96f288745e73d7ee6bebdb43cb64485", "results": [ { "depth": 1, @@ -761,7 +761,7 @@ { "depth": 1, "leaf": { - "commitment": "715290b51d4bb3646b2c930c468c69682d970648df6efdf40a9ea9bf33edfb15", + "commitment": "7b23938253cd548c27b39c93fab34ebd71dfe18941e66d7c50ef05c93b8bb108", "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, "result_type": 2 @@ -770,16 +770,16 @@ } ], "prefix_roots": [ - "bf8d52e0e41fc3fd0d1a72c602f51abd6b374991b84db95298cf9befff4c8f59", - "15bef1a372bc2594c42d9f076db494988508f7651bf8573e2af5bf0c991c1a20" + "a68c663c7d945ae9f824cbfdcd4d67ef90f4bd4e9c0856cfae4b03bd7b344a4f", + "030e9081b11a772a791303f333998d73d8a2ced522ee230780f738211381b425" ], - "response": "020000000000000007004056b765194d402924cb9093bf4078dac607b80f6667de38684f242d7b4497b0e303d9b3887cb8f487c65e0e9e82de591a733ec3ae0f4bd3ff77cc6f3e31373b0c419e288fc19a46665c575fa4bc20841f00000007616c6963652d3102f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f0000414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf020195af14a73dd9baec5c5c0f4a2563a459ad829de0f90f1ebf92d189381718c6c4050000019fae89a6a90000019fae89a6a90000019fae89a6aa0000019fae89a6a90000019fae89a6a8030201040102000309e61aab75d1fc1e689b8828477ffa875b352d7873b450a71d0695ba104cffa80000000000000000000000000000000000000000000000000000000000000000c9ae69b0176d16bf8d2a1a4d53896ade09966457f729b1467c0d7861a8eee55902010201020001ef8c35daf0caab5041faddeead32f18c51e43263316c516a890e3ce2dfa26a1a02010102fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3715290b51d4bb3646b2c930c468c69682d970648df6efdf40a9ea9bf33edfb15010001ef8c35daf0caab5041faddeead32f18c51e43263316c516a890e3ce2dfa26a1a02bf8d52e0e41fc3fd0d1a72c602f51abd6b374991b84db95298cf9befff4c8f5915bef1a372bc2594c42d9f076db494988508f7651bf8573e2af5bf0c991c1a200002a82c3e68675b3aa3d12bcad2026b196bafffd57e6187914565cfb2c5ee4dd1a0dc168454bfff63742300ff0d0de357b772d288e4b173cfede993b459bf8e36ac", + "response": "020000000000000007004024db298706f32a083a0cf8661d37031dba0e29facc36f22f6fb92af567b6266d835cd5b42fd2bbceb7fd32fe42e106c9ca0b3e53425c2bfe978ce15978d9ae084f7436097b408b849a2f5d6aea81717800000007616c6963652d3102f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f0000414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf020113e44c320985aa35f6c3418694b90b375f5e3cb635daa7eaf121488ad3704351050000019fae981e8b0000019fae981e8b0000019fae981e8b0000019fae981e8a0000019fae981e8a0302010401020003f216fa69ab6b93d0e748290eb3750b001ccefc9dded8277e0e3f3ffd22dd4ba6000000000000000000000000000000000000000000000000000000000000000090dc90af0c433f2b7dbe7e9a6e619d6ccdb4d888905b7e2c526177dba96f539d0201020102000136d535a3ec723f0ab87ca0d4911583cbc96f288745e73d7ee6bebdb43cb6448502010102fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e37b23938253cd548c27b39c93fab34ebd71dfe18941e66d7c50ef05c93b8bb10801000136d535a3ec723f0ab87ca0d4911583cbc96f288745e73d7ee6bebdb43cb6448502a68c663c7d945ae9f824cbfdcd4d67ef90f4bd4e9c0856cfae4b03bd7b344a4f030e9081b11a772a791303f333998d73d8a2ced522ee230780f738211381b42500029e9de5df2a753436897bd4979a65e48626a238e217d8d85bebc42bc5e46e77d55ffd669667b9a53b762adc0ee168e45621951690bbaf5e7de0ec700e2aea98f6", "timestamps": [ - 1785339684521, - 1785339684521, - 1785339684522, - 1785339684521, - 1785339684520 + 1785340632715, + 1785340632715, + 1785340632715, + 1785340632714, + 1785340632714 ], "tree_size": 7 } @@ -788,13 +788,13 @@ "name": "fixed-version-middle", "input": { "entry_timestamps": [ - 1785339684522, - 1785339684523, - 1785339684523, - 1785339684523, - 1785339684523, - 1785339684523, - 1785339684524 + 1785340632716, + 1785340632716, + 1785340632716, + 1785340632716, + 1785340632717, + 1785340632717, + 1785340632717 ], "label": "616c696365406578616d706c652e636f6d", "max_ahead": 10000, @@ -871,11 +871,11 @@ "expect": { "binary_ladder": [ { - "commitment": "c0fc23f4a5831373f33d4fc06d48ffad4662d86c5fd691aa76e7acf7b3a8559c", + "commitment": "4c59fd082a26ec9f6eedee964f5a38a2626256ffb2e093df05aad113d375dd12", "proof": "f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00" }, { - "commitment": "e999b2d84a6fc8094d610cbdb23b9a08efcc6e9d9859a0fff82671397415ce7e", + "commitment": "8cea2c0a7a795ab285859421199b372aa9ae1072d79c85ab8c5a60052b49e171", "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" }, { @@ -891,20 +891,20 @@ "proof": "901738f65e8b0d720acdb242304a8725f8ca1acbb009fbd89c72016887f57fd6d75db48330615e002cec7257a9620a57bd2679cafe860c43c92d86e7751ff5fa38ff87f334f665233fb88fe5d60f240e" } ], - "full_tree_head": "020000000000000007004088b6a12fa8c1c304184cec765e795668bf126ef527dcd98d4a25ad446276b719b97726ad4bf022f26a3a7a511175fc644ab9819985b01a8962861bca99b69a0d", + "full_tree_head": "02000000000000000700404e5dd09bc00ce528e7dc8e66dd2ec8fb43b66e9e6a3146ed7c2920f5d715be83cf1d9abd48964d1ee710f220c6260525d5107d2bdaef6717714d1c24f44ca10f", "inclusion": [ - "155419b192910e2194aa0fb889a6bef766401ae867fd591cddf28688ee04942d", - "44c9acb8ff1bfcd0a45ad24019ff9e0ff3239bd5ecea7f8648359b38b067f098", - "a4ee39e746ce73f7104458f47d7c111f141f4eaf050d695ff08cbceb3a045bcb" + "496372721184e7fbce33d4638a3268d2dc22356e36791d0776edfe8dfb318467", + "ad45053068efb805e23d892ff264b556c360d759ef61faf77f1f8433f9144901", + "d25dc3ed16d4196a07ab73ae4d122f9a088f2a343ac68713e2efdcbde0c48887" ], - "opening": "665d74fad7feaa5a4ceb86f733288bba", + "opening": "328b0759f9e4ae158bd572cf767a405d", "prefix_proofs": [ { "elements": [ - "3668fe0f43f96d85ded43e76055061314b10b3213aa34d6b59bfa4396b133967", + "9868bf3b8ae871d3861cee518ad188795ce5c7e6f5bac1212197b2ff014be9ae", "0000000000000000000000000000000000000000000000000000000000000000" ], - "encoding": "0601040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fe999b2d84a6fc8094d610cbdb23b9a08efcc6e9d9859a0fff82671397415ce7e0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fe999b2d84a6fc8094d610cbdb23b9a08efcc6e9d9859a0fff82671397415ce7e0202fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3c0fc23f4a5831373f33d4fc06d48ffad4662d86c5fd691aa76e7acf7b3a8559c0400023668fe0f43f96d85ded43e76055061314b10b3213aa34d6b59bfa4396b1339670000000000000000000000000000000000000000000000000000000000000000", + "encoding": "0601040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f8cea2c0a7a795ab285859421199b372aa9ae1072d79c85ab8c5a60052b49e1710202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f8cea2c0a7a795ab285859421199b372aa9ae1072d79c85ab8c5a60052b49e1710202fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e34c59fd082a26ec9f6eedee964f5a38a2626256ffb2e093df05aad113d375dd120400029868bf3b8ae871d3861cee518ad188795ce5c7e6f5bac1212197b2ff014be9ae0000000000000000000000000000000000000000000000000000000000000000", "results": [ { "depth": 4, @@ -921,7 +921,7 @@ { "depth": 2, "leaf": { - "commitment": "e999b2d84a6fc8094d610cbdb23b9a08efcc6e9d9859a0fff82671397415ce7e", + "commitment": "8cea2c0a7a795ab285859421199b372aa9ae1072d79c85ab8c5a60052b49e171", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -929,7 +929,7 @@ { "depth": 2, "leaf": { - "commitment": "e999b2d84a6fc8094d610cbdb23b9a08efcc6e9d9859a0fff82671397415ce7e", + "commitment": "8cea2c0a7a795ab285859421199b372aa9ae1072d79c85ab8c5a60052b49e171", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -937,7 +937,7 @@ { "depth": 4, "leaf": { - "commitment": "c0fc23f4a5831373f33d4fc06d48ffad4662d86c5fd691aa76e7acf7b3a8559c", + "commitment": "4c59fd082a26ec9f6eedee964f5a38a2626256ffb2e093df05aad113d375dd12", "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, "result_type": 2 @@ -946,14 +946,14 @@ } ], "prefix_roots": [ - "e5da99551e02291bdc49cf15b0b34c9a71d68a07451ee5d8b47d5fce40c2de27", - "7c98b71b7162984ee602b2a9946a4ad080a176de054340da02b443031e2c6c1c" + "d2fec9a496af3eeaee0c2661d178487d92d4f17b4bbe87b3948457a75f1c6b46", + "1a814272cea7f51319f3fe9246cb11b4dfec9eaeb74789d7eef42ac929f2955a" ], - "response": "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", + "response": "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", "timestamps": [ - 1785339684523, - 1785339684523, - 1785339684524 + 1785340632716, + 1785340632717, + 1785340632717 ], "tree_size": 7 } @@ -962,13 +962,13 @@ "name": "fixed-version-greatest", "input": { "entry_timestamps": [ - 1785339684525, - 1785339684525, - 1785339684525, - 1785339684526, - 1785339684526, - 1785339684526, - 1785339684526 + 1785340632718, + 1785340632719, + 1785340632719, + 1785340632719, + 1785340632719, + 1785340632720, + 1785340632720 ], "label": "616c696365406578616d706c652e636f6d", "max_ahead": 10000, @@ -1045,42 +1045,42 @@ "expect": { "binary_ladder": [ { - "commitment": "5c060ace19fc55ed82a65a0445f08f6e7db3d3cfb9881d6e3a1d7bce11896aae", + "commitment": "20f9aa37a5bcbcd927a91118e5af17454705cb2087e04d16e604e7a83d77a8b5", "proof": "f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00" }, { - "commitment": "efb49d1a8a4344bf4deea7b5ddc6c1338ececae4377b5b53de7be73e660c08bd", + "commitment": "4f77a9127d971eedc738e3a37a6f34d1e7d5382c1718a613d195ce17ef943e8d", "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" }, { - "commitment": "a949282efbb99cc93ab4fcb9ea14cb2dca5cd6044c6cb20b121988d688ebf935", + "commitment": "870e864ca6382c36787f6edc97cf73695d15f7699abcaa0a6f44755b5b42a551", "proof": "783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c" }, { "proof": "26fa91c612726fab2892d9d4bd0f73d52f623d1e536dd405e66fb3fb6c5cb157ac15cffa6eb16f43f72685f8f9b641d097435b4df6f5e3173987f2cec4d7c7506d20083e4c1037957595afa23e123409" }, { - "commitment": "76b1755a584c88553e1bbaf5e60771c74d895444a5362bec6e4214874f4c4e3f", + "commitment": "df3fae312448b0813aaf909d86275b37c27b184f7e52dfbcc90fcb3e0b583134", "proof": "e8064efcdf44e6573edc6fdfb948d4d36439d9e825e1e2d4b8b6ceddb5780bf5cb1207e328983ca5b32ff580ad6a1c96b080d6ee0290932ddb84ff37db88380cd470f7dddbf4e7dda6cc76c74592f603" }, { "proof": "79f3efd60d574baf99ba8351653f86889db173fc5321dbf9738f1fbb84e5fd442f8b21447179087c71097be04beecb9954b83f1c2e3e7346743de7e75ee452a0f1295f7844782688166c0e4c3ea7330a" } ], - "full_tree_head": "0200000000000000070040b2dd46bede1d41d8947bdcf15e9d277785976ac5a86508f80944e40dcc0005e456d91ec72aa66f3a3eb4bf7ef95775a30b6f5477be2314864a892c5eca2ec600", + "full_tree_head": "0200000000000000070040ee9c9e0348ccae6464b4986e82c4fbe0f257a14964419713f9533a8f6c8ed2a9d70e2a86bb38c7ebca3750b2e06436e2090069ecbc5cd0720659f3ed4afba80a", "inclusion": [ - "8900233f927dfba6f1b92e76d8c85d3a4adb5fdb44dcd8ea378d7d51dafdce11", - "8590b471c6abaf56f05c18a3d58436028dcd8f41201b9631dc9796633777543d", - "d86c6366bebc4703b0b8d66eaf3a8c4d308d0e45c02d2b34eeeae6f73bc5a550" + "e6f9fbe9181ae40278325145abd0486352f683e89b6bbbfb3cdf612a516b7beb", + "53a7ea9db99be34e1d4f2fcf5a563cb49618e42198827b9d5fc797a4d963e1e2", + "f38113ccf03a24786fbe5c659f89d84aa9f28a6fa6902814ad19d6b6da212dcb" ], - "opening": "31298398b0b5da80125569add737a4fd", + "opening": "13f341998f0b008108caac0a9df8e44e", "prefix_proofs": [ { "elements": [ - "2f5b3d0347674703386ffeacc07a96ae2ed18957702637eae24c87cbd5197d9c", + "1b499227429935bc01f5ae90137cb108db90304517c76a07114fe5d9de250fbd", "0000000000000000000000000000000000000000000000000000000000000000" ], - "encoding": "0501040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fefb49d1a8a4344bf4deea7b5ddc6c1338ececae4377b5b53de7be73e660c08bd0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fefb49d1a8a4344bf4deea7b5ddc6c1338ececae4377b5b53de7be73e660c08bd0200022f5b3d0347674703386ffeacc07a96ae2ed18957702637eae24c87cbd5197d9c0000000000000000000000000000000000000000000000000000000000000000", + "encoding": "0501040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f4f77a9127d971eedc738e3a37a6f34d1e7d5382c1718a613d195ce17ef943e8d0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f4f77a9127d971eedc738e3a37a6f34d1e7d5382c1718a613d195ce17ef943e8d0200021b499227429935bc01f5ae90137cb108db90304517c76a07114fe5d9de250fbd0000000000000000000000000000000000000000000000000000000000000000", "results": [ { "depth": 4, @@ -1097,7 +1097,7 @@ { "depth": 2, "leaf": { - "commitment": "efb49d1a8a4344bf4deea7b5ddc6c1338ececae4377b5b53de7be73e660c08bd", + "commitment": "4f77a9127d971eedc738e3a37a6f34d1e7d5382c1718a613d195ce17ef943e8d", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -1105,7 +1105,7 @@ { "depth": 2, "leaf": { - "commitment": "efb49d1a8a4344bf4deea7b5ddc6c1338ececae4377b5b53de7be73e660c08bd", + "commitment": "4f77a9127d971eedc738e3a37a6f34d1e7d5382c1718a613d195ce17ef943e8d", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -1114,16 +1114,16 @@ }, { "elements": [ - "6fdc9a9f72e6c31a8bc9731cffd4319c916f6876e124dd657e287868a576dd30", - "51fe955e38c6f1e5c1c7070f39811f49b1a37fc651fd822be12a329b63a945ee", - "18c5e2634a9a4a52ec5b884a4b4829de264328174a5890f4cf02b0da660a66f3" + "6a40291a0f2cfbd1df0ec7c8f8222c4cfc55392a1fa1e9eb8b5b4e453916065f", + "c4fbb9f4c6ad7cb1eb5213cd8437741fe2699b1454ca280cd3d8a4025e04cafe", + "d838cdbc559f70891eff6b95c4039ddbdc4145242fc0591b44039070a734e791" ], - "encoding": "03028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba876b1755a584c88553e1bbaf5e60771c74d895444a5362bec6e4214874f4c4e3f0301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45f8ea07427b8aac0649eb8df6753d473160f5ccdbc53aa4ffbff2c237156c9aed0200036fdc9a9f72e6c31a8bc9731cffd4319c916f6876e124dd657e287868a576dd3051fe955e38c6f1e5c1c7070f39811f49b1a37fc651fd822be12a329b63a945ee18c5e2634a9a4a52ec5b884a4b4829de264328174a5890f4cf02b0da660a66f3", + "encoding": "03028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8df3fae312448b0813aaf909d86275b37c27b184f7e52dfbcc90fcb3e0b5831340301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45672020d609903470f1075e11f6495d6f7d69051721a6638bf50a2b3f1c655b860200036a40291a0f2cfbd1df0ec7c8f8222c4cfc55392a1fa1e9eb8b5b4e453916065fc4fbb9f4c6ad7cb1eb5213cd8437741fe2699b1454ca280cd3d8a4025e04cafed838cdbc559f70891eff6b95c4039ddbdc4145242fc0591b44039070a734e791", "results": [ { "depth": 3, "leaf": { - "commitment": "76b1755a584c88553e1bbaf5e60771c74d895444a5362bec6e4214874f4c4e3f", + "commitment": "df3fae312448b0813aaf909d86275b37c27b184f7e52dfbcc90fcb3e0b583134", "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, "result_type": 2 @@ -1135,7 +1135,7 @@ { "depth": 2, "leaf": { - "commitment": "f8ea07427b8aac0649eb8df6753d473160f5ccdbc53aa4ffbff2c237156c9aed", + "commitment": "672020d609903470f1075e11f6495d6f7d69051721a6638bf50a2b3f1c655b86", "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" }, "result_type": 2 @@ -1144,18 +1144,18 @@ }, { "elements": [ - "6fdc9a9f72e6c31a8bc9731cffd4319c916f6876e124dd657e287868a576dd30", - "4c21c0f6cd75fdc79ff8bbb6322a5660713cc64dd1aa729b45c60de0355e1a0b", + "6a40291a0f2cfbd1df0ec7c8f8222c4cfc55392a1fa1e9eb8b5b4e453916065f", + "c87b8f0efed7e3f90e56903423136c0de5474c9a78cddfeae3156cb09f3d8dce", "0000000000000000000000000000000000000000000000000000000000000000", - "51fe955e38c6f1e5c1c7070f39811f49b1a37fc651fd822be12a329b63a945ee", - "18c5e2634a9a4a52ec5b884a4b4829de264328174a5890f4cf02b0da660a66f3" + "c4fbb9f4c6ad7cb1eb5213cd8437741fe2699b1454ca280cd3d8a4025e04cafe", + "d838cdbc559f70891eff6b95c4039ddbdc4145242fc0591b44039070a734e791" ], - "encoding": "02028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba876b1755a584c88553e1bbaf5e60771c74d895444a5362bec6e4214874f4c4e3f03010400056fdc9a9f72e6c31a8bc9731cffd4319c916f6876e124dd657e287868a576dd304c21c0f6cd75fdc79ff8bbb6322a5660713cc64dd1aa729b45c60de0355e1a0b000000000000000000000000000000000000000000000000000000000000000051fe955e38c6f1e5c1c7070f39811f49b1a37fc651fd822be12a329b63a945ee18c5e2634a9a4a52ec5b884a4b4829de264328174a5890f4cf02b0da660a66f3", + "encoding": "02028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8df3fae312448b0813aaf909d86275b37c27b184f7e52dfbcc90fcb3e0b58313403010400056a40291a0f2cfbd1df0ec7c8f8222c4cfc55392a1fa1e9eb8b5b4e453916065fc87b8f0efed7e3f90e56903423136c0de5474c9a78cddfeae3156cb09f3d8dce0000000000000000000000000000000000000000000000000000000000000000c4fbb9f4c6ad7cb1eb5213cd8437741fe2699b1454ca280cd3d8a4025e04cafed838cdbc559f70891eff6b95c4039ddbdc4145242fc0591b44039070a734e791", "results": [ { "depth": 3, "leaf": { - "commitment": "76b1755a584c88553e1bbaf5e60771c74d895444a5362bec6e4214874f4c4e3f", + "commitment": "df3fae312448b0813aaf909d86275b37c27b184f7e52dfbcc90fcb3e0b583134", "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, "result_type": 2 @@ -1168,11 +1168,11 @@ } ], "prefix_roots": [], - "response": "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", + "response": "0200000000000000070040ee9c9e0348ccae6464b4986e82c4fbe0f257a14964419713f9533a8f6c8ed2a9d70e2a86bb38c7ebca3750b2e06436e2090069ecbc5cd0720659f3ed4afba80a13f341998f0b008108caac0a9df8e44e00000007616c6963652d3706f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f000120f9aa37a5bcbcd927a91118e5af17454705cb2087e04d16e604e7a83d77a8b5414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02014f77a9127d971eedc738e3a37a6f34d1e7d5382c1718a613d195ce17ef943e8d783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c01870e864ca6382c36787f6edc97cf73695d15f7699abcaa0a6f44755b5b42a55126fa91c612726fab2892d9d4bd0f73d52f623d1e536dd405e66fb3fb6c5cb157ac15cffa6eb16f43f72685f8f9b641d097435b4df6f5e3173987f2cec4d7c7506d20083e4c1037957595afa23e12340900e8064efcdf44e6573edc6fdfb948d4d36439d9e825e1e2d4b8b6ceddb5780bf5cb1207e328983ca5b32ff580ad6a1c96b080d6ee0290932ddb84ff37db88380cd470f7dddbf4e7dda6cc76c74592f60301df3fae312448b0813aaf909d86275b37c27b184f7e52dfbcc90fcb3e0b58313479f3efd60d574baf99ba8351653f86889db173fc5321dbf9738f1fbb84e5fd442f8b21447179087c71097be04beecb9954b83f1c2e3e7346743de7e75ee452a0f1295f7844782688166c0e4c3ea7330a00030000019fae981e8f0000019fae981e900000019fae981e90030501040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f4f77a9127d971eedc738e3a37a6f34d1e7d5382c1718a613d195ce17ef943e8d0202a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f4f77a9127d971eedc738e3a37a6f34d1e7d5382c1718a613d195ce17ef943e8d0200021b499227429935bc01f5ae90137cb108db90304517c76a07114fe5d9de250fbd000000000000000000000000000000000000000000000000000000000000000003028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8df3fae312448b0813aaf909d86275b37c27b184f7e52dfbcc90fcb3e0b5831340301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45672020d609903470f1075e11f6495d6f7d69051721a6638bf50a2b3f1c655b860200036a40291a0f2cfbd1df0ec7c8f8222c4cfc55392a1fa1e9eb8b5b4e453916065fc4fbb9f4c6ad7cb1eb5213cd8437741fe2699b1454ca280cd3d8a4025e04cafed838cdbc559f70891eff6b95c4039ddbdc4145242fc0591b44039070a734e79102028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8df3fae312448b0813aaf909d86275b37c27b184f7e52dfbcc90fcb3e0b58313403010400056a40291a0f2cfbd1df0ec7c8f8222c4cfc55392a1fa1e9eb8b5b4e453916065fc87b8f0efed7e3f90e56903423136c0de5474c9a78cddfeae3156cb09f3d8dce0000000000000000000000000000000000000000000000000000000000000000c4fbb9f4c6ad7cb1eb5213cd8437741fe2699b1454ca280cd3d8a4025e04cafed838cdbc559f70891eff6b95c4039ddbdc4145242fc0591b44039070a734e791000003e6f9fbe9181ae40278325145abd0486352f683e89b6bbbfb3cdf612a516b7beb53a7ea9db99be34e1d4f2fcf5a563cb49618e42198827b9d5fc797a4d963e1e2f38113ccf03a24786fbe5c659f89d84aa9f28a6fa6902814ad19d6b6da212dcb", "timestamps": [ - 1785339684526, - 1785339684526, - 1785339684526 + 1785340632719, + 1785340632720, + 1785340632720 ], "tree_size": 7 } @@ -1181,13 +1181,13 @@ "name": "fixed-version-with-advertised-size", "input": { "entry_timestamps": [ - 1785339684527, - 1785339684528, - 1785339684528, - 1785339684528, - 1785339684528, - 1785339684529, - 1785339684529 + 1785340632721, + 1785340632721, + 1785340632722, + 1785340632722, + 1785340632722, + 1785340632722, + 1785340632722 ], "label": "616c696365406578616d706c652e636f6d", "last": 4, @@ -1265,35 +1265,35 @@ "expect": { "binary_ladder": [ { - "commitment": "8e94a89f383ac5848538836632d2c42ef577ae3a32f3ee3101801a15d7dfe56f", + "commitment": "bd77f410a6122572d35aa0c48a78fad06e9be124f59c87e3940d5b9086f9eb4c", "proof": "f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00" }, { - "commitment": "392895155692b319ed3482976b106f4f7456fc2b2e55ec1b60d96231843e68aa", + "commitment": "ad25284924f30e7b624ccb288f407a57721f47a2e39023caac49c46e45364b8e", "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" }, { - "commitment": "245fb72b8959dce1f85b2eba14a43e8210486b7a0a0d032c19c74d478669e861", + "commitment": "bbac2d8123f2c27d9974c5c5202da2e6fd90b557a7be1b0ebf687d99b0b69dbb", "proof": "783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c" }, { "proof": "4d493fd0ff6a928c26e821165294b8375d30556957c68899f5d44d8358cde8ffc491c2208f6d9e8dbcdf2b4005c8e7ff457d570474684ff317b6789806504feb346ad1667cac398558db901c11a15a00" } ], - "full_tree_head": "0200000000000000070040e802e611640b465adc3596e3e7dd3c5af41fd00bf7d0ea62109ceb947158e4ee52b2b170071ee8a9b237598f22cbd1ddf8a0801eb6b3f99f4f03c0bd40f8c607", + "full_tree_head": "0200000000000000070040a9f397185d6cb3f7d6a7cef9c9db02279fe160d47df6f55af36e3dbf2aba93acaa7fd85e3414d566b5a78e42585422d164e5081e3b4e30ae998ba9186cd91202", "inclusion": [ - "3daf4cb5e0ee1ecd2e19021cee26f3f48a6b0d7af826495a609796a03067c7f8", - "226884f88d199a3a06e0f3d2bad94959c0fcf471b276fd18e49993e684766a86", - "202329c5920284ef3711b0e004e74ed9104c29af89d2b8c1860c244c6b0d9ed4" + "c8ae879d60fdf415f30d251366d237f0cf562233891eeb29b00b599836370e05", + "88f6b54f93d0959ac7e5acce3b899df8d9025c4040a26b72578cc811a89d6ece", + "73a17755c2d91be42499e9c3820089fb3f782db87a3decfa221eabf846e5f95b" ], - "opening": "f97f60b2ceaf33a22efa52e941082d98", + "opening": "d48f397e2b2b731562a2639701e1fedb", "prefix_proofs": [ { "elements": [ - "790a4960829a6b3da7435df540996922a914aff5bc1cc5dba7fee7e71531df51", + "75a81f410360427449243e9a0596cc1f3f0a619e8cf5ad2e7d1d0df2520ef028", "0000000000000000000000000000000000000000000000000000000000000000" ], - "encoding": "030104010201040002790a4960829a6b3da7435df540996922a914aff5bc1cc5dba7fee7e71531df510000000000000000000000000000000000000000000000000000000000000000", + "encoding": "03010401020104000275a81f410360427449243e9a0596cc1f3f0a619e8cf5ad2e7d1d0df2520ef0280000000000000000000000000000000000000000000000000000000000000000", "results": [ { "depth": 4, @@ -1311,7 +1311,7 @@ }, { "elements": [], - "encoding": "040102010202fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e38e94a89f383ac5848538836632d2c42ef577ae3a32f3ee3101801a15d7dfe56f02023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee2d3bb7b3663d30921db84e1071f0b1decd5ae5e78da29048b3bd3534b246eecac010000", + "encoding": "040102010202fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3bd77f410a6122572d35aa0c48a78fad06e9be124f59c87e3940d5b9086f9eb4c02023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee2e5eb4a011d8f6fccf9ceaa9477842f409b36c447bf47f9f926ed434905337b26010000", "results": [ { "depth": 2, @@ -1324,7 +1324,7 @@ { "depth": 2, "leaf": { - "commitment": "8e94a89f383ac5848538836632d2c42ef577ae3a32f3ee3101801a15d7dfe56f", + "commitment": "bd77f410a6122572d35aa0c48a78fad06e9be124f59c87e3940d5b9086f9eb4c", "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, "result_type": 2 @@ -1332,7 +1332,7 @@ { "depth": 1, "leaf": { - "commitment": "d3bb7b3663d30921db84e1071f0b1decd5ae5e78da29048b3bd3534b246eecac", + "commitment": "e5eb4a011d8f6fccf9ceaa9477842f409b36c447bf47f9f926ed434905337b26", "vrf_output": "3ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee2" }, "result_type": 2 @@ -1341,15 +1341,15 @@ }, { "elements": [ - "6e343ba316c8181bfc37053f10548bbf01392e4bf51938ed9f51ec4c9f087e4f", - "46981f5f547810b188281d9de5157bb87659ba1122682b74a17cafebb59f6153" + "2b8106813339530a67319e46bfb7c8c253bdfd942faa1296c8aefa0d59583d11", + "edd5132cfb84d4b0ae8d94a3b9f1c579712e404d18ffd67385691433253fd990" ], - "encoding": "0202fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e38e94a89f383ac5848538836632d2c42ef577ae3a32f3ee3101801a15d7dfe56f02010200026e343ba316c8181bfc37053f10548bbf01392e4bf51938ed9f51ec4c9f087e4f46981f5f547810b188281d9de5157bb87659ba1122682b74a17cafebb59f6153", + "encoding": "0202fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3bd77f410a6122572d35aa0c48a78fad06e9be124f59c87e3940d5b9086f9eb4c02010200022b8106813339530a67319e46bfb7c8c253bdfd942faa1296c8aefa0d59583d11edd5132cfb84d4b0ae8d94a3b9f1c579712e404d18ffd67385691433253fd990", "results": [ { "depth": 2, "leaf": { - "commitment": "8e94a89f383ac5848538836632d2c42ef577ae3a32f3ee3101801a15d7dfe56f", + "commitment": "bd77f410a6122572d35aa0c48a78fad06e9be124f59c87e3940d5b9086f9eb4c", "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, "result_type": 2 @@ -1362,13 +1362,13 @@ } ], "prefix_roots": [ - "273c54c3d2f4d164121b7b376535a8a298719210c1c9c857e139a8e2b948c69f" + "7e453f5f00c229e5a5e86987ffc7bc45facf9ecffe8ef8051b6cafacccf0c45f" ], - "response": "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", + "response": "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", "timestamps": [ - 1785339684529, - 1785339684528, - 1785339684528 + 1785340632722, + 1785340632721, + 1785340632722 ], "tree_size": 7 } @@ -1377,7 +1377,7 @@ "name": "single-entry-log", "input": { "entry_timestamps": [ - 1785339684530 + 1785340632723 ], "label": "616c696365406578616d706c652e636f6d", "max_ahead": 10000, @@ -1407,13 +1407,13 @@ "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" } ], - "full_tree_head": "0200000000000000010040f91e39835c1280c3407b107636042a143ec5488574c7ad0e018ebcf36f5d362a7c037552b1d81d37e3c578bedd0d2280f267ed5b2983fc94d48d84809dce850c", + "full_tree_head": "02000000000000000100403cca72769974723c6d2ef3bd8891c478341894590eaa81b9e095aeb19909d4285dee09ef00befb4632b72687e819c7e24e678dd7f49611d5a08f920c2c618105", "inclusion": [], - "opening": "a1ac9528e69c2d9d8ec9f375a17dff77", + "opening": "fe22c92126a75a115e6b9a417a4db700", "prefix_proofs": [ { "elements": [], - "encoding": "02010002fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e395414c325f778d420709591a371fc937f3060522870ea705c440e7b6dca65c5c000000", + "encoding": "02010002fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e367506e6b5a33f8b16316d7d16516fc3eeb0f57af37a1e06fc91f61004b4aadc8000000", "results": [ { "depth": 0, @@ -1422,7 +1422,7 @@ { "depth": 0, "leaf": { - "commitment": "95414c325f778d420709591a371fc937f3060522870ea705c440e7b6dca65c5c", + "commitment": "67506e6b5a33f8b16316d7d16516fc3eeb0f57af37a1e06fc91f61004b4aadc8", "vrf_output": "fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e3" }, "result_type": 2 @@ -1431,9 +1431,9 @@ } ], "prefix_roots": [], - "response": "0200000000000000010040f91e39835c1280c3407b107636042a143ec5488574c7ad0e018ebcf36f5d362a7c037552b1d81d37e3c578bedd0d2280f267ed5b2983fc94d48d84809dce850c00000000a1ac9528e69c2d9d8ec9f375a17dff7700000007616c6963652d3102f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f0000414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf0200010000019fae89a6b20102010002fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e395414c325f778d420709591a371fc937f3060522870ea705c440e7b6dca65c5c000000000000", + "response": "02000000000000000100403cca72769974723c6d2ef3bd8891c478341894590eaa81b9e095aeb19909d4285dee09ef00befb4632b72687e819c7e24e678dd7f49611d5a08f920c2c61810500000000fe22c92126a75a115e6b9a417a4db70000000007616c6963652d3102f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f0000414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf0200010000019fae981e930102010002fd9ecf918e3b2a80ad06e2474e7a43de9578e3a10e0e4211d7c907e27179a1e367506e6b5a33f8b16316d7d16516fc3eeb0f57af37a1e06fc91f61004b4aadc8000000000000", "timestamps": [ - 1785339684530 + 1785340632723 ], "tree_size": 1, "version": 0 @@ -1443,13 +1443,13 @@ "name": "label-does-not-exist", "input": { "entry_timestamps": [ - 1785339684530, - 1785339684531, - 1785339684531, - 1785339684531, - 1785339684531, - 1785339684531, - 1785339684532 + 1785340632724, + 1785340632724, + 1785340632724, + 1785340632725, + 1785340632725, + 1785340632725, + 1785340632725 ], "label": "6e6f626f6479406578616d706c652e636f6d", "max_ahead": 10000, @@ -1528,25 +1528,25 @@ "proof": "4b04fea1cc97b5612a9cf074b619ab597e884754382b924f15782338f5758f3ced2ac7fcc0b4bd528d2101f7046d3fadb9735b459544ac75f8bc1bca20b4ae2f7ddeef21639ba2ea2b195d2a3879ae0f" } ], - "full_tree_head": "02000000000000000700401094b623e7a3e50f526b25648e6577f6ecae73b98a5658bd1294a98fa805f66291c564ca37a015796b3eba208ad9a7fbb33ceb84fe8d17557d3d5172a84a2b05", + "full_tree_head": "0200000000000000070040f42695aa420874d99f30fd65a52bd2b06ffc96cde84cfc82549770ab9c73d446bcdfc869b8beaf6614d47f7211253e8548bb9fb01e020ef3c843274e296aa90d", "inclusion": [ - "7e89284b778fb7a92a13cee1241b5c6685fe61417403b2a45e7b613caf24e391", - "fd68622899d201cb7a708c18865772de0a1cdea006c34c6c56f81efcacb75239", - "f1b012a9852b3a4efb3a9965c1030301074c030862a45957986701bed46c987e" + "1a201592668fe47683262583eb59b79567407e61e4c535162ec3b7b671097773", + "0f2818b81c5f38c22b52b1613d781d17a92886ac0c07979ae36c2c43db7e83ca", + "e8984fd41772627050d716966a193540ba283256d4be74be7621a97a3b182f48" ], "opening": "00000000000000000000000000000000", "prefix_proofs": [ { "elements": [ - "9d846a7ef7b916baa17bb8f76c7dd35cd1dab182aca59766dd4acb63f4de8d9a", - "f18c999066bc6b2f8b9199170aac67f15b4b96e881c915907913cfb406c1273f" + "6e83a05a1aaf77d561a73545e3de83e40052d95db0d0449908a4687a052996c9", + "18963ce0d787ade654ccd61a1596b9a2bef8fec435ff0e41e309e8dde1769ebd" ], - "encoding": "01023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee214982cd34f5c229e79fb31e0f9c09fea847f02916d50c5ca140a0d27ee5734770200029d846a7ef7b916baa17bb8f76c7dd35cd1dab182aca59766dd4acb63f4de8d9af18c999066bc6b2f8b9199170aac67f15b4b96e881c915907913cfb406c1273f", + "encoding": "01023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee264228a9aa773a3be29e1cf4345163ceefeda39e1c7ed8f0d2dfca06042d1adb80200026e83a05a1aaf77d561a73545e3de83e40052d95db0d0449908a4687a052996c918963ce0d787ade654ccd61a1596b9a2bef8fec435ff0e41e309e8dde1769ebd", "results": [ { "depth": 2, "leaf": { - "commitment": "14982cd34f5c229e79fb31e0f9c09fea847f02916d50c5ca140a0d27ee573477", + "commitment": "64228a9aa773a3be29e1cf4345163ceefeda39e1c7ed8f0d2dfca06042d1adb8", "vrf_output": "3ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee2" }, "result_type": 2 @@ -1555,15 +1555,15 @@ }, { "elements": [ - "9d846a7ef7b916baa17bb8f76c7dd35cd1dab182aca59766dd4acb63f4de8d9a", - "74efef3ecb3943da910228b6d9beebb398a729c5755681b8619bb4cffca373af" + "6e83a05a1aaf77d561a73545e3de83e40052d95db0d0449908a4687a052996c9", + "685fcbf93f1538181baaa66191677e4efbaff9c33207252c81ad90ab188f1fef" ], - "encoding": "01023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee214982cd34f5c229e79fb31e0f9c09fea847f02916d50c5ca140a0d27ee5734770200029d846a7ef7b916baa17bb8f76c7dd35cd1dab182aca59766dd4acb63f4de8d9a74efef3ecb3943da910228b6d9beebb398a729c5755681b8619bb4cffca373af", + "encoding": "01023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee264228a9aa773a3be29e1cf4345163ceefeda39e1c7ed8f0d2dfca06042d1adb80200026e83a05a1aaf77d561a73545e3de83e40052d95db0d0449908a4687a052996c9685fcbf93f1538181baaa66191677e4efbaff9c33207252c81ad90ab188f1fef", "results": [ { "depth": 2, "leaf": { - "commitment": "14982cd34f5c229e79fb31e0f9c09fea847f02916d50c5ca140a0d27ee573477", + "commitment": "64228a9aa773a3be29e1cf4345163ceefeda39e1c7ed8f0d2dfca06042d1adb8", "vrf_output": "3ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee2" }, "result_type": 2 @@ -1572,15 +1572,15 @@ }, { "elements": [ - "854e55c2b0f9efc0dbb73ced395be7edcdb5b79665b3db0068047764b76c5458", - "74efef3ecb3943da910228b6d9beebb398a729c5755681b8619bb4cffca373af" + "bf5eb7397f87667fdf288ed756120404984bce08e47bece37ed3b778fa375364", + "685fcbf93f1538181baaa66191677e4efbaff9c33207252c81ad90ab188f1fef" ], - "encoding": "01023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee214982cd34f5c229e79fb31e0f9c09fea847f02916d50c5ca140a0d27ee573477020002854e55c2b0f9efc0dbb73ced395be7edcdb5b79665b3db0068047764b76c545874efef3ecb3943da910228b6d9beebb398a729c5755681b8619bb4cffca373af", + "encoding": "01023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee264228a9aa773a3be29e1cf4345163ceefeda39e1c7ed8f0d2dfca06042d1adb8020002bf5eb7397f87667fdf288ed756120404984bce08e47bece37ed3b778fa375364685fcbf93f1538181baaa66191677e4efbaff9c33207252c81ad90ab188f1fef", "results": [ { "depth": 2, "leaf": { - "commitment": "14982cd34f5c229e79fb31e0f9c09fea847f02916d50c5ca140a0d27ee573477", + "commitment": "64228a9aa773a3be29e1cf4345163ceefeda39e1c7ed8f0d2dfca06042d1adb8", "vrf_output": "3ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee2" }, "result_type": 2 @@ -1589,11 +1589,11 @@ } ], "prefix_roots": [], - "response": "02000000000000000700401094b623e7a3e50f526b25648e6577f6ecae73b98a5658bd1294a98fa805f66291c564ca37a015796b3eba208ad9a7fbb33ceb84fe8d17557d3d5172a84a2b05000000000000000000000000000000000000000000000000014b04fea1cc97b5612a9cf074b619ab597e884754382b924f15782338f5758f3ced2ac7fcc0b4bd528d2101f7046d3fadb9735b459544ac75f8bc1bca20b4ae2f7ddeef21639ba2ea2b195d2a3879ae0f00030000019fae89a6b30000019fae89a6b30000019fae89a6b40301023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee214982cd34f5c229e79fb31e0f9c09fea847f02916d50c5ca140a0d27ee5734770200029d846a7ef7b916baa17bb8f76c7dd35cd1dab182aca59766dd4acb63f4de8d9af18c999066bc6b2f8b9199170aac67f15b4b96e881c915907913cfb406c1273f01023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee214982cd34f5c229e79fb31e0f9c09fea847f02916d50c5ca140a0d27ee5734770200029d846a7ef7b916baa17bb8f76c7dd35cd1dab182aca59766dd4acb63f4de8d9a74efef3ecb3943da910228b6d9beebb398a729c5755681b8619bb4cffca373af01023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee214982cd34f5c229e79fb31e0f9c09fea847f02916d50c5ca140a0d27ee573477020002854e55c2b0f9efc0dbb73ced395be7edcdb5b79665b3db0068047764b76c545874efef3ecb3943da910228b6d9beebb398a729c5755681b8619bb4cffca373af0000037e89284b778fb7a92a13cee1241b5c6685fe61417403b2a45e7b613caf24e391fd68622899d201cb7a708c18865772de0a1cdea006c34c6c56f81efcacb75239f1b012a9852b3a4efb3a9965c1030301074c030862a45957986701bed46c987e", + "response": "0200000000000000070040f42695aa420874d99f30fd65a52bd2b06ffc96cde84cfc82549770ab9c73d446bcdfc869b8beaf6614d47f7211253e8548bb9fb01e020ef3c843274e296aa90d000000000000000000000000000000000000000000000000014b04fea1cc97b5612a9cf074b619ab597e884754382b924f15782338f5758f3ced2ac7fcc0b4bd528d2101f7046d3fadb9735b459544ac75f8bc1bca20b4ae2f7ddeef21639ba2ea2b195d2a3879ae0f00030000019fae981e950000019fae981e950000019fae981e950301023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee264228a9aa773a3be29e1cf4345163ceefeda39e1c7ed8f0d2dfca06042d1adb80200026e83a05a1aaf77d561a73545e3de83e40052d95db0d0449908a4687a052996c918963ce0d787ade654ccd61a1596b9a2bef8fec435ff0e41e309e8dde1769ebd01023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee264228a9aa773a3be29e1cf4345163ceefeda39e1c7ed8f0d2dfca06042d1adb80200026e83a05a1aaf77d561a73545e3de83e40052d95db0d0449908a4687a052996c9685fcbf93f1538181baaa66191677e4efbaff9c33207252c81ad90ab188f1fef01023ff1b3e0e4016d2e4616cd0ab1b242c07f7484319e7e5c7bc86a6cb9dd341ee264228a9aa773a3be29e1cf4345163ceefeda39e1c7ed8f0d2dfca06042d1adb8020002bf5eb7397f87667fdf288ed756120404984bce08e47bece37ed3b778fa375364685fcbf93f1538181baaa66191677e4efbaff9c33207252c81ad90ab188f1fef0000031a201592668fe47683262583eb59b79567407e61e4c535162ec3b7b6710977730f2818b81c5f38c22b52b1613d781d17a92886ac0c07979ae36c2c43db7e83cae8984fd41772627050d716966a193540ba283256d4be74be7621a97a3b182f48", "timestamps": [ - 1785339684531, - 1785339684531, - 1785339684532 + 1785340632725, + 1785340632725, + 1785340632725 ], "tree_size": 7, "version": 0 @@ -1603,13 +1603,13 @@ "name": "fixed-version-above-the-greatest", "input": { "entry_timestamps": [ - 1785339684532, - 1785339684532, - 1785339684532, - 1785339684533, - 1785339684533, - 1785339684533, - 1785339684533 + 1785340632725, + 1785340632726, + 1785340632726, + 1785340632726, + 1785340632726, + 1785340632727, + 1785340632727 ], "label": "616c696365406578616d706c652e636f6d", "max_ahead": 10000, @@ -1686,15 +1686,15 @@ "expect": { "binary_ladder": [ { - "commitment": "d53344b6f5df79e15a7bc34262cc5607add94d7ce7c42675dc368b4944a51ccf", + "commitment": "153cf79a0fac56dbcc1b680effc5b8f2b5c9a49f4c7717190b5f99d4b70a1086", "proof": "f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00" }, { - "commitment": "c95ab3d760180d707dbfbcb80b20f5efc640d69aa81b5a8d6b3b1815c53056b0", + "commitment": "f7b7f3db1b851eea90ee8d19f1fd46187c033b3c56156505b03d36ce8a01ab43", "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" }, { - "commitment": "f56d70a5d3399ffdcc2e1f2d48bf01f945bfc9d94fe2a6ea848e7aed04a59c42", + "commitment": "1e6fa2073aeef59a5efa022a4b6345f55bcfd281876c918ee322d589da5f3a21", "proof": "783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c" }, { @@ -1731,20 +1731,20 @@ "proof": "88d1e8277e88abf08a92eda5845d19af3f41bf8af907dfa823e26f5e1b2a5abf254e197a5f52cbaa4c183fbdbef46551aed90df5c61b7e17a31afef8fc2b84c876c0e5b49f07a87ff054a51854229e0b" } ], - "full_tree_head": "0200000000000000070040cf98fc3a577470644159927feac23bdaec9df8cd57a75e171123f428ee2eccf09cae81628541654c0fff8164e670831ba2fd217f12d4d77149674b64f5b1f30a", + "full_tree_head": "02000000000000000700407b74bc35bd2e878143e8ad9ec39075d0f3aaefe202e03963c8218e2385f2fce82b7898d853e7bc53d197b041958012a33309b78a8fa5693201cb2e7778b2c804", "inclusion": [ - "710868cb1ff9382841f71bac687efab6884815c9547d3ba249f731f781a8ac77", - "e1a51b369ca42d35730bc643ce24ff65828ec7f7fde177d174ab8b3a76668846", - "117ec494e5d071ceed9f2ee60c8fa386122bbe623833ebb09fc6cf083c63f947" + "552f308dbe58b4b364a0388f7983d77a2e69216e00b6dc486531f34bbc3bd9fe", + "97f8ab875a470b792ff484cbc823a1451a128ce91017836869f8c009cc3d69ad", + "9c4daea901db40c1c77058b7f471e536e0ed1d628b423498b379dd15238d8620" ], "opening": "00000000000000000000000000000000", "prefix_proofs": [ { "elements": [ - "e38fbc5ec41c63d419a46ea66d3ff15bf55f58023c1f0922dcc6425c00eff1c3", + "831d5091f6464708f85273fdea5a012f5f6cf3d37c22d9623380711ead3e6941", "0000000000000000000000000000000000000000000000000000000000000000" ], - "encoding": "0401040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7fc95ab3d760180d707dbfbcb80b20f5efc640d69aa81b5a8d6b3b1815c53056b0020002e38fbc5ec41c63d419a46ea66d3ff15bf55f58023c1f0922dcc6425c00eff1c30000000000000000000000000000000000000000000000000000000000000000", + "encoding": "0401040102010402a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7ff7b7f3db1b851eea90ee8d19f1fd46187c033b3c56156505b03d36ce8a01ab43020002831d5091f6464708f85273fdea5a012f5f6cf3d37c22d9623380711ead3e69410000000000000000000000000000000000000000000000000000000000000000", "results": [ { "depth": 4, @@ -1761,7 +1761,7 @@ { "depth": 2, "leaf": { - "commitment": "c95ab3d760180d707dbfbcb80b20f5efc640d69aa81b5a8d6b3b1815c53056b0", + "commitment": "f7b7f3db1b851eea90ee8d19f1fd46187c033b3c56156505b03d36ce8a01ab43", "vrf_output": "a23e5c9a8983f63dd4358efa06aa4d2077629a50c452b7e3da7a1b26e6181f7f" }, "result_type": 2 @@ -1770,16 +1770,16 @@ }, { "elements": [ - "e38fbc5ec41c63d419a46ea66d3ff15bf55f58023c1f0922dcc6425c00eff1c3", - "e3fc939f120d6e5d07ea9d04052ec2243115099c4bbb6ad9e2aba0fa6651eebf", - "e0b2144bb56b78df3ec405d9c4ad06eb38d5dd4396260fe32688ca127db40e06" + "831d5091f6464708f85273fdea5a012f5f6cf3d37c22d9623380711ead3e6941", + "0ff899d9e77687cd2371e4e4bee706a9cc9279924c33bca36151a667e46eba37", + "36588434d671933f645f8d2203f8a9b40d110933284b603bea577b1f0de35006" ], - "encoding": "01028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba87da862896c627751672c6a43b21b57335a906920cdcadf6f81640dbb6c84e04f030003e38fbc5ec41c63d419a46ea66d3ff15bf55f58023c1f0922dcc6425c00eff1c3e3fc939f120d6e5d07ea9d04052ec2243115099c4bbb6ad9e2aba0fa6651eebfe0b2144bb56b78df3ec405d9c4ad06eb38d5dd4396260fe32688ca127db40e06", + "encoding": "01028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8a84aee5646ce5b359e27120588271609b039c2ab8a70582439ac88240bfb4de9030003831d5091f6464708f85273fdea5a012f5f6cf3d37c22d9623380711ead3e69410ff899d9e77687cd2371e4e4bee706a9cc9279924c33bca36151a667e46eba3736588434d671933f645f8d2203f8a9b40d110933284b603bea577b1f0de35006", "results": [ { "depth": 3, "leaf": { - "commitment": "7da862896c627751672c6a43b21b57335a906920cdcadf6f81640dbb6c84e04f", + "commitment": "a84aee5646ce5b359e27120588271609b039c2ab8a70582439ac88240bfb4de9", "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, "result_type": 2 @@ -1788,16 +1788,16 @@ }, { "elements": [ - "4e72f356f17262974c0cf2a4d561d97c3303a1ba4e575591f9b95d580e864d8b", - "e3fc939f120d6e5d07ea9d04052ec2243115099c4bbb6ad9e2aba0fa6651eebf", - "e0b2144bb56b78df3ec405d9c4ad06eb38d5dd4396260fe32688ca127db40e06" + "871d19e4ba8dab17f854b16ce9463dfe3c5e022d8910c0570c5806e057b118dd", + "0ff899d9e77687cd2371e4e4bee706a9cc9279924c33bca36151a667e46eba37", + "36588434d671933f645f8d2203f8a9b40d110933284b603bea577b1f0de35006" ], - "encoding": "01028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba87da862896c627751672c6a43b21b57335a906920cdcadf6f81640dbb6c84e04f0300034e72f356f17262974c0cf2a4d561d97c3303a1ba4e575591f9b95d580e864d8be3fc939f120d6e5d07ea9d04052ec2243115099c4bbb6ad9e2aba0fa6651eebfe0b2144bb56b78df3ec405d9c4ad06eb38d5dd4396260fe32688ca127db40e06", + "encoding": "01028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8a84aee5646ce5b359e27120588271609b039c2ab8a70582439ac88240bfb4de9030003871d19e4ba8dab17f854b16ce9463dfe3c5e022d8910c0570c5806e057b118dd0ff899d9e77687cd2371e4e4bee706a9cc9279924c33bca36151a667e46eba3736588434d671933f645f8d2203f8a9b40d110933284b603bea577b1f0de35006", "results": [ { "depth": 3, "leaf": { - "commitment": "7da862896c627751672c6a43b21b57335a906920cdcadf6f81640dbb6c84e04f", + "commitment": "a84aee5646ce5b359e27120588271609b039c2ab8a70582439ac88240bfb4de9", "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, "result_type": 2 @@ -1806,11 +1806,11 @@ } ], "prefix_roots": [], - "response": "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", + "response": "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", "timestamps": [ - 1785339684533, - 1785339684533, - 1785339684533 + 1785340632726, + 1785340632727, + 1785340632727 ], "tree_size": 7 } @@ -1819,13 +1819,13 @@ "name": "fixed-version-with-expired-entries", "input": { "entry_timestamps": [ - 1785339684536, - 1785339684637, - 1785339684738, - 1785339684840, - 1785339684941, - 1785339685042, - 1785339685144 + 1785340632729, + 1785340632831, + 1785340632932, + 1785340633034, + 1785340633135, + 1785340633238, + 1785340633340 ], "label": "616c696365406578616d706c652e636f6d", "max_ahead": 10000, @@ -1902,15 +1902,15 @@ "expect": { "binary_ladder": [ { - "commitment": "71afb38ea19da38cf40d0f3f185541d4eef95ac90decb7f06fb8290d55fb82f5", + "commitment": "25acf037bc760217523198cebdf2f4083d2bd6643cf4560c94fb714adb503d8f", "proof": "f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00" }, { - "commitment": "0226713cbeed47ea24045a1a408a206bd22013c71a7fa8dd3336985a46ae9113", + "commitment": "fb03094a7f9144c8fd8606644a7c32e5e72767405f7274d36e224c070e9c7d0b", "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" }, { - "commitment": "a3b4038995ca7b2b01858e3a9d10c7c7e62d5a7c1bca940d7d78f244d7687aa7", + "commitment": "feda6620ba14359973e8b88e96d356b88e170ac2b410d414eb53b40ae06dfb55", "proof": "783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c" }, { @@ -1923,22 +1923,22 @@ "proof": "79f3efd60d574baf99ba8351653f86889db173fc5321dbf9738f1fbb84e5fd442f8b21447179087c71097be04beecb9954b83f1c2e3e7346743de7e75ee452a0f1295f7844782688166c0e4c3ea7330a" } ], - "full_tree_head": "02000000000000000700403be437138566e7e8c67c7081473cbe9e7d76364117d71e43062213cbb6c55314da38b3f2f083dfe104b5e5e225b3ef05f79aa9c7a8044172caef569d95fe6204", + "full_tree_head": "020000000000000007004013be33afd1dc39a2d2a68def31f61a1bf63192ccd9edda5212a95b2f9d6475b1842fd3cb9b83927ac7bccdd20f309694a3484a447fc53535aede9fa27e33620e", "inclusion": [ - "c6a144d151769a883fdbad27d08c26dea348e0b5dee589445a5f113a730e3a86", - "97ce012add2c79d6dae5085aab68e569b9abd952b5ba4a8fa249c4b9b3896fe5", - "d3e2429461aae8e76757a075f3e5b1f4ad920e33820f54efa669efea11bb7934" + "ccd66dfaae98c01943217badab667ed84a8006c739b21c1834773dd2c95fd386", + "10190ad0064e5f6ce44fb846b5bb944572802d7d55e141222a349d6ddf406369", + "91cd716e56f47776f550df7ebfbd5a3c27cb4d57df2238b9d374ad81e0c21488" ], - "opening": "7e36d78bb75d61f01f724ecef6a72609", + "opening": "d3559f404103d6d0d139d3d63964d561", "prefix_proofs": [ { "elements": [ - "f94fef2502101b31e3ef53412f4ad5878666e91c093bbacd99e8bd210e741572", + "00239a471b2aaae858e64983a0a2da026e7ea5b6bfa16dbe55b11602589cb435", "0000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000000", - "b2419c88b8335cdcf69468df2f86f695fc4c4701d9457ee2149e9df14834c9df" + "56e092261cf66cd840158caceac0269efa1307fde3a758c804109fc5538456a4" ], - "encoding": "06010601030104028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba839988969e39bea5eada9f0376ce3ca4a233ab92de8754a371ea7a93fcb44560e0301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45fd0be86e86c5c85e66332a524c3cf91741ebdfd433c5dc398a5b4ed2344c2bb8020004f94fef2502101b31e3ef53412f4ad5878666e91c093bbacd99e8bd210e74157200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b2419c88b8335cdcf69468df2f86f695fc4c4701d9457ee2149e9df14834c9df", + "encoding": "06010601030104028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba86db1332b444a0c9df42ec8c6d1842ffbfcc55f099c2d483f68e1724ceac926d60301030249ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45c5b3acb82dbd06328467c960b0aae84a2a0f8e4d883767dd29460823fb037d3d02000400239a471b2aaae858e64983a0a2da026e7ea5b6bfa16dbe55b11602589cb4350000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000056e092261cf66cd840158caceac0269efa1307fde3a758c804109fc5538456a4", "results": [ { "depth": 6, @@ -1955,7 +1955,7 @@ { "depth": 3, "leaf": { - "commitment": "39988969e39bea5eada9f0376ce3ca4a233ab92de8754a371ea7a93fcb44560e", + "commitment": "6db1332b444a0c9df42ec8c6d1842ffbfcc55f099c2d483f68e1724ceac926d6", "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, "result_type": 2 @@ -1967,7 +1967,7 @@ { "depth": 2, "leaf": { - "commitment": "fd0be86e86c5c85e66332a524c3cf91741ebdfd433c5dc398a5b4ed2344c2bb8", + "commitment": "c5b3acb82dbd06328467c960b0aae84a2a0f8e4d883767dd29460823fb037d3d", "vrf_output": "49ac592e66e6cdf540930a2de58d345878986b1e337ee0aeb9d5c3730be70e45" }, "result_type": 2 @@ -1976,14 +1976,14 @@ } ], "prefix_roots": [ - "d5c6ba321a45f309cef3cbbc5e651f84b8c7bbccbe1c9a8b0b1e77ef607c23f4", - "c86d37be7fff1f8b7b3119a68beb800919faca7bb01353a0751e6883c10ef613" + "87ecaf645511aff4ad4c385f8bd15fdda050733150daf3ed63dbe4b1f4aa795c", + "823d1433a8d7371203a9ca996681a1452582607c561f0df3dd992a51fd093fb1" ], - "response": "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", + "response": "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", "timestamps": [ - 1785339684840, - 1785339685042, - 1785339685144 + 1785340633034, + 1785340633238, + 1785340633340 ], "tree_size": 7 } @@ -1992,13 +1992,13 @@ "name": "fixed-version-expired-target", "input": { "entry_timestamps": [ - 1785339685150, - 1785339685251, - 1785339685353, - 1785339685456, - 1785339685557, - 1785339685660, - 1785339685761 + 1785340633346, + 1785340633447, + 1785340633548, + 1785340633649, + 1785340633751, + 1785340633853, + 1785340633955 ], "label": "616c696365406578616d706c652e636f6d", "max_ahead": 10000, @@ -2080,13 +2080,13 @@ "name": "greatest-version-with-expired-entries", "input": { "entry_timestamps": [ - 1785339685764, - 1785339685865, - 1785339685966, - 1785339686068, - 1785339686170, - 1785339686271, - 1785339686373 + 1785340633958, + 1785340634060, + 1785340634163, + 1785340634265, + 1785340634367, + 1785340634469, + 1785340634572 ], "label": "616c696365406578616d706c652e636f6d", "max_ahead": 10000, @@ -2162,46 +2162,46 @@ "expect": { "binary_ladder": [ { - "commitment": "2305e7786307b642bac152cafda1ce6b85e7b996866664e3b613f1c3eca6e452", + "commitment": "e42e7a4b50fdb0f96d17d5e92ea94ff2ce1fc0e359c43b7153125c6898aedb51", "proof": "f73cf4600d657de46b1c253865fb864c21c61d2f953e0de8783551a320a6ead8db24ada8c88dc61ef91918546bfbcf7a368978fa3fd0be323df12dd9e33158b6030f85a1626f67b9ce76824925638f00" }, { - "commitment": "69818f39ab4fac281fb849219120f133026e564fa39637c9a9046489f58fc91b", + "commitment": "3564e579a1344ccdf00c3db139e3ce88996c395a6d7fdc357f4bf662923f6b2d", "proof": "414bf5100e0e7375962137f3033ad5f665473dc0ef92ae6ee72bc707a4823f18b1ada9796df18a84c12362f3b0c62d3de28c2225f21bcad3800f653155c2b53c174111c6b7b441301e95ad238c2edf02" }, { - "commitment": "787f83b35959f20afbf273b7725aea77dd21cf902efc207efb31b24f034128e5", + "commitment": "4c3bdecc94580254541e076a4997fdc48d5881b02bf28512f165a7eee7abcfc7", "proof": "783c97f3a538e3b5efd329babbfd1b04779837fe3bc02ef1853f1a5c230c9fba2ff677633ff6a6fec42460a0544fa203fd64e801091419ada272aabff336e6be2b78ca81ad48ba56b279a340ace4f90c" }, { "proof": "26fa91c612726fab2892d9d4bd0f73d52f623d1e536dd405e66fb3fb6c5cb157ac15cffa6eb16f43f72685f8f9b641d097435b4df6f5e3173987f2cec4d7c7506d20083e4c1037957595afa23e123409" }, { - "commitment": "da62ce31a1379e0d723dd213032f8be40fa9bf864dc8c56f9944a1ff77830f7b", + "commitment": "f63f73bf6b9764276d593d106d51f132858ff58729288d467369edd7f97f6784", "proof": "e8064efcdf44e6573edc6fdfb948d4d36439d9e825e1e2d4b8b6ceddb5780bf5cb1207e328983ca5b32ff580ad6a1c96b080d6ee0290932ddb84ff37db88380cd470f7dddbf4e7dda6cc76c74592f603" }, { "proof": "79f3efd60d574baf99ba8351653f86889db173fc5321dbf9738f1fbb84e5fd442f8b21447179087c71097be04beecb9954b83f1c2e3e7346743de7e75ee452a0f1295f7844782688166c0e4c3ea7330a" } ], - "full_tree_head": "0200000000000000070040fa64d343e6de91fad776d166f8f407c470897c1db21905367b3ec26f20c16df046e40acc443afc105a34ec68c6824d0a4762742ee27ddf8399e09d7e8ed8af02", + "full_tree_head": "0200000000000000070040dba3073a80586490e848e919dd672646da2e4e935bf999d22ff2bf193c325ddc767a9aba13f6150e907703c5e2736646f363c680af93878b1f894a9da32c9b0f", "inclusion": [ - "10ca84058bbfd477941899bce720f43fe9f26588d98b280be99858e6bfb28910", - "aba0c4ab79ff86a2842a32738c2a8a0ef31e1f24faa7cbb4448a5f9490365001", - "5faf9b98c781e1ff8fe4c508bd204e8c96f251bdccc0e5f12b1df334d7d8b2bc" + "2fa95a841e871f6d2a7bc24d17f0ab1b32058330c81a43316ef032a8b5ed8686", + "3eded459d1250f7e4a8693498bb1f0f793de37df673c5af15b0472dfba57bf2e", + "d9c72316500a1d5f3b9f72df70d8e23f84d2f1a3b9781144819216cc69bb74a8" ], - "opening": "0f32c18fc3880d6536baf92b1ee464ac", + "opening": "7cb700bae7e6939a9acf99d090c220dd", "prefix_proofs": [ { "elements": [ - "b4acf09b14606cd33d77b15a0fb77ac8ae7076c4721b438a19cf94394cbe69c9", - "2b8feab63d1bf1ac8c0d113362d1ce565c80443b538db81b403e99e89c73fcd4", + "698322aec3525b3346ab87fb8d8fd40b345c7b9381faff4999a9bca0f14b3556", + "8d7a106625e8dd911f7e9e937a48a4ebf7a8312887e77d8782e92c814b44c4b0", "0000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000000", - "12396f2f5e217313b6501f5da9e20854f03f90996a79417e7253afd58dbc9919" + "5fe8408a764fbf05d5e14a92a0415b44b5024e3107c78a2b5157dc69625e0f9e" ], - "encoding": "06010601030104028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8da62ce31a1379e0d723dd213032f8be40fa9bf864dc8c56f9944a1ff77830f7b03010301040006b4acf09b14606cd33d77b15a0fb77ac8ae7076c4721b438a19cf94394cbe69c92b8feab63d1bf1ac8c0d113362d1ce565c80443b538db81b403e99e89c73fcd400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012396f2f5e217313b6501f5da9e20854f03f90996a79417e7253afd58dbc9919", + "encoding": "06010601030104028bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8f63f73bf6b9764276d593d106d51f132858ff58729288d467369edd7f97f678403010301040006698322aec3525b3346ab87fb8d8fd40b345c7b9381faff4999a9bca0f14b35568d7a106625e8dd911f7e9e937a48a4ebf7a8312887e77d8782e92c814b44c4b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005fe8408a764fbf05d5e14a92a0415b44b5024e3107c78a2b5157dc69625e0f9e", "results": [ { "depth": 6, @@ -2218,7 +2218,7 @@ { "depth": 3, "leaf": { - "commitment": "da62ce31a1379e0d723dd213032f8be40fa9bf864dc8c56f9944a1ff77830f7b", + "commitment": "f63f73bf6b9764276d593d106d51f132858ff58729288d467369edd7f97f6784", "vrf_output": "8bae45f7cb557efa69cdfc5607df19343b91071c69818c06a124adec721d3ba8" }, "result_type": 2 @@ -2235,14 +2235,14 @@ } ], "prefix_roots": [ - "152c7e02b31624d5a181d05936ca3a963bfc6c8c525531cb1e054ee7c2eaf4f9", - "34150448ca8d154ea5e4f1c3d919bb02822dd691752a527049eb07175400c567" + "ce4ca46898a68265964e8172bcd75531a954d9b00d523f7c83f81555bc06a76d", + "9b7f02cc8b5dd3260b8d7dc0793d55c5fe50f4f85c4637df97f5d6d29bfb99b1" ], - "response": "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", + "response": "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", "timestamps": [ - 1785339686068, - 1785339686271, - 1785339686373 + 1785340634265, + 1785340634469, + 1785340634572 ], "tree_size": 7, "version": 6