diff --git a/wnfs-bench/Cargo.toml b/wnfs-bench/Cargo.toml index 186fc0fa..4ebb5f64 100644 --- a/wnfs-bench/Cargo.toml +++ b/wnfs-bench/Cargo.toml @@ -16,7 +16,7 @@ rand = "0.8" wnfs = { path = "../wnfs" } wnfs-common = { path = "../wnfs-common", features = ["test_utils"] } wnfs-hamt = { path = "../wnfs-hamt", features = ["test_utils"] } -wnfs-nameaccumulator = { path = "../wnfs-nameaccumulator" } +wnfs-nameaccumulator = { path = "../wnfs-nameaccumulator", features = ["num-bigint-dig", "rug"] } [[bench]] name = "hamt" diff --git a/wnfs-bench/nameaccumulator.rs b/wnfs-bench/nameaccumulator.rs index cfd11484..6105fa2e 100644 --- a/wnfs-bench/nameaccumulator.rs +++ b/wnfs-bench/nameaccumulator.rs @@ -1,41 +1,72 @@ use criterion::{criterion_group, criterion_main, BatchSize, Criterion}; use rand::{thread_rng, Rng}; -use wnfs_nameaccumulator::{AccumulatorSetup, NameAccumulator, NameSegment}; +use wnfs_nameaccumulator::{AccumulatorSetup, BigNumDig, BigNumRug, NameAccumulator, NameSegment}; fn name_segment_from_digest(c: &mut Criterion) { - c.bench_function("NameSegment::new_hashed", |b| { + c.bench_function("NameSegment::::new_hashed", |b| { b.iter_batched( || thread_rng().gen::<[u8; 32]>(), - |sth| NameSegment::new_hashed("wnfs benchmarks", sth), + |sth| NameSegment::::new_hashed("wnfs benchmarks", sth), + BatchSize::SmallInput, + ); + }); + c.bench_function("NameSegment::::new_hashed", |b| { + b.iter_batched( + || thread_rng().gen::<[u8; 32]>(), + |sth| NameSegment::::new_hashed("wnfs benchmarks", sth), BatchSize::SmallInput, ); }); } fn name_segment_rng(c: &mut Criterion) { - c.bench_function("NameSegment::new(rng)", |b| { - b.iter(|| NameSegment::new(&mut thread_rng())); + c.bench_function("NameSegment::::new(rng)", |b| { + b.iter(|| NameSegment::::new(&mut thread_rng())); + }); + c.bench_function("NameSegment::::new(rng)", |b| { + b.iter(|| NameSegment::::new(&mut thread_rng())); }); } fn name_accumulator_add(c: &mut Criterion) { - let setup = &AccumulatorSetup::from_rsa_2048(&mut thread_rng()); - c.bench_function("NameAccumulator::add", |b| { + let setup = &AccumulatorSetup::::from_rsa_2048(&mut thread_rng()); + c.bench_function("NameAccumulator::::add", |b| { + b.iter_batched( + || NameSegment::::new(&mut thread_rng()), + |segment| NameAccumulator::::empty(setup).add(Some(&segment), setup), + BatchSize::SmallInput, + ) + }); + let setup = &AccumulatorSetup::::from_rsa_2048(&mut thread_rng()); + c.bench_function("NameAccumulator::::add", |b| { b.iter_batched( - || NameSegment::new(&mut thread_rng()), - |segment| NameAccumulator::empty(setup).add(Some(&segment), setup), + || NameSegment::::new(&mut thread_rng()), + |segment| NameAccumulator::::empty(setup).add(Some(&segment), setup), BatchSize::SmallInput, ) }); } fn name_accumulator_serialize(c: &mut Criterion) { - let setup = &AccumulatorSetup::from_rsa_2048(&mut thread_rng()); - c.bench_function("NameAccumulator serialization", |b| { + let setup = &AccumulatorSetup::::from_rsa_2048(&mut thread_rng()); + c.bench_function("NameAccumulator:: serialization", |b| { + b.iter_batched( + || { + let segment = NameSegment::::new(&mut thread_rng()); + let mut name = NameAccumulator::::empty(setup); + name.add(Some(&segment), setup); + name + }, + |name| name.into_bytes(), + BatchSize::SmallInput, + ) + }); + let setup = &AccumulatorSetup::::from_rsa_2048(&mut thread_rng()); + c.bench_function("NameAccumulator:: serialization", |b| { b.iter_batched( || { - let segment = NameSegment::new(&mut thread_rng()); - let mut name = NameAccumulator::empty(setup); + let segment = NameSegment::::new(&mut thread_rng()); + let mut name = NameAccumulator::::empty(setup); name.add(Some(&segment), setup); name }, diff --git a/wnfs-common/src/utils/test.rs b/wnfs-common/src/utils/test.rs index 60988926..f0f429f8 100644 --- a/wnfs-common/src/utils/test.rs +++ b/wnfs-common/src/utils/test.rs @@ -7,8 +7,8 @@ use bytes::Bytes; use libipld::{ cbor::DagCborCodec, json::DagJsonCodec, - prelude::{Decode, Encode}, - Cid, Ipld, + prelude::{Decode, Encode, References}, + Cid, Ipld, IpldCodec, }; use parking_lot::Mutex; use proptest::{ @@ -18,7 +18,7 @@ use proptest::{ use serde::{Deserialize, Serialize}; use serde_json::Value; use std::{ - collections::{BTreeMap, HashMap}, + collections::{HashMap, HashSet, VecDeque}, io::Cursor, }; @@ -42,6 +42,7 @@ base64_serde_type!(Base64Standard, base64::engine::general_purpose::STANDARD); #[derive(Serialize, Deserialize, Debug)] pub struct BlockSnapshot { + pub cid: String, pub value: Value, #[serde(with = "Base64Standard")] pub bytes: Bytes, @@ -59,10 +60,10 @@ pub trait Sampleable { impl SnapshotBlockStore { pub async fn get_block_snapshot(&self, cid: &Cid) -> Result { let bytes = self.get_block(cid).await?; - self.handle_block(cid, &bytes).map(|(_, snapshot)| snapshot) + self.handle_block(cid, &bytes) } - pub fn handle_block(&self, cid: &Cid, bytes: &Bytes) -> Result<(String, BlockSnapshot)> { + pub fn handle_block(&self, cid: &Cid, bytes: &Bytes) -> Result { let ipld = match cid.codec() { CODEC_DAG_CBOR => Ipld::decode(DagCborCodec, &mut Cursor::new(bytes))?, CODEC_RAW => match self.block_handlers.lock().get(cid) { @@ -76,22 +77,34 @@ impl SnapshotBlockStore { ipld.encode(DagJsonCodec, &mut json_bytes)?; let value = serde_json::from_slice(&json_bytes)?; - Ok(( - cid.to_string(), - BlockSnapshot { - value, - bytes: bytes.clone(), - }, - )) + Ok(BlockSnapshot { + cid: cid.to_string(), + value, + bytes: bytes.clone(), + }) } - pub fn get_all_block_snapshots(&self) -> Result> { - self.inner - .0 - .lock() - .iter() - .map(|(cid, bytes)| self.handle_block(cid, bytes)) - .collect() + pub async fn get_dag_snapshot(&self, root_cid: Cid) -> Result> { + let mut frontier = VecDeque::from([root_cid]); + let mut visited = HashSet::new(); + let mut snapshots = Vec::new(); + + while let Some(cid) = frontier.pop_front() { + if !visited.insert(cid) { + continue; + } + + let snapshot = self.get_block_snapshot(&cid).await?; + let codec: IpldCodec = cid.codec().try_into()?; + >::references( + codec, + &mut Cursor::new(&snapshot.bytes), + &mut frontier, + )?; + snapshots.push(snapshot); + } + + Ok(snapshots) } pub fn add_block_handler(&mut self, cid: Cid, f: BlockHandler) { diff --git a/wnfs-hamt/src/snapshots/wnfs_hamt__hamt__snapshot_tests__hamt.snap b/wnfs-hamt/src/snapshots/wnfs_hamt__hamt__snapshot_tests__hamt.snap index 2217f7d7..a2a30ffd 100644 --- a/wnfs-hamt/src/snapshots/wnfs_hamt__hamt__snapshot_tests__hamt.snap +++ b/wnfs-hamt/src/snapshots/wnfs_hamt__hamt__snapshot_tests__hamt.snap @@ -3,6 +3,7 @@ source: wnfs-hamt/src/hamt.rs expression: hamt --- { + "cid": "bafyr4iaveogpzpomn7qakjyrq6nynt6b2pemjiejr7unlxhalfdciw74qa", "value": { "root": [ { diff --git a/wnfs-hamt/src/snapshots/wnfs_hamt__node__snapshot_tests__node.snap b/wnfs-hamt/src/snapshots/wnfs_hamt__node__snapshot_tests__node.snap index c367a4e4..ae6d0d89 100644 --- a/wnfs-hamt/src/snapshots/wnfs_hamt__node__snapshot_tests__node.snap +++ b/wnfs-hamt/src/snapshots/wnfs_hamt__node__snapshot_tests__node.snap @@ -3,6 +3,7 @@ source: wnfs-hamt/src/node.rs expression: node --- { + "cid": "bafyr4igc6oq6uq55xmd4v6dheqdydlyzexhqs5zfewtudpwsinanqmylyq", "value": [ { "/": { diff --git a/wnfs-hamt/src/snapshots/wnfs_hamt__pointer__snapshot_tests__pointer.snap b/wnfs-hamt/src/snapshots/wnfs_hamt__pointer__snapshot_tests__pointer.snap index 09c38e55..882ad332 100644 --- a/wnfs-hamt/src/snapshots/wnfs_hamt__pointer__snapshot_tests__pointer.snap +++ b/wnfs-hamt/src/snapshots/wnfs_hamt__pointer__snapshot_tests__pointer.snap @@ -3,6 +3,7 @@ source: wnfs-hamt/src/pointer.rs expression: ptr --- { + "cid": "bafyr4icjrohmzg3axrk7guxd42zmfwhdx7ptio3n4lsg23hywjrmjgpmpa", "value": [ [ "James", diff --git a/wnfs-nameaccumulator/Cargo.toml b/wnfs-nameaccumulator/Cargo.toml index 00a6ff33..fee5ee24 100644 --- a/wnfs-nameaccumulator/Cargo.toml +++ b/wnfs-nameaccumulator/Cargo.toml @@ -21,11 +21,12 @@ anyhow = "1.0" async-trait = "0.1" blake3 = { version = "1.4", features = ["traits-preview"] } libipld = { version = "0.16", features = ["dag-cbor", "derive", "serde-codec"] } -num-bigint-dig = { version = "0.8.2", features = ["prime", "zeroize"] } +num-bigint-dig = { version = "0.8.2", features = ["prime", "zeroize"], optional = true } num-integer = "0.1.45" num-traits = "0.2.15" once_cell = "1.0" rand_core = "0.6" +rug = { version = "1.22", optional = true, default-features = false, features = ["rand", "integer", "num-traits"] } serde = { version = "1.0", features = ["rc"] } serde_bytes = "0.11.9" thiserror = "1.0" @@ -42,3 +43,8 @@ rand_chacha = "0.3" serde_json = "1.0.103" test-strategy = "0.3" wnfs-common = { path = "../wnfs-common", features = ["test_utils"] } + +[features] +default = ["num-bigint-dig"] +rug = ["dep:rug"] +num-bigint-dig = ["dep:num-bigint-dig"] diff --git a/wnfs-nameaccumulator/README.md b/wnfs-nameaccumulator/README.md index 6fab81ca..777de6d2 100644 --- a/wnfs-nameaccumulator/README.md +++ b/wnfs-nameaccumulator/README.md @@ -82,3 +82,22 @@ verification.add(&name_base, &accum_note, &proof_note.part)?; verification.add(&name_base, &accum_image, &proof_image.part)?; verification.verify(&batched_proof)?; ``` + +## The `rug` feature + +This enables a different backend for big unsigned integer arithmetic, based on the [rug crate] (which is based on the [GNU multiprecision library], also abbreviated GMP). + +It is roughly 2x faster than the `num-bigint-dig` implementation when building for release, but as a bonus is also fast in debug builds (e.g. during tests) due to rug containing a statically linked release build of GMP. + +However, it doesn't work in Wasm and it should be noted that GMP is licensed as [LGPLv3]. + +If you depend on the `wnfs` crate, but want to use the `rug` backend for your application, then simply add a `wnfs-nameaccumulator` as a dependency and enable its `rug` feature. This will make `wnfs` use a version of `wnfs-nameaccumulator` with `rug` enabled: + +```toml +wnfs-nameaccumulator = { version = "*", default-features = false, features = ["rug"] } +``` + + +[rug crate]: https://crates.io/crates/rug +[GNU multiprecision library]: https://gmplib.org/ +[LGPLv3]: https://www.gnu.org/licenses/lgpl-3.0.en.html diff --git a/wnfs-nameaccumulator/proptest-regressions/name.txt b/wnfs-nameaccumulator/proptest-regressions/name.txt index 4b8ef974..b0f5b3dd 100644 --- a/wnfs-nameaccumulator/proptest-regressions/name.txt +++ b/wnfs-nameaccumulator/proptest-regressions/name.txt @@ -5,3 +5,4 @@ # It is recommended to check this file in to source control so that # everyone who runs the test benefits from these saved cases. cc 981ff5c92ddd0a53eb8569b94c7aa0184603de547961d5562c40e1c8643a7275 # shrinks to input = _PaddedBiguintEncodingRoundtripsArgs { num: 1 } +cc 96d340fe66ed56e3479dd02bbccc0a500237d7720fb1488557806d6a61972205 # shrinks to input = _BatchProofsArgs { do_batch_step: [false, false, true, true], do_verify_step: [false, true, true, false], seed: 0 } diff --git a/wnfs-nameaccumulator/src/error.rs b/wnfs-nameaccumulator/src/error.rs index f68711ea..c41e6e2e 100644 --- a/wnfs-nameaccumulator/src/error.rs +++ b/wnfs-nameaccumulator/src/error.rs @@ -16,4 +16,7 @@ pub enum VerificationError { #[error("NameAccumulator batched proof validation failed")] ValidationFailed, + + #[error("Couldn't invert base accumulator state")] + NoInverse, } diff --git a/wnfs-nameaccumulator/src/fns.rs b/wnfs-nameaccumulator/src/fns.rs index f4d82901..cfe853ed 100644 --- a/wnfs-nameaccumulator/src/fns.rs +++ b/wnfs-nameaccumulator/src/fns.rs @@ -1,5 +1,5 @@ +use crate::Big; use blake3::traits::digest::{ExtendableOutput, ExtendableOutputReset}; -use num_bigint_dig::{prime::probably_prime, BigUint}; use num_traits::One; #[cfg(test)] @@ -11,31 +11,34 @@ const TEST_DSI: &str = "rs-wnfs tests"; /// /// With `(base_i, exponent_i) = bases_and_exponents_i`, it computes the product of /// `base_i ^ (product of exponent_j with j != i)`. -pub(crate) fn multi_exp(bases_and_exponents: &[(BigUint, BigUint)], modulus: &BigUint) -> BigUint { +pub(crate) fn multi_exp( + bases_and_exponents: &[(B::Num, B::Num)], + modulus: &B::Num, +) -> B::Num { match bases_and_exponents { - &[] => BigUint::one(), + &[] => B::Num::one(), [(base, _)] => base.clone() % modulus, other => { let mid = other.len() / 2; let (left, right) = other.split_at(mid); - let x_star_left = nlogn_product(left, |(_, x_i)| x_i); - let x_star_right = nlogn_product(right, |(_, x_i)| x_i); - (multi_exp(left, modulus).modpow(&x_star_right, modulus) - * multi_exp(right, modulus).modpow(&x_star_left, modulus)) + let x_star_left = nlogn_product::<_, B>(left, |(_, x_i)| x_i); + let x_star_right = nlogn_product::<_, B>(right, |(_, x_i)| x_i); + (B::modpow(&multi_exp::(left, modulus), &x_star_right, modulus) + * B::modpow(&multi_exp::(right, modulus), &x_star_left, modulus)) % modulus } } } /// Computes the product of all factors in O(n log n) time. -pub(crate) fn nlogn_product(factors: &[A], f: fn(&A) -> &BigUint) -> BigUint { +pub(crate) fn nlogn_product(factors: &[A], f: fn(&A) -> &B::Num) -> B::Num { match factors { - [] => BigUint::one(), + [] => B::Num::one(), [factor] => f(factor).clone(), other => { let mid = other.len() / 2; let (left, right) = factors.split_at(mid); - nlogn_product(left, f) * nlogn_product(right, f) + nlogn_product::(left, f) * nlogn_product::(right, f) } } } @@ -44,11 +47,11 @@ pub(crate) fn nlogn_product(factors: &[A], f: fn(&A) -> &BigUint) -> BigUint /// /// The output includes both the prime and a 32-bit counter /// that helps verifying the prime digest. -pub(crate) fn blake3_prime_digest( +pub(crate) fn blake3_prime_digest( domain_separation_info: &str, bytes: impl AsRef<[u8]>, hash_len: usize, -) -> (BigUint, u32) { +) -> (B::Num, u32) { let mut counter: u32 = 0; let mut hasher = blake3::Hasher::new_derive_key(domain_separation_info); let mut hash = vec![0u8; hash_len]; @@ -59,11 +62,11 @@ pub(crate) fn blake3_prime_digest( hasher.update(&counter.to_le_bytes()); hasher.finalize_xof_reset_into(&mut hash); - let mut candidate = BigUint::from_bytes_le(&hash); + let mut candidate = B::from_bytes_be(&hash); - candidate |= BigUint::one(); + candidate |= B::Num::one(); - if probably_prime(&candidate, 20) { + if B::is_probably_prime(&candidate) { return (candidate, counter); } @@ -74,22 +77,22 @@ pub(crate) fn blake3_prime_digest( /// Finalizes a digest fast, if it has been computed before given the counter from /// a previous invocation of `prime_digest`. /// This will make sure that the returned digest is prime. -pub(crate) fn blake3_prime_digest_fast( +pub(crate) fn blake3_prime_digest_fast( domain_separation_info: &str, bytes: impl AsRef<[u8]>, hash_len: usize, counter: u32, -) -> Option { +) -> Option { let mut hash = vec![0u8; hash_len]; let mut hasher = blake3::Hasher::new_derive_key(domain_separation_info); hasher.update(bytes.as_ref()); hasher.update(&counter.to_le_bytes()); hasher.finalize_xof_into(&mut hash); - let mut to_verify = BigUint::from_bytes_le(&hash); - to_verify |= BigUint::one(); + let mut to_verify = B::from_bytes_be(&hash); + to_verify |= B::Num::one(); - if !probably_prime(&to_verify, 20) { + if !B::is_probably_prime(&to_verify) { None } else { Some(to_verify) @@ -99,23 +102,25 @@ pub(crate) fn blake3_prime_digest_fast( #[cfg(test)] mod tests { use super::{blake3_prime_digest, TEST_DSI}; + use crate::BigNumDig; /// This test makes sure we don't accidentally (only intentionally) /// change hash outputs between versions. #[test] fn test_fixture_prime_hash() { - let (output, counter) = blake3_prime_digest(TEST_DSI, "Hello, World!", 16); + let (output, counter) = blake3_prime_digest::(TEST_DSI, "Hello, World!", 16); assert_eq!( (output.to_str_radix(16), counter), - ("9ef50db608f1e61acedaf2fe6ad982ed".into(), 6) + ("7f1f785675ccdf2fb20238124fe3e80f".into(), 23) ); } } #[cfg(test)] mod proptests { - use crate::fns::{ - blake3_prime_digest, blake3_prime_digest_fast, multi_exp, nlogn_product, TEST_DSI, + use crate::{ + fns::{blake3_prime_digest, blake3_prime_digest_fast, multi_exp, nlogn_product, TEST_DSI}, + BigNumDig, }; use num_bigint_dig::{prime::probably_prime, BigUint, RandPrime}; use num_traits::One; @@ -128,10 +133,10 @@ mod proptests { #[proptest(cases = 1000)] fn test_prime_digest(#[strategy(vec(any::(), 0..100))] bytes: Vec) { - let (prime_hash, inc) = blake3_prime_digest(TEST_DSI, &bytes, 16); + let (prime_hash, inc) = blake3_prime_digest::(TEST_DSI, &bytes, 16); prop_assert!(probably_prime(&prime_hash, 20)); prop_assert_eq!( - blake3_prime_digest_fast(TEST_DSI, &bytes, 16, inc), + blake3_prime_digest_fast::(TEST_DSI, &bytes, 16, inc), Some(prime_hash) ); } @@ -146,13 +151,13 @@ mod proptests { .map(|(b, e)| (BigUint::from(*b), BigUint::from(*e))) .collect(); - let actual = multi_exp(&bases_and_exponents, &modulus); + let actual = multi_exp::(&bases_and_exponents, &modulus); let expected = multi_exp_naive(&bases_and_exponents, &modulus); prop_assert_eq!(actual, expected); } fn multi_exp_naive(bases_and_exponents: &[(BigUint, BigUint)], modulus: &BigUint) -> BigUint { - let x_star = nlogn_product(bases_and_exponents, |(_, x_i)| x_i); + let x_star = nlogn_product::<_, BigNumDig>(bases_and_exponents, |(_, x_i)| x_i); let mut product = BigUint::one(); for (alpha_i, x_i) in bases_and_exponents { diff --git a/wnfs-nameaccumulator/src/lib.rs b/wnfs-nameaccumulator/src/lib.rs index d43cdc93..ec485bdc 100644 --- a/wnfs-nameaccumulator/src/lib.rs +++ b/wnfs-nameaccumulator/src/lib.rs @@ -4,7 +4,15 @@ mod error; mod fns; +#[cfg(any(feature = "rug", feature = "num-bigint-dig"))] mod name; +mod traits; mod uint256_serde_be; +#[cfg(not(feature = "rug"))] +#[cfg(not(feature = "num-bigint-dig"))] +compile_error!("no backend for big numbers, enable either the 'rug' or 'num-bigint-dig' feature."); + +#[cfg(any(feature = "rug", feature = "num-bigint-dig"))] pub use name::*; +pub use traits::*; diff --git a/wnfs-nameaccumulator/src/name.rs b/wnfs-nameaccumulator/src/name.rs index 425d9a22..81a8eef7 100644 --- a/wnfs-nameaccumulator/src/name.rs +++ b/wnfs-nameaccumulator/src/name.rs @@ -1,18 +1,21 @@ +#[cfg(not(feature = "rug"))] +#[cfg(feature = "num-bigint-dig")] +use crate::BigNumDig; +#[cfg(feature = "rug")] +use crate::BigNumRug; use crate::{ error::VerificationError, - fns::{blake3_prime_digest, blake3_prime_digest_fast, multi_exp, nlogn_product}, - uint256_serde_be::to_bytes_helper, + fns::{blake3_prime_digest, blake3_prime_digest_fast, multi_exp}, + traits::Big, }; use anyhow::Result; -use num_bigint_dig::{BigUint, ModInverse, RandBigInt, RandPrime}; -use num_integer::Integer; -use num_traits::One; +use libipld::Cid; +use num_traits::{One, Zero}; use once_cell::sync::OnceCell; use rand_core::CryptoRngCore; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use std::{hash::Hash, str::FromStr}; -use wnfs_common::impl_storable_from_serde; -use zeroize::Zeroize; +use wnfs_common::{BlockStore, Storable}; /// The domain separation string for deriving the l hash in the PoKE* protocol. const L_HASH_DSI: &str = "wnfs/1.0/PoKE*/l 128-bit hash derivation"; @@ -21,6 +24,13 @@ const L_HASH_DSI: &str = "wnfs/1.0/PoKE*/l 128-bit hash derivation"; // Type Definitions //-------------------------------------------------------------------------------------------------- +#[cfg(not(feature = "rug"))] +#[cfg(feature = "num-bigint-dig")] +pub type DefaultBig = BigNumDig; + +#[cfg(feature = "rug")] +pub type DefaultBig = BigNumRug; + /// A WNFS name. /// Each file or directory has a name. /// Names consist of a set of name segments and are commited to name accumulators. @@ -28,25 +38,29 @@ const L_HASH_DSI: &str = "wnfs/1.0/PoKE*/l 128-bit hash derivation"; /// to prove a relationship between two names, e.g a file being contained in /// a sub-directory of a directory while leaking as little information as possible. #[derive(Clone, Debug, PartialEq, Eq, Hash)] -pub struct Name { - relative_to: NameAccumulator, - segments: Vec, +pub struct Name { + relative_to: NameAccumulator, + segments: Vec>, } /// Represents a setup needed for RSA accumulator operation. #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)] -pub struct AccumulatorSetup { - #[serde(with = "crate::uint256_serde_be")] - modulus: BigUint, - #[serde(with = "crate::uint256_serde_be")] - pub generator: BigUint, +pub struct AccumulatorSetup { + #[serde(bound = "B: Big")] + #[serde(deserialize_with = "crate::uint256_serde_be::deserialize::")] + #[serde(serialize_with = "crate::uint256_serde_be::serialize::")] + modulus: B::Num, + #[serde(bound = "B: Big")] + #[serde(deserialize_with = "crate::uint256_serde_be::deserialize::")] + #[serde(serialize_with = "crate::uint256_serde_be::serialize::")] + pub generator: B::Num, } /// A WNFS name represented as the RSA accumulator of all of its name segments. #[derive(Clone, Eq)] -pub struct NameAccumulator { +pub struct NameAccumulator { /// A 2048-bit number - state: BigUint, + state: B::Num, /// A cache for its serialized form serialized_cache: OnceCell<[u8; 256]>, } @@ -54,65 +68,67 @@ pub struct NameAccumulator { /// A name accumluator segment. A name accumulator commits to a set of these. /// They are represented as 256-bit prime numbers. #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct NameSegment( +pub struct NameSegment( /// Invariant: Must be a 256-bit prime - BigUint, + B::Num, ); /// PoKE* (Proof of Knowledge of Exponent), /// assuming that the base is trusted /// (e.g. part of a common reference string). #[derive(Clone, PartialEq, Eq)] -pub struct ElementsProof { +pub struct ElementsProof { /// The accumulator's base, $u$ - pub base: BigUint, + pub base: B::Num, /// A part of the proof, $Q = u^q$, where $element = q*l + r$ - pub big_q: BigUint, + pub big_q: B::Num, /// Part of the proof that can't be batched - pub part: UnbatchableProofPart, + pub part: UnbatchableProofPart, } /// The part of PoKE* (Proof of Knowledge of Exponent) proofs that can't be batched. /// This is very small (serialized typically <20 bytes, most likely just 17 bytes). #[derive(Clone, PartialEq, Eq)] -pub struct UnbatchableProofPart { +pub struct UnbatchableProofPart { /// The number to increase a hash by to land on the next prime. /// Helps to more quickly generate/verify the prime number $l$. pub l_hash_inc: u32, /// A part of the proof, the residue of the element that's proven, i.e. $r$ in $element = q*l + r$ - pub r: BigUint, + pub r: B::Num, } /// The part of a name accumulator proof that can be batched, /// i.e. the size of this part of the proof is independent of /// the number of elements being proven. It's always 2048-bit. #[derive(Clone, Eq, PartialEq, Serialize, Deserialize)] -pub struct BatchedProofPart { - #[serde(with = "crate::uint256_serde_be")] - big_q_product: BigUint, +pub struct BatchedProofPart { + #[serde(bound = "B: Big")] + #[serde(deserialize_with = "crate::uint256_serde_be::deserialize::")] + #[serde(serialize_with = "crate::uint256_serde_be::serialize::")] + big_q_product: B::Num, } /// Data that is kept around for verifying batch proofs. -pub struct BatchedProofVerification<'a> { - bases_and_exponents: Vec<(BigUint, BigUint)>, - setup: &'a AccumulatorSetup, +pub struct BatchedProofVerification<'a, B: Big = DefaultBig> { + bases_and_exponents: Vec<(B::Num, B::Num)>, + setup: &'a AccumulatorSetup, } //-------------------------------------------------------------------------------------------------- // Implementations //-------------------------------------------------------------------------------------------------- -impl Name { +impl Name { /// Create the empty name - pub fn empty(setup: &AccumulatorSetup) -> Self { + pub fn empty(setup: &AccumulatorSetup) -> Self { Self::new(NameAccumulator::empty(setup), None) } /// Create a name relative to some other committed name /// and with given segments added to that name. pub fn new( - relative_to: NameAccumulator, - segments: impl IntoIterator, + relative_to: NameAccumulator, + segments: impl IntoIterator>, ) -> Self { Self { relative_to, @@ -132,7 +148,7 @@ impl Name { } /// Return the parent name, if possible. - pub fn parent(&self) -> Option { + pub fn parent(&self) -> Option> { if self.is_root() { None } else { @@ -142,15 +158,15 @@ impl Name { } } - pub fn get_segments(&self) -> &Vec { + pub fn get_segments(&self) -> &Vec> { &self.segments } - pub fn add_segments(&mut self, segments: impl IntoIterator) { + pub fn add_segments(&mut self, segments: impl IntoIterator>) { self.segments.extend(segments); } - pub fn with_segments_added(&self, segments: impl IntoIterator) -> Self { + pub fn with_segments_added(&self, segments: impl IntoIterator>) -> Self { let mut clone = self.clone(); clone.add_segments(segments); clone @@ -163,22 +179,22 @@ impl Name { /// This proof process is memoized. Running it twice won't duplicate work. pub fn into_proven_accumulator( &self, - setup: &AccumulatorSetup, - ) -> (NameAccumulator, ElementsProof) { + setup: &AccumulatorSetup, + ) -> (NameAccumulator, ElementsProof) { let mut name = self.relative_to.clone(); let proof = name.add(self.segments.iter(), setup); (name, proof) } /// Return what name accumulator this name commits to. - pub fn into_accumulator(&self, setup: &AccumulatorSetup) -> NameAccumulator { + pub fn into_accumulator(&self, setup: &AccumulatorSetup) -> NameAccumulator { self.into_proven_accumulator(setup).0 } } -impl NameAccumulator { +impl NameAccumulator { /// Create the empty accumulator. - pub fn empty(setup: &AccumulatorSetup) -> Self { + pub fn empty(setup: &AccumulatorSetup) -> Self { Self { state: setup.generator.clone(), serialized_cache: OnceCell::new(), @@ -187,9 +203,12 @@ impl NameAccumulator { /// Create an accumulator with given segments inside. pub fn with_segments<'a>( - segments: impl IntoIterator, - setup: &AccumulatorSetup, - ) -> Self { + segments: impl IntoIterator> + Clone, + setup: &AccumulatorSetup, + ) -> Self + where + B: 'a, + { let mut acc = Self::empty(setup); acc.add(segments, setup); // ignore proof acc @@ -199,7 +218,7 @@ impl NameAccumulator { /// /// This needs to be a 2048-bit number in the RSA group from /// the accumulator setup used. - pub fn from_state(state: BigUint) -> Self { + pub fn from_state(state: B::Num) -> Self { Self { state, serialized_cache: OnceCell::new(), @@ -210,26 +229,33 @@ impl NameAccumulator { /// elements proof that verifies the change of state of the accumulator. pub fn add<'a>( &mut self, - segments: impl IntoIterator, - setup: &AccumulatorSetup, - ) -> ElementsProof { + segments: impl IntoIterator>, + setup: &AccumulatorSetup, + ) -> ElementsProof + where + B: 'a, + { + let segments = segments + .into_iter() + .map(|s| s.0.clone()) + .collect::>(); + // Reset the serialized state self.serialized_cache = OnceCell::new(); - - let mut product = BigUint::one(); - for segment in segments { - product *= &segment.0; - } - let witness = self.state.clone(); - self.state = self.state.modpow(&product, &setup.modulus); - let data = poke_fiat_shamir_l_hash_data(&setup.modulus, &witness, &self.state); - let (l, l_hash_inc) = blake3_prime_digest(L_HASH_DSI, data, 16); + self.state = B::modpow_product(&self.state, segments.iter(), &setup.modulus); + + let data = poke_fiat_shamir_l_hash_data::(&setup.modulus, &witness, &self.state); + let (l, l_hash_inc) = blake3_prime_digest::(L_HASH_DSI, data, 16); - let (q, r) = product.div_mod_floor(&l); + let (q, r) = B::quotrem_product(segments.iter(), &l); - let big_q = witness.modpow(&q, &setup.modulus); + let big_q = if B::Num::is_zero(&q) { + B::Num::one() + } else { + B::modpow(&witness, &q, &setup.modulus) + }; ElementsProof { base: witness, @@ -249,7 +275,7 @@ impl NameAccumulator { /// Deserialize a name accumulator from bytes. pub fn parse_slice(slice: [u8; 256]) -> Self { - let state = BigUint::from_bytes_be(&slice); + let state = B::from_bytes_be(&slice); Self { state, serialized_cache: OnceCell::from(slice), @@ -260,9 +286,7 @@ impl NameAccumulator { pub fn into_bytes(self) -> [u8; 256] { let cache = self.serialized_cache; let state = self.state; - cache - .into_inner() - .unwrap_or_else(|| to_bytes_helper(&state)) + cache.into_inner().unwrap_or_else(|| B::to_bytes_be(&state)) } /// Serialize a name accumulator to bytes and return a reference. @@ -270,33 +294,31 @@ impl NameAccumulator { /// This call is memoized, serializing twice won't duplicate work. pub fn as_bytes(&self) -> &[u8; 256] { self.serialized_cache - .get_or_init(|| to_bytes_helper(&self.state)) + .get_or_init(|| B::to_bytes_be(&self.state)) } } -fn poke_fiat_shamir_l_hash_data( - modulus: &BigUint, - base: &BigUint, - commitment: &BigUint, +fn poke_fiat_shamir_l_hash_data( + modulus: &B::Num, + base: &B::Num, + commitment: &B::Num, ) -> impl AsRef<[u8]> { [ - to_bytes_helper::<256>(modulus), - to_bytes_helper::<256>(base), - to_bytes_helper::<256>(commitment), + B::to_bytes_be::<256>(modulus), + B::to_bytes_be::<256>(base), + B::to_bytes_be::<256>(commitment), ] .concat() } -impl AccumulatorSetup { +impl AccumulatorSetup { /// Finishes a setup given a 2048-bit RSA modulus encoded in big-endian. /// /// Remaining work is safe and doesn't require a trusted environment. pub fn with_modulus(modulus_big_endian: &[u8; 256], rng: &mut impl CryptoRngCore) -> Self { - let modulus = BigUint::from_bytes_be(modulus_big_endian); + let modulus = B::from_bytes_be(modulus_big_endian); // The generator is just some random quadratic residue. - let generator = rng - .gen_biguint_below(&modulus) - .modpow(&BigUint::from(2u8), &modulus); + let generator = B::squaremod(&B::rand_below(&modulus, rng), &modulus); Self { modulus, generator } } @@ -308,19 +330,9 @@ impl AccumulatorSetup { /// priviliged process to observe the memory and copy out the toxic waste /// before it's deleted. pub fn trusted(rng: &mut impl CryptoRngCore) -> Self { - // This is a trusted setup. - // The prime factors are "toxic waste", they need to be - // disposed immediately. - let mut p = rng.gen_prime(1024); - let mut q = rng.gen_prime(1024); - let modulus = &p * &q; - // Make sure to delete toxic waste - p.zeroize(); - q.zeroize(); + let modulus = B::rand_rsa_modulus(rng); // The generator is just some random quadratic residue. - let generator = rng - .gen_biguint_below(&modulus) - .modpow(&BigUint::from(2u8), &modulus); + let generator = B::squaremod(&B::rand_below(&modulus, rng), &modulus); Self { modulus, generator } } @@ -331,47 +343,45 @@ impl AccumulatorSetup { /// /// [rsa factoring challenge]: https://en.wikipedia.org/wiki/RSA_numbers#RSA-2048 pub fn from_rsa_2048(rng: &mut impl CryptoRngCore) -> Self { - let modulus = BigUint::from_str( + let modulus = B::Num::from_str( "25195908475657893494027183240048398571429282126204032027777137836043662020707595556264018525880784406918290641249515082189298559149176184502808489120072844992687392807287776735971418347270261896375014971824691165077613379859095700097330459748808428401797429100642458691817195118746121515172654632282216869987549182422433637259085141865462043576798423387184774447920739934236584823824281198163815010674810451660377306056201619676256133844143603833904414952634432190114657544454178424020924616515723350778707749817125772467962926386356373289912154831438167899885040445364023527381951378636564391212010397122822120720357", - ).unwrap(); - let generator = rng - .gen_biguint_below(&modulus) - .modpow(&BigUint::from(2u8), &modulus); + ).ok().unwrap(); + let generator = B::squaremod(&B::rand_below(&modulus, rng), &modulus); Self { modulus, generator } } } -impl NameSegment { +impl NameSegment { /// Create a new, random name segment pub fn new(rng: &mut impl CryptoRngCore) -> Self { - Self(rng.gen_prime(256)) + Self(B::rand_prime_256bit(rng)) } /// Derive a name segment as the hash from some data pub fn new_hashed(domain_separation_info: &str, data: impl AsRef<[u8]>) -> Self { - Self(blake3_prime_digest(domain_separation_info, data, 32).0) + Self(blake3_prime_digest::(domain_separation_info, data, 32).0) } } -impl BatchedProofPart { +impl BatchedProofPart { /// Create a new proof batcher. pub fn new() -> Self { Self { - big_q_product: BigUint::one(), + big_q_product: B::Num::one(), } } /// Add the batchable portion of a proof of elements /// for a certain name accumulator to this batch proof. - pub fn add(&mut self, proof: &ElementsProof, setup: &AccumulatorSetup) { + pub fn add(&mut self, proof: &ElementsProof, setup: &AccumulatorSetup) { self.big_q_product *= &proof.big_q; self.big_q_product %= &setup.modulus; } } -impl<'a> BatchedProofVerification<'a> { +impl<'a, B: Big> BatchedProofVerification<'a, B> { /// Create a new verifier - pub fn new(setup: &'a AccumulatorSetup) -> Self { + pub fn new(setup: &'a AccumulatorSetup) -> Self { Self { bases_and_exponents: Vec::new(), setup, @@ -388,26 +398,26 @@ impl<'a> BatchedProofVerification<'a> { /// don't fit this proof part. pub fn add( &mut self, - base: &NameAccumulator, - commitment: &NameAccumulator, - proof_part: &UnbatchableProofPart, + base: &NameAccumulator, + commitment: &NameAccumulator, + proof_part: &UnbatchableProofPart, ) -> Result<()> { let hasher = - poke_fiat_shamir_l_hash_data(&self.setup.modulus, &base.state, &commitment.state); - let l = blake3_prime_digest_fast(L_HASH_DSI, hasher, 16, proof_part.l_hash_inc) + poke_fiat_shamir_l_hash_data::(&self.setup.modulus, &base.state, &commitment.state); + let l = blake3_prime_digest_fast::(L_HASH_DSI, hasher, 16, proof_part.l_hash_inc) .ok_or(VerificationError::LHashNonPrime)?; if proof_part.r >= l { Err(VerificationError::ResidueOutsideRange)?; } - let proof_kcr_base = (&commitment.state - * (&base.state) - .mod_inverse(&self.setup.modulus) - .unwrap() - .to_biguint() - .unwrap() - .modpow(&proof_part.r, &self.setup.modulus)) + let proof_kcr_base = (commitment.state.clone() + * B::modpow( + &B::mod_inv(&base.state, &self.setup.modulus) + .ok_or(VerificationError::NoInverse)?, + &proof_part.r, + &self.setup.modulus, + )) % &self.setup.modulus; self.bases_and_exponents.push((proof_kcr_base, l)); @@ -419,14 +429,11 @@ impl<'a> BatchedProofVerification<'a> { /// the batched proof. /// /// Will return an error if verification fails. - pub fn verify(&self, batched_proof: &BatchedProofPart) -> Result<()> { - let l_star = nlogn_product(&self.bases_and_exponents, |(_, l)| l); - - if batched_proof - .big_q_product - .modpow(&l_star, &self.setup.modulus) - != multi_exp(&self.bases_and_exponents, &self.setup.modulus) - { + pub fn verify(&self, batched_proof: &BatchedProofPart) -> Result<()> { + let exponents = self.bases_and_exponents.iter().map(|(_, l)| l); + let tmp = B::modpow_product(&batched_proof.big_q_product, exponents, &self.setup.modulus); + + if tmp != multi_exp::(&self.bases_and_exponents, &self.setup.modulus) { return Err(VerificationError::ValidationFailed.into()); } @@ -434,28 +441,56 @@ impl<'a> BatchedProofVerification<'a> { } } -impl_storable_from_serde! { AccumulatorSetup, NameSegment, NameAccumulator, UnbatchableProofPart, BatchedProofPart } +macro_rules! impl_storable { + ( $ty:ty ) => { + #[cfg_attr(not(target_arch = "wasm32"), ::async_trait::async_trait)] + #[cfg_attr(target_arch = "wasm32", ::async_trait::async_trait(?Send))] + impl Storable for $ty { + type Serializable = $ty; + + async fn to_serializable( + &self, + _store: &impl BlockStore, + ) -> Result { + Ok(self.clone()) + } -impl Serialize for NameSegment { + async fn from_serializable( + _: Option<&Cid>, + serializable: Self::Serializable, + ) -> Result { + Ok(serializable) + } + } + }; +} + +impl_storable!(AccumulatorSetup); +impl_storable!(NameSegment); +impl_storable!(NameAccumulator); +impl_storable!(UnbatchableProofPart); +impl_storable!(BatchedProofPart); + +impl Serialize for NameSegment { fn serialize(&self, serializer: S) -> Result where S: serde::Serializer, { - serde_bytes::serialize(to_bytes_helper::<32>(&self.0).as_ref(), serializer) + serde_bytes::serialize(B::to_bytes_be::<32>(&self.0).as_ref(), serializer) } } -impl<'de> Deserialize<'de> for NameSegment { +impl<'de, B: Big> Deserialize<'de> for NameSegment { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de>, { let bytes: Vec = serde_bytes::deserialize(deserializer)?; - Ok(NameSegment(BigUint::from_bytes_be(&bytes))) + Ok(NameSegment(B::from_bytes_be(&bytes))) } } -impl<'de> Deserialize<'de> for NameAccumulator { +impl<'de, B: Big> Deserialize<'de> for NameAccumulator { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de>, @@ -465,7 +500,7 @@ impl<'de> Deserialize<'de> for NameAccumulator { } } -impl Serialize for NameAccumulator { +impl Serialize for NameAccumulator { fn serialize(&self, serializer: S) -> Result where S: serde::Serializer, @@ -474,47 +509,47 @@ impl Serialize for NameAccumulator { } } -impl<'de> Deserialize<'de> for UnbatchableProofPart { +impl<'de, B: Big> Deserialize<'de> for UnbatchableProofPart { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { let (l_hash_inc, r): (u32, &serde_bytes::Bytes) = Deserialize::deserialize(deserializer)?; - let r = BigUint::from_bytes_be(r); + let r = B::from_bytes_be(r); Ok(Self { l_hash_inc, r }) } } -impl Serialize for UnbatchableProofPart { +impl Serialize for UnbatchableProofPart { fn serialize(&self, serializer: S) -> Result where S: Serializer, { - let residue = to_bytes_helper::<16>(&self.r); + let residue = B::to_bytes_be::<16>(&self.r); let r = serde_bytes::Bytes::new(&residue); (self.l_hash_inc, r).serialize(serializer) } } -impl PartialEq for NameAccumulator { +impl PartialEq for NameAccumulator { fn eq(&self, other: &Self) -> bool { self.state == other.state } } -impl Ord for NameAccumulator { +impl Ord for NameAccumulator { fn cmp(&self, other: &Self) -> std::cmp::Ordering { self.state.cmp(&other.state) } } -impl PartialOrd for NameAccumulator { +impl PartialOrd for NameAccumulator { fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) } } -impl std::fmt::Debug for NameAccumulator { +impl std::fmt::Debug for NameAccumulator { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("NameAccumulator") .field("state", &self.state.to_string()) @@ -522,25 +557,25 @@ impl std::fmt::Debug for NameAccumulator { } } -impl Hash for NameAccumulator { +impl Hash for NameAccumulator { fn hash(&self, state: &mut H) { self.state.hash(state); } } -impl AsRef<[u8]> for NameAccumulator { +impl AsRef<[u8]> for NameAccumulator { fn as_ref(&self) -> &[u8] { self.as_bytes() } } -impl Default for BatchedProofPart { +impl Default for BatchedProofPart { fn default() -> Self { Self::new() } } -impl std::fmt::Debug for NameSegment { +impl std::fmt::Debug for NameSegment { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_tuple("NameSegment") .field(&self.0.to_string()) @@ -548,7 +583,7 @@ impl std::fmt::Debug for NameSegment { } } -impl std::fmt::Debug for AccumulatorSetup { +impl std::fmt::Debug for AccumulatorSetup { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("AccumulatorSetup") .field("modulus", &self.modulus.to_string()) @@ -557,7 +592,7 @@ impl std::fmt::Debug for AccumulatorSetup { } } -impl std::fmt::Debug for UnbatchableProofPart { +impl std::fmt::Debug for UnbatchableProofPart { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("UnbatchableProofPart") .field("l_hash_inc", &self.l_hash_inc) @@ -566,7 +601,7 @@ impl std::fmt::Debug for UnbatchableProofPart { } } -impl std::fmt::Debug for ElementsProof { +impl std::fmt::Debug for ElementsProof { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("ElementsProof") .field("base", &self.base.to_string()) @@ -576,7 +611,7 @@ impl std::fmt::Debug for ElementsProof { } } -impl std::fmt::Debug for BatchedProofPart { +impl std::fmt::Debug for BatchedProofPart { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("BatchedProofPart") .field("big_q_product", &self.big_q_product.to_string()) @@ -590,9 +625,10 @@ impl std::fmt::Debug for BatchedProofPart { #[cfg(test)] mod tests { + use super::DefaultBig; use crate::{ - uint256_serde_be::to_bytes_helper, AccumulatorSetup, BatchedProofPart, - BatchedProofVerification, Name, NameAccumulator, NameSegment, + AccumulatorSetup, BatchedProofPart, BatchedProofVerification, Big, BigNumDig, Name, + NameAccumulator, NameSegment, }; use anyhow::Result; use libipld::{ @@ -647,7 +683,7 @@ mod tests { #[test] fn name_batched_proof_example() -> Result<()> { let rng = &mut thread_rng(); - let setup = &AccumulatorSetup::from_rsa_2048(rng); + let setup = &AccumulatorSetup::::from_rsa_2048(rng); let mut name_note = Name::empty(setup); let mut name_image = Name::empty(setup); @@ -683,7 +719,7 @@ mod tests { #[test] fn equals_ignores_serialization_cache() -> Result<()> { let rng = &mut thread_rng(); - let setup = &AccumulatorSetup::from_rsa_2048(rng); + let setup = &AccumulatorSetup::::from_rsa_2048(rng); let mut name_one = NameAccumulator::empty(setup); let mut name_two = NameAccumulator::empty(setup); @@ -710,7 +746,7 @@ mod tests { #[proptest(cases = 32)] fn batch_proofs(do_batch_step: [bool; 4], do_verify_step: [bool; 4], seed: u64) { let rng = &mut ChaCha12Rng::seed_from_u64(seed); - let setup = &AccumulatorSetup::from_rsa_2048(rng); + let setup = &AccumulatorSetup::::from_rsa_2048(rng); let base_a = NameAccumulator::with_segments(&[NameSegment::new(rng)], setup); let base_b = NameAccumulator::with_segments(&[NameSegment::new(rng)], setup); @@ -775,7 +811,7 @@ mod tests { #[proptest] fn padded_biguint_encoding_roundtrips(num: u64) { let num = BigUint::from(num); - let bytes = to_bytes_helper::<8>(&num); + let bytes = BigNumDig::to_bytes_be::<8>(&num); let parsed = BigUint::from_bytes_be(bytes.as_ref()); prop_assert_eq!(parsed, num); } @@ -784,7 +820,7 @@ mod tests { #[cfg(test)] mod snapshot_tests { use super::*; - use crate::NameSegment; + use crate::{BigNumDig, NameSegment}; use rand_chacha::ChaCha12Rng; use rand_core::SeedableRng; use wnfs_common::{utils::SnapshotBlockStore, BlockStore}; @@ -793,7 +829,7 @@ mod snapshot_tests { async fn test_name_accumulator() { let rng = &mut ChaCha12Rng::seed_from_u64(0); let store = &SnapshotBlockStore::default(); - let setup = &AccumulatorSetup::from_rsa_2048(rng); + let setup = &AccumulatorSetup::::from_rsa_2048(rng); let mut acc = NameAccumulator::empty(setup); acc.add( diff --git a/wnfs-nameaccumulator/src/snapshots/wnfs_nameaccumulator__name__snapshot_tests__name_accumulator.snap b/wnfs-nameaccumulator/src/snapshots/wnfs_nameaccumulator__name__snapshot_tests__name_accumulator.snap index 814d2bcc..56dacaad 100644 --- a/wnfs-nameaccumulator/src/snapshots/wnfs_nameaccumulator__name__snapshot_tests__name_accumulator.snap +++ b/wnfs-nameaccumulator/src/snapshots/wnfs_nameaccumulator__name__snapshot_tests__name_accumulator.snap @@ -3,6 +3,7 @@ source: wnfs-nameaccumulator/src/name.rs expression: name --- { + "cid": "bafyr4ifk4gn3ikouj2hr6otqcrvczkzoez7f3nbsdhrn66lsulgouus4x4", "value": { "/": { "bytes": "QJGrxttvHTU78j/tJnSVMV+P/9eqtVs+5/MZFGwT+Fp5OeAeYYkTdROGIU1QBThKsKXTxagSECZN+AkULPOERVK/6n2UrWBYdj89gXBHMsVzzKRSi1V2gv9KjsI8bxbVM5b1M3YAGixO7vlAWZOREWRK82XHaaQnbrnENoFvjtXpKp7ZeW7bdWKXsa3gz891zlMb4SjudlQJYbz4LxfaYCvFo77/x5lN8Nr5B5aDJbgG+Hkgk0h3v/hEkZV+xjfhhtVaQ8qULLK4YlWZhyz/9Vg4YS/NuJvaEfCbfEBJksOnRJg9tMT7ckzjnz6WH7NKFt5TPMZwQEqLNQGHhtim4g" diff --git a/wnfs-nameaccumulator/src/traits.rs b/wnfs-nameaccumulator/src/traits.rs new file mode 100644 index 00000000..3ff2d68d --- /dev/null +++ b/wnfs-nameaccumulator/src/traits.rs @@ -0,0 +1,317 @@ +#[cfg(feature = "num-bigint-dig")] +use num_bigint_dig::{prime::probably_prime, BigUint, ModInverse, RandBigInt, RandPrime}; +#[cfg(feature = "num-bigint-dig")] +use num_traits::{One, Zero}; +use rand_core::CryptoRngCore; +#[cfg(feature = "rug")] +use rug::{ + integer::{IsPrime, Order}, + rand::RandState, + Integer, +}; +use std::{ + fmt::{Debug, Display}, + hash::Hash, + ops::{BitOrAssign, MulAssign, Rem, RemAssign}, + str::FromStr, +}; +use wnfs_common::utils::CondSync; +#[cfg(feature = "num-bigint-dig")] +use zeroize::Zeroize; + +/// Big integer math functions required to implement name accumulators. +/// +/// This allows abstracting the big number library backend. +pub trait Big: Eq + Clone + Hash { + /// The big unsigned integer for this backend + type Num: Clone + + Debug + + Display + + PartialEq + + Eq + + Hash + + CondSync + // number-related traits + + FromStr + + Zero + + One + + for<'a> MulAssign<&'a Self::Num> + + for<'a> RemAssign<&'a Self::Num> + + for<'a> Rem<&'a Self::Num, Output = Self::Num> + + BitOrAssign + + Ord; + + /// Computes the power of base to the product of some numbers all under a modulus. + /// + /// `modpow_product(b, exps, N) = b ^ product(exps) mod N` + fn modpow_product<'a>( + base: &Self::Num, + exponents: impl Iterator, + modulus: &Self::Num, + ) -> Self::Num + where + Self::Num: 'a; + + /// Computes `(base ^ exponent) mod modulus` + fn modpow(base: &Self::Num, exponent: &Self::Num, modulus: &Self::Num) -> Self::Num; + + /// Computes the modulo multiplicative inverse of `base`. + /// + /// `(mod_inv(base, N) * base) mod N = 1` + fn mod_inv(base: &Self::Num, modulus: &Self::Num) -> Option; + + /// Computes `(base ^ 2) mod N`. + /// + /// A specialization of `modpow` with `exponent = 2`. + fn squaremod(base: &Self::Num, modulus: &Self::Num) -> Self::Num; + + /// Computes the quotient and remainder of a product of numbers divided + /// by `divisor`. + /// + /// `quotrem_product(fs, d).0 * d + quotrem_product(fs, d).1 = product(fs)` + /// + /// Returns `(quotient, remainder)`. + fn quotrem_product<'a>( + factors: impl Iterator, + divisor: &Self::Num, + ) -> (Self::Num, Self::Num) + where + Self::Num: 'a; + + /// Parses a big-endian-encoded number + /// + /// (Big endian is the standard encoding for RSA numbers.) + fn from_bytes_be(bytes: &[u8]) -> Self::Num; + + /// Turns a 2048-bit number into a big-endian encoded slice. + /// + /// (Big endian is the standard encoding for RSA numbers.) + fn to_bytes_be(n: &Self::Num) -> [u8; N]; + + /// Returns whether given number is probably prime. + /// The propability of the number being non-prime must be neglegible. + fn is_probably_prime(candidate: &Self::Num) -> bool; + + /// Generates a random number less than the non-zero ceiling, given some randomness. + fn rand_below(ceiling: &Self::Num, rng: &mut impl CryptoRngCore) -> Self::Num; + + /// Generate a random modulus `N = p * q` where `p` and `q` are prime. + fn rand_rsa_modulus(rng: &mut impl CryptoRngCore) -> Self::Num; + + /// Generate a random 256-bit prime number. + fn rand_prime_256bit(rng: &mut impl CryptoRngCore) -> Self::Num; +} + +#[cfg(feature = "num-bigint-dig")] +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct BigNumDig; + +#[cfg(feature = "num-bigint-dig")] +impl Big for BigNumDig { + type Num = BigUint; + + fn modpow_product<'a>( + base: &Self::Num, + exponents: impl Iterator, + modulus: &Self::Num, + ) -> Self::Num { + let mut product = Self::Num::one(); + for exponent in exponents { + product *= exponent; + } + + base.modpow(&product, modulus) + } + + fn modpow(base: &Self::Num, exponent: &Self::Num, modulus: &Self::Num) -> Self::Num { + base.modpow(exponent, modulus) + } + + fn mod_inv(base: &Self::Num, modulus: &Self::Num) -> Option { + base.mod_inverse(modulus)?.to_biguint() + } + + fn squaremod(base: &Self::Num, modulus: &Self::Num) -> Self::Num { + base.modpow(&BigUint::from(2u8), modulus) + } + + fn quotrem_product<'a>( + factors: impl Iterator, + divisor: &Self::Num, + ) -> (Self::Num, Self::Num) { + let mut product = BigUint::one(); + for factor in factors { + product *= factor; + } + + use num_integer::Integer; + product.div_mod_floor(divisor) + } + + fn from_bytes_be(bytes: &[u8]) -> Self::Num { + BigUint::from_bytes_be(bytes) + } + + fn to_bytes_be(n: &Self::Num) -> [u8; N] { + let vec = n.to_bytes_be(); + let mut bytes = [0u8; N]; + let zero_bytes = N - vec.len(); + bytes[zero_bytes..].copy_from_slice(&vec); + bytes + } + + fn is_probably_prime(candidate: &Self::Num) -> bool { + probably_prime(candidate, 20) + } + + fn rand_below(ceiling: &Self::Num, rng: &mut impl CryptoRngCore) -> Self::Num { + rng.gen_biguint_below(ceiling) + } + + fn rand_rsa_modulus(rng: &mut impl CryptoRngCore) -> Self::Num { + // This is a trusted setup. + // The prime factors are "toxic waste", they need to be + // disposed immediately. + let mut p = rng.gen_prime(1024); + let mut q = rng.gen_prime(1024); + let modulus = &p * &q; + // Make sure to delete toxic waste + p.zeroize(); + q.zeroize(); + modulus + } + + fn rand_prime_256bit(rng: &mut impl CryptoRngCore) -> Self::Num { + rng.gen_prime(256) + } +} + +#[cfg(feature = "rug")] +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct BigNumRug; + +#[cfg(feature = "rug")] +impl Big for BigNumRug { + type Num = Integer; + + fn modpow_product<'a>( + base: &Self::Num, + exponents: impl Iterator, + modulus: &Self::Num, + ) -> Self::Num { + let mut product = Self::Num::one(); + for exponent in exponents { + product *= exponent; + } + + base.clone().secure_pow_mod(&product, modulus) + } + + fn modpow(base: &Self::Num, exponent: &Self::Num, modulus: &Self::Num) -> Self::Num { + base.clone().secure_pow_mod(exponent, modulus) + } + + fn mod_inv(base: &Self::Num, modulus: &Self::Num) -> Option { + base.clone().invert(modulus).ok() + } + + fn squaremod(base: &Self::Num, modulus: &Self::Num) -> Self::Num { + base.clone() + .pow_mod(&Integer::from_digits(&[2u8], Order::LsfLe), modulus) + .unwrap() + } + + fn quotrem_product<'a>( + factors: impl Iterator, + divisor: &Self::Num, + ) -> (Self::Num, Self::Num) { + let mut product = Self::Num::one(); + for factor in factors { + product *= factor; + } + + product.div_rem_floor(divisor.clone()) + } + + fn from_bytes_be(bytes: &[u8]) -> Self::Num { + Integer::from_digits(bytes, Order::MsfLe) + } + + fn to_bytes_be(n: &Self::Num) -> [u8; N] { + let vec = n.to_digits(Order::MsfLe); + let mut bytes = [0u8; N]; + let zero_bytes = N - vec.len(); + bytes[zero_bytes..].copy_from_slice(&vec); + bytes + } + + fn is_probably_prime(candidate: &Self::Num) -> bool { + match candidate.is_probably_prime(20) { + IsPrime::No => false, + IsPrime::Probably => true, + IsPrime::Yes => true, + } + } + + fn rand_below(ceiling: &Self::Num, rng: &mut impl CryptoRngCore) -> Self::Num { + let mut rng = Self::setup_rand_state(rng); + Integer::random_below(ceiling.clone(), &mut rng) + } + + fn rand_rsa_modulus(rng: &mut impl CryptoRngCore) -> Self::Num { + let mut rng = Self::setup_rand_state(rng); + let p_pre: Integer = Integer::random_bits(1024, &mut rng).into(); + let q_pre: Integer = Integer::random_bits(1024, &mut rng).into(); + let p = p_pre.next_prime(); + let q = q_pre.next_prime(); + p * q + } + + fn rand_prime_256bit(rng: &mut impl CryptoRngCore) -> Self::Num { + let i: Integer = Integer::random_bits(256, &mut Self::setup_rand_state(rng)).into(); + let prime = i.next_prime(); + debug_assert!(prime.is_positive()); + prime + } +} + +#[cfg(feature = "rug")] +impl BigNumRug { + fn setup_rand_state(rng: &mut impl CryptoRngCore) -> RandState { + let mut seed = [0u8; 32]; + rng.fill_bytes(&mut seed); + let seed = Integer::from_digits(&seed, Order::LsfLe); + let mut rng = RandState::new(); + rng.seed(&seed); + rng + } +} + +#[cfg(feature = "rug")] +#[cfg(test)] +mod rug_tests { + use crate::{Big, BigNumRug}; + use rand_chacha::ChaCha12Rng; + use rand_core::SeedableRng; + + /// We need this property for snapshot testing + #[test] + fn rand_prime_is_deterministic() { + let run_one = BigNumRug::rand_prime_256bit(&mut ChaCha12Rng::seed_from_u64(0)); + let run_two = BigNumRug::rand_prime_256bit(&mut ChaCha12Rng::seed_from_u64(0)); + assert_eq!(run_one, run_two); + let run_three = BigNumRug::rand_prime_256bit(&mut ChaCha12Rng::seed_from_u64(1)); + assert_ne!(run_one, run_three); + } + + /// We need this property for snapshot testing + #[test] + fn rand_below_is_deterministic() { + let ceiling = BigNumRug::rand_prime_256bit(&mut ChaCha12Rng::seed_from_u64(0)); + let run_one = BigNumRug::rand_below(&ceiling, &mut ChaCha12Rng::seed_from_u64(0)); + let run_two = BigNumRug::rand_below(&ceiling, &mut ChaCha12Rng::seed_from_u64(0)); + assert_eq!(run_one, run_two); + let run_three = BigNumRug::rand_below(&ceiling, &mut ChaCha12Rng::seed_from_u64(1)); + assert_ne!(run_one, run_three); + } +} diff --git a/wnfs-nameaccumulator/src/uint256_serde_be.rs b/wnfs-nameaccumulator/src/uint256_serde_be.rs index ba02c93b..6935e85e 100644 --- a/wnfs-nameaccumulator/src/uint256_serde_be.rs +++ b/wnfs-nameaccumulator/src/uint256_serde_be.rs @@ -1,25 +1,17 @@ -use num_bigint_dig::BigUint; +use crate::Big; use serde::{Deserializer, Serializer}; -pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result +pub(crate) fn deserialize<'de, B: Big, D>(deserializer: D) -> Result where D: Deserializer<'de>, { let bytes: Vec = serde_bytes::deserialize(deserializer)?; - Ok(BigUint::from_bytes_be(&bytes)) + Ok(B::from_bytes_be(&bytes)) } -pub(crate) fn serialize(uint: &BigUint, serializer: S) -> Result +pub(crate) fn serialize(uint: &B::Num, serializer: S) -> Result where S: Serializer, { - serde_bytes::serialize(to_bytes_helper::<256>(uint).as_ref(), serializer) -} - -pub(crate) fn to_bytes_helper(state: &BigUint) -> [u8; N] { - let vec = state.to_bytes_be(); - let mut bytes = [0u8; N]; - let zero_bytes = N - vec.len(); - bytes[zero_bytes..].copy_from_slice(&vec); - bytes + serde_bytes::serialize(B::to_bytes_be::<256>(uint).as_ref(), serializer) } diff --git a/wnfs/Cargo.toml b/wnfs/Cargo.toml index f2332b76..3fd38cba 100644 --- a/wnfs/Cargo.toml +++ b/wnfs/Cargo.toml @@ -67,6 +67,7 @@ test-strategy = "0.3" testresult = "0.3.0" tiny-bip39 = "1.0" wnfs-common = { path = "../wnfs-common", features = ["test_utils"] } +wnfs-nameaccumulator = { path = "../wnfs-nameaccumulator", version = "=0.1.25", default-features = false, features = ["rug"] } [lib] name = "wnfs" diff --git a/wnfs/src/private/directory.rs b/wnfs/src/private/directory.rs index 89313bba..88c62d0c 100644 --- a/wnfs/src/private/directory.rs +++ b/wnfs/src/private/directory.rs @@ -2276,16 +2276,15 @@ mod snapshot_tests { store, rng, ) - .await - .unwrap(); + .await?; } - let _ = root_dir.store(forest, store, rng).await.unwrap(); - forest.store(store).await.unwrap(); + let _ = root_dir.store(forest, store, rng).await?; + let cid = forest.store(store).await?; - utils::walk_dir(store, forest, root_dir, rng).await.unwrap(); + utils::walk_dir(store, forest, root_dir, rng).await?; - let values = store.get_all_block_snapshots()?; + let values = store.get_dag_snapshot(cid).await?; insta::assert_json_snapshot!(values); Ok(()) diff --git a/wnfs/src/private/forest/snapshots/wnfs__private__forest__hamt__snapshot_tests__hamt.snap b/wnfs/src/private/forest/snapshots/wnfs__private__forest__hamt__snapshot_tests__hamt.snap index 347bc0e0..390fe3e5 100644 --- a/wnfs/src/private/forest/snapshots/wnfs__private__forest__hamt__snapshot_tests__hamt.snap +++ b/wnfs/src/private/forest/snapshots/wnfs__private__forest__hamt__snapshot_tests__hamt.snap @@ -3,11 +3,12 @@ source: wnfs/src/private/forest/hamt.rs expression: store --- { + "cid": "bafyr4iewia5aiw5jxi3ojkkwogwrrq4x2bfqskeg2zbq45gvrlqm4up2ua", "value": { "accumulator": { "generator": { "/": { - "bytes": "rGCe5WHIjiZjiFxYSolBMJVjSSp2tGS18oeHuU2n0RFR3k5UcbjIjxzCF03Lsndi4sCURnnka6qzIs9sl96XpmOG3b+ds6Kn2sdqnw22vdIWYjL5J63NtT26i09JMi8JWNYiF8aNRLSdXGg+TZTd1pN4Kao7k6ThdaPENnQeQB4IzzkputboM2ZUTu6Jxg4teVO5D1yXImQfJ1VgOGwWBC0j4xuRRZ9STH3tZw+boy4oC584XoRpagF0B+PM7/r8Pjmz/Bb2qVA3tTebeY6ZUeftEvodt/DPiEsvKvag2SdwzuPQ3IVTZOnNF3CZSy5G+W1WwLbMl3yXDxO4yMmcPA" + "bytes": "DnwXmD/vORPcLzdf1evo7nGljNInOtYHpODrD3+82Nnpu0qfQPxFLKSB2dhylrLkh4UmTnLZtphq+jBbSjrWkqRf6C/qEToqzAhkAPtkF048lnLaI3UjBCXagQjJv8boXybWdaxiKxTFN2nu9B2vzNyUl1QqO9wXmNkzWM1P4T8lIm6FTjWSbHg/TVTXkpv8nTgQIUA1A0Kk7jEtjb/Vl8VdTZ2UgBywKE1Pvf8HbmXDc6Cjg0K5+XXC6SW1Bk71iLdLM174Mu8KWDjb3qotRpqrGGeSIv1KI1v1VWCI8ZuohkVe4zT5JvzyKIizsVDKcPTKGR60H6enSeQZgShFww" } }, "modulus": { @@ -19,7 +20,7 @@ expression: store "root": [ { "/": { - "bytes": "EIg" + "bytes": "IgQ" } }, [ @@ -27,7 +28,7 @@ expression: store [ { "/": { - "bytes": "PysK81Y28dr+hdj3ik9MSrpRvYt/c53mpys0bVn8NSeklT2ELDB39dn82P0lBBeE/Y0vMHJIXYqSlmS3hY1qjcdzJhgPXSPZgUnM9/ZgE/IHlMGDNf2v87kzKQR6EsEPG5J3vhj9NKTY8X0NwYH3HW5REIDqJcmLfOxQctKG0PvS6t+NEeepocm6ljn6OMjGoivcpr5VYV1/GI+Ut6vrTfITxU6S1dJNpC8Ov/YvbxNQWd3OXOEnR0yXd/7OtXhCRPDgnp0KZ6GlYUfgfa7J3DzX+SjJBkyKn4vCyV9HIFtraBIA/mBuUcicg+Q+EEI2afXSC4F/xE6RZM7CddgH/Q" + "bytes": "WzUFTg2et93G6urhSL2Viqdf49sAgAv0vv8SE1SgzA2V80ukVHaZR6+PcbbkvJa7kqRzKbUJ8si3pckU/2L30Kmr+JVM38v6cQAT5N0y9KiTmXX6EyUIkQ5r+zfH8xybEhJ00mPJbRpB76OgZ24z9a1VLWQCcenR6GsrPWUkU94p3r8XBQtIBni/uHjKlpFvR/Csq+pmoBqK5qOYaDsgWn6nV8pgMIIRFifu6S7bw9SSMtRUrW/FFfcu1GjRHeq7UV71wyUGGB2gpC4Ekm8Y/tri1S3zHbLnh54ck+tjUZM0MMRSWnL+FvwXcYKaxfRmxooi0Jajw3zF+xGdW8hlnw" } }, [ @@ -41,7 +42,7 @@ expression: store [ { "/": { - "bytes": "BUpE9eho+KEgskxrwd9+4wlYCt/yfYKjub7PRSDxbG5oYpw/3YLg0D4Y+sNtAJWqqmq5RHiXMvdTpW0BI39W9C3j/jIJV3cK+/bbJTMR8/vtppzG1L75UlgVSa/Ld7ng2lj18N1iYfbzXGVvGw3yX+5i+syy6HED7LmjKaZkgDBPzlmvs1m3NdTluSTePUWfYL5YX6ASbSg0yqtW2+K1FwOmUKXJ1k50GmqJGUb7jvZg3bsOvbKBJfCTZP973McYlISdptaPNIvjVshSotvay15XaBwNUFRfxVvfCDxXRxisqqGzG9HUslUclQSvFdR2WssN64lHatfeIurB4AIhLQ" + "bytes": "JpTYbHBVDGw5673kIA4lqeXDoKce4FWIcUzot6Dz7jlQu9P/oIsgyVqxOsyywQNdzwbCXdzscWCzafaoX46arhINT9o9aB2e88mQLJrs3Q19cVojT1MNS0ozckERxcmJdarrm3SQMX61pyRK796Su33+5bKZ2QfVQwlhpQ6zC6bFrsXNtcM+xk82MgpFkhNNg7vP+LRUVzmRgk8bdsnHypPQE0jAOS/tn93KMV4aA32KNeZdxDwvFDJ/BFqQ0X0uhs0NA1xQbNqlUOfLvfKa2ADlU+Gn+wilPLwjnelZbuQSu78e+Y1kGDuYJPYG5aCYKlNlYfjV/V2BqvTgY6Qt7w" } }, [ @@ -55,7 +56,7 @@ expression: store [ { "/": { - "bytes": "NLRQaY7/LIeJkeF481XbATcYyftYoXn2UUgae0yxgkAlNOZb8e9bQyIX8WYBUeXR4PxQVJBoc64r4nkj0xYD5V8uRk+bKebOW9CiIDWj0kDF/E/ydUXMA6YzGsZuMM9mQEsomU+1501wnwVc/WDzn16FQFCDVf/URVC919Hr8OCG3drnZ2yMtGiszZqqECbM0u70CZVhk8deTWmwrjf1H1PSacmK6Z9CroQMBdnIBWBgC4LOK5TPsm0fTTdqMEkcbSJHokThy1eKAlXVficzX/T+OWq8/TkXp/qQQWS7wF3tE7GHWcIG4IBT+DRxm+p9SYowZq8IVfRhfOHZRTcc3w" + "bytes": "PIhixhlMETh9BGn4lF0klTdOCHH3/JngF0bGUZZg3HO25Qqp4c5K3eOyAohQYWIhyxgbOhkvzeVtG5oDNSVLcgd+6lMULgXBEEhavSX6CFLnxVoKLFqvvt7dxh5dUVTSQ6adIIa0E7hzu1Jt9E8mZm3C1rNz8js9+eaQwWzYynyRi78O/ubhgK8W5K1lIKtDdKI6VnOTaUKn/kih2kYhR/exZGWAzk9vwmDlsRRIJLHrTYX3cxZuTlMa2MwFov5WDE5zYSh/qe3jVmIXEhp/ffnWzEjwlbkZi6RpC/cT2NStprki+vwJdV4klvKpSdA8+5Ma+cUZ8PjeEBqLjl10WA" } }, [ @@ -70,5 +71,5 @@ expression: store "structure": "hamt", "version": "0.1.0" }, - "bytes": "pGRyb290gkIQiIOBglkBAD8rCvNWNvHa/oXY94pPTEq6Ub2Lf3Od5qcrNG1Z/DUnpJU9hCwwd/XZ/Nj9JQQXhP2NLzBySF2KkpZkt4WNao3HcyYYD10j2YFJzPf2YBPyB5TBgzX9r/O5MykEehLBDxuSd74Y/TSk2PF9DcGB9x1uURCA6iXJi3zsUHLShtD70urfjRHnqaHJupY5+jjIxqIr3Ka+VWFdfxiPlLer603yE8VOktXSTaQvDr/2L28TUFndzlzhJ0dMl3f+zrV4QkTw4J6dCmehpWFH4H2uydw81/koyQZMip+LwslfRyBba2gSAP5gblHInIPkPhBCNmn10guBf8ROkWTOwnXYB/2B2CpFAAEAAACBglkBAAVKRPXoaPihILJMa8HffuMJWArf8n2Co7m+z0Ug8WxuaGKcP92C4NA+GPrDbQCVqqpquUR4lzL3U6VtASN/VvQt4/4yCVd3Cvv22yUzEfP77aacxtS++VJYFUmvy3e54NpY9fDdYmH281xlbxsN8l/uYvrMsuhxA+y5oymmZIAwT85Zr7NZtzXU5bkk3j1Fn2C+WF+gEm0oNMqrVtvitRcDplClydZOdBpqiRlG+472YN27Dr2ygSXwk2T/e9zHGJSEnabWjzSL41bIUqLb2steV2gcDVBUX8Vb3wg8V0cYrKqhsxvR1LJVHJUErxXUdlrLDeuJR2rX3iLqweACIS2B2CpFAAEAAACBglkBADS0UGmO/yyHiZHhePNV2wE3GMn7WKF59lFIGntMsYJAJTTmW/HvW0MiF/FmAVHl0eD8UFSQaHOuK+J5I9MWA+VfLkZPmynmzlvQoiA1o9JAxfxP8nVFzAOmMxrGbjDPZkBLKJlPtedNcJ8FXP1g859ehUBQg1X/1EVQvdfR6/Dght3a52dsjLRorM2aqhAmzNLu9AmVYZPHXk1psK439R9T0mnJiumfQq6EDAXZyAVgYAuCziuUz7JtH003ajBJHG0iR6JE4ctXigJV1X4nM1/0/jlqvP05F6f6kEFku8Bd7ROxh1nCBuCAU/g0cZvqfUmKMGavCFX0YXzh2UU3HN+B2CpFAAEAAABndmVyc2lvbmUwLjEuMGlzdHJ1Y3R1cmVkaGFtdGthY2N1bXVsYXRvcqJnbW9kdWx1c1kBAMeXDO7cw7B1RJAgGnqmE81zkRCBx5D18ahyb0Y1ULtbf/Dbjh6hGJ7HL5PRZQARvXIa7qzCrN4yoEEH8GSMKBOjH1sLd2X/i0S0tv/JM4S2RusJx89ehZLUDqM8gAOfNbTxSgS1H3v9eBvk0WcxZLqOuZHCxNcwu7419ZK971JK9+ja79JsZvwCxHmvidZNNz9EJwlDneZs65VfPqN9UVn2E1gJ+FM0tcsYE63cgM0FYJ8QrGqVrWWHLJCVJb2tMrxylZJkKSDyTGHcWzw7eSPlaxak2dNz2HIfJKP8DxsxMfVWFRcoZrzMMPlQVMgk5zOl62gX97wWOZ1IxjYcx+VpZ2VuZXJhdG9yWQEArGCe5WHIjiZjiFxYSolBMJVjSSp2tGS18oeHuU2n0RFR3k5UcbjIjxzCF03Lsndi4sCURnnka6qzIs9sl96XpmOG3b+ds6Kn2sdqnw22vdIWYjL5J63NtT26i09JMi8JWNYiF8aNRLSdXGg+TZTd1pN4Kao7k6ThdaPENnQeQB4IzzkputboM2ZUTu6Jxg4teVO5D1yXImQfJ1VgOGwWBC0j4xuRRZ9STH3tZw+boy4oC584XoRpagF0B+PM7/r8Pjmz/Bb2qVA3tTebeY6ZUeftEvodt/DPiEsvKvag2SdwzuPQ3IVTZOnNF3CZSy5G+W1WwLbMl3yXDxO4yMmcPA==" + "bytes": "pGRyb290gkIiBIOBglkBAFs1BU4Nnrfdxurq4Ui9lYqnX+PbAIAL9L7/EhNUoMwNlfNLpFR2mUevj3G25LyWu5Kkcym1CfLIt6XJFP9i99Cpq/iVTN/L+nEAE+TdMvSok5l1+hMlCJEOa/s3x/McmxISdNJjyW0aQe+joGduM/WtVS1kAnHp0ehrKz1lJFPeKd6/FwULSAZ4v7h4ypaRb0fwrKvqZqAaiuajmGg7IFp+p1fKYDCCERYn7uku28PUkjLUVK1vxRX3LtRo0R3qu1Fe9cMlBhgdoKQuBJJvGP7a4tUt8x2y54eeHJPrY1GTNDDEUlpy/hb8F3GCmsX0ZsaKItCWo8N8xfsRnVvIZZ+B2CpFAAEAAACBglkBACaU2GxwVQxsOeu95CAOJanlw6CnHuBViHFM6Leg8+45ULvT/6CLIMlasTrMssEDXc8Gwl3c7HFgs2n2qF+Omq4SDU/aPWgdnvPJkCya7N0NfXFaI09TDUtKM3JBEcXJiXWq65t0kDF+tackSu/ekrt9/uWymdkH1UMJYaUOswumxa7FzbXDPsZPNjIKRZITTYO7z/i0VFc5kYJPG3bJx8qT0BNIwDkv7Z/dyjFeGgN9ijXmXcQ8LxQyfwRakNF9LobNDQNcUGzapVDny73ymtgA5VPhp/sIpTy8I53pWW7kEru/HvmNZBg7mCT2BuWgmCpTZWH41f1dgar04GOkLe+B2CpFAAEAAACBglkBADyIYsYZTBE4fQRp+JRdJJU3Tghx9/yZ4BdGxlGWYNxztuUKqeHOSt3jsgKIUGFiIcsYGzoZL83lbRuaAzUlS3IHfupTFC4FwRBIWr0l+ghS58VaCixar77e3cYeXVFU0kOmnSCGtBO4c7tSbfRPJmZtwtazc/I7PfnmkMFs2Mp8kYu/Dv7m4YCvFuStZSCrQ3SiOlZzk2lCp/5IodpGIUf3sWRlgM5Pb8Jg5bEUSCSx602F93MWbk5TGtjMBaL+VgxOc2Eof6nt41ZiFxIaf3351sxI8JW5GYukaQv3E9jUraa5Ivr8CXVeJJbyqUnQPPuTGvnFGfD43hAai45ddFiB2CpFAAEAAABndmVyc2lvbmUwLjEuMGlzdHJ1Y3R1cmVkaGFtdGthY2N1bXVsYXRvcqJnbW9kdWx1c1kBAMeXDO7cw7B1RJAgGnqmE81zkRCBx5D18ahyb0Y1ULtbf/Dbjh6hGJ7HL5PRZQARvXIa7qzCrN4yoEEH8GSMKBOjH1sLd2X/i0S0tv/JM4S2RusJx89ehZLUDqM8gAOfNbTxSgS1H3v9eBvk0WcxZLqOuZHCxNcwu7419ZK971JK9+ja79JsZvwCxHmvidZNNz9EJwlDneZs65VfPqN9UVn2E1gJ+FM0tcsYE63cgM0FYJ8QrGqVrWWHLJCVJb2tMrxylZJkKSDyTGHcWzw7eSPlaxak2dNz2HIfJKP8DxsxMfVWFRcoZrzMMPlQVMgk5zOl62gX97wWOZ1IxjYcx+VpZ2VuZXJhdG9yWQEADnwXmD/vORPcLzdf1evo7nGljNInOtYHpODrD3+82Nnpu0qfQPxFLKSB2dhylrLkh4UmTnLZtphq+jBbSjrWkqRf6C/qEToqzAhkAPtkF048lnLaI3UjBCXagQjJv8boXybWdaxiKxTFN2nu9B2vzNyUl1QqO9wXmNkzWM1P4T8lIm6FTjWSbHg/TVTXkpv8nTgQIUA1A0Kk7jEtjb/Vl8VdTZ2UgBywKE1Pvf8HbmXDc6Cjg0K5+XXC6SW1Bk71iLdLM174Mu8KWDjb3qotRpqrGGeSIv1KI1v1VWCI8ZuohkVe4zT5JvzyKIizsVDKcPTKGR60H6enSeQZgShFww==" } diff --git a/wnfs/src/private/keys/snapshots/wnfs__private__keys__access__snapshot_tests__access_key-2.snap b/wnfs/src/private/keys/snapshots/wnfs__private__keys__access__snapshot_tests__access_key-2.snap index a0b4046c..2976296c 100644 --- a/wnfs/src/private/keys/snapshots/wnfs__private__keys__access__snapshot_tests__access_key-2.snap +++ b/wnfs/src/private/keys/snapshots/wnfs__private__keys__access__snapshot_tests__access_key-2.snap @@ -3,6 +3,7 @@ source: wnfs/src/private/keys/access.rs expression: snap_key --- { + "cid": "bafyr4ics27f5xqe7ryshkpoln5w7nkvvsdnoaw55r5gfb5earluczlil4a", "value": { "wnfs/share/snapshot": { "contentCid": { diff --git a/wnfs/src/private/keys/snapshots/wnfs__private__keys__access__snapshot_tests__access_key.snap b/wnfs/src/private/keys/snapshots/wnfs__private__keys__access__snapshot_tests__access_key.snap index d40905f6..79f2b6fe 100644 --- a/wnfs/src/private/keys/snapshots/wnfs__private__keys__access__snapshot_tests__access_key.snap +++ b/wnfs/src/private/keys/snapshots/wnfs__private__keys__access__snapshot_tests__access_key.snap @@ -3,6 +3,7 @@ source: wnfs/src/private/keys/access.rs expression: temp_key --- { + "cid": "bafyr4ih2hblsecub5jvxxlbkhjgmabg2mnaxzq7jtzkchd4s4sacqxwbge", "value": { "wnfs/share/temporal": { "contentCid": { diff --git a/wnfs/src/private/snapshots/wnfs__private__directory__snapshot_tests__private_fs.snap b/wnfs/src/private/snapshots/wnfs__private__directory__snapshot_tests__private_fs.snap index ebb86a07..c262b2a5 100644 --- a/wnfs/src/private/snapshots/wnfs__private__directory__snapshot_tests__private_fs.snap +++ b/wnfs/src/private/snapshots/wnfs__private__directory__snapshot_tests__private_fs.snap @@ -2,168 +2,380 @@ source: wnfs/src/private/directory.rs expression: values --- -{ - "bafkr4ibpbyy7pbkq3kppxasqy7gh6nnfg35on3n76vamzzku2gberpsype": { +[ + { + "cid": "bafyr4ibfiuriisxil5heizpfzjgjezce2t44ob7t7njd2ygsuye7adokzi", "value": { - "/": { - "bytes": "SGVsbG8gV29ybGQ" - } + "accumulator": { + "generator": { + "/": { + "bytes": "DnwXmD/vORPcLzdf1evo7nGljNInOtYHpODrD3+82Nnpu0qfQPxFLKSB2dhylrLkh4UmTnLZtphq+jBbSjrWkqRf6C/qEToqzAhkAPtkF048lnLaI3UjBCXagQjJv8boXybWdaxiKxTFN2nu9B2vzNyUl1QqO9wXmNkzWM1P4T8lIm6FTjWSbHg/TVTXkpv8nTgQIUA1A0Kk7jEtjb/Vl8VdTZ2UgBywKE1Pvf8HbmXDc6Cjg0K5+XXC6SW1Bk71iLdLM174Mu8KWDjb3qotRpqrGGeSIv1KI1v1VWCI8ZuohkVe4zT5JvzyKIizsVDKcPTKGR60H6enSeQZgShFww" + } + }, + "modulus": { + "/": { + "bytes": "x5cM7tzDsHVEkCAaeqYTzXOREIHHkPXxqHJvRjVQu1t/8NuOHqEYnscvk9FlABG9chrurMKs3jKgQQfwZIwoE6MfWwt3Zf+LRLS2/8kzhLZG6wnHz16FktQOozyAA581tPFKBLUfe/14G+TRZzFkuo65kcLE1zC7vjX1kr3vUkr36Nrv0mxm/ALEea+J1k03P0QnCUOd5mzrlV8+o31RWfYTWAn4UzS1yxgTrdyAzQVgnxCsapWtZYcskJUlva0yvHKVkmQpIPJMYdxbPDt5I+VrFqTZ03PYch8ko/wPGzEx9VYVFyhmvMww+VBUyCTnM6XraBf3vBY5nUjGNhzH5Q" + } + } + }, + "root": [ + { + "/": { + "bytes": "6Q0" + } + }, + [ + [ + [ + { + "/": { + "bytes": "lIqujxHCkwppW376IJssGcxy5p8TLQrS9DpbT14Dh5NsUpxAbhyp6ZOPX6GrWLIL2jxhfHMLACr/PUy/Xk5QM+MdTFbGInt/cT5Nr8ATR6r6RdEjU9wh7n7wDCxVoYceu4LwpoHa74Os7185/7DOBYiqdG7WV5Cy4AOpLSdabndXhb+wMKWHXrkoyOi9R0UxtBXJWnNdALZTvkEj3drKeHfaH2jvkAap1bL8th3mZr7HhfCJMO3gzu8Ut2tALsxWdVOL9BoVEc+GPjlo7W4pz2pCM8Io5unEnb8nwdlakQpgOGsjo9SxX7vjccMgoYma43PVxCUk4lrr0tn/Wite+g" + } + }, + [ + { + "/": "bafkr4iacv4rx64g5hcak7p3eqh5rjvtctk3tms3l55l7s6524uojui3gpy" + }, + { + "/": "bafkr4ignsuoyxnoxqlw6wrryymod2qpzczjwqdaallf4ldv4ujzbzj73je" + } + ] + ] + ], + [ + [ + { + "/": { + "bytes": "oQFcAlCbAaqjLdfLoKs5ES5a+CNCfJz16DfVCFUsXAHhv1IFwEoWZrNxcm/e9ufBeH4YIGW05YN9aoy4iv6iHBeT8XgHay5LgBUKWAWl3NPMlt/N9Y7hk5kjynmAXNI8nkGwKfe0UamToMdLTpqpzeiTpjo2D/sIHDwZBpGAe/M496cLPZAXQe/nkqiePII8UfpIuoEJ0MaZWcOVIBJ+15YhJSW/f1ver2dr3TpWqJzZ80Ftc+oUJSZ3zqQwz6EJC1bqIfMufm1MjSZV4s09xe5QnI7WSjK/Z+jintpsAZOJ6znSrj+u12MKOKbxnykxRCm+8KmVqaeRqHzUmAY7Zg" + } + }, + [ + { + "/": "bafkr4iahin3hzsm2b73deeogau3shuwtrq2k5ygczipcdcnvf2xoopd64y" + }, + { + "/": "bafkr4ihzowv3xejcx7gmjdjeiekbdynuoyu3ghn6zunvwu57s4dw3kwhmi" + } + ] + ] + ], + [ + [ + { + "/": { + "bytes": "nn28+vTVE59osEe6bTqsYv8A8SfdDVCxvTOLSnJZYLld5XAOXozb/mY+7V4v5jiODRRrasZ8kAm9zypgrvMOtTgroVFEinGAShG+ps+ivxJwhG2xAKIsUnsOQ4t07ptavFyLbvBBg7L3Idm1fUIXIDfEZHAPb0UQzDGgZKBgNLlwEdmLRML0aOh7aMrEU0Y6bi+95Mild/lUxp8k1q/+brxn5hD7+C/aaFjSadKY7L1/4/szL/9A6Ss+WXVx+B8HHDpn5UfIYO9SDIcLzox/ywG/bxBF8safMPZwlrb5t6TRdpXBveTcVjDG+9cvPoftPoNm/PZCJ+Yf5sSWbhfUlA" + } + }, + [ + { + "/": "bafkr4ibhraqq4prlc4zsuddrlwebj2l3emgxehgdcuvppohr6y2ruoozx4" + }, + { + "/": "bafkr4ibpva2zlmfnlujo3znj2wox3bvysnhhhykiwd4xeksazyivwihria" + } + ] + ] + ], + [ + [ + { + "/": { + "bytes": "pE8dY9E8CCiMGJRpCV9bGSxYSezB5SECK6mbnUJgXXZDs5taOLWSROGajSU0+I4UWQCND70APPfRhsEH2IxIYMBmnjS6iadwCB5l5IzS0qIMZp3SdeCOHysvX/mt7j7zMxvSgMYpd/yBV+JpjHW9EXv6Nt1np8dCCiQULZywZOoX3nJxy+BT6AEEytNJUFyPqefpXL3q7swVTyWw9UySP97mEjrEFdKEbtH4JdPmqIRwbEu4GA3gJ2w8psNdqzTxmUa4HuQcU/ta/M3l5zceNcD5E3G4PIcROZkSx7wLCdnDxXSU3vIBYvCn62DDgeyWLqcc4TwR78ls9QTXOQnN2g" + } + }, + [ + { + "/": "bafkr4icyunetfy6kvn4wrplm7mruibripujkyjjbso4yoixcvoi53qfboy" + }, + { + "/": "bafkr4idfb6czevqvtq4r5m5trlchtxo35gmhm3tzqiyhzldtn4aaey2vpe" + } + ] + ] + ], + [ + [ + { + "/": { + "bytes": "J/4F0qCn+UoYdwTymAGlzfpfFMaqi6qaxDiQZ0UZiMnbmlz0tf6jD0vuYVaopoS40TSfQLRF9GJ9n1tItJsvPiQzgQg2O8LSRH9yPimXczCxzG6pVBbNzlq9kSeSA0ydIjE0MQIj7pDiq0dHjbJLAFgYo82bfndbtB7jlETUijI7lO6MJnrb0DonXzH8DKh1MDtG2SjFjUMmj4cp1t/gyZRTpYIxboqT7GYqPD/C4Tc1ulEeN1Px0evQs/V2ihdKi8/+oJND5ZddkSI0w0H8SvFRcXgyl95SXE9oA2u/JsJFNsDujBPH9nU5pikYknf4hEsQJWoM4RMR8l0ZS/Io1Q" + } + }, + [ + { + "/": "bafkr4ia5xkxzhnkaxwvtfvz2ot4m4pf3aapvusg57ixrnubf2g2pe5vsdq" + }, + { + "/": "bafkr4iev75qq7mmrndgf5rtrwfbp7h3acwrs6ws322micp6lqmatzuv6iq" + } + ] + ] + ], + [ + [ + { + "/": { + "bytes": "lKhU/rclBXugS/Th2tOyzwpPrsZd2C/gl/HHo9J4WaIXFgjvQyoqrvRPPcKzuHzbeHdTjcG1ihsQ5ia+atYGNCx9RhfxnjXrCxdMpP4ZTOLfuJhi6vQ840NjcutdMfUp3OmZCq3klhwMCLbvW3Rg9269FBEhXrzhjiFFopL9QuzUyv3jzbC9+nznXA3mg+8yO8lFCYCklRWiEe/23KZdmn8h0alILcw1KM2+0wcKIG0a7kh3GknnWBhZp0Rcm5aKvTca/E6Gna6145yCZ51Vra2QaiPq5xbngsnlpA/GHuaA1t+fVBnyi54eeFFNurfoxrq/hR2dq6gsJDpg2NDJAA" + } + }, + [ + { + "/": "bafkr4if2ng6ts2xei6cca53d6tgq2igjioiirk7gm4bvciwhdddhqno77i" + }, + { + "/": "bafkr4ihhaet6xdsol6oabwqjopk5jpppfd7sshvtdrfhekryrvi6qspxdy" + } + ] + ], + [ + { + "/": { + "bytes": "ZCS6Ok+fnR00uTBixwlVE0L9Ch+lN3joVJ8yUl4cASzc420cupVjWmkETKVCuWtGOB87gKXG9+K5cJZwujztD3f02l1XVVnIrlIzxeMAIoeghKL2Bc//LccukHuM24yxuWO4ZK5Ui03nXmjVNp3AoUsGUYA9tcRHSgP39HSCvZRFMoB917TBzKgcYgne0ty2JYcovcGzzA6qMHeW70GOdolbfiHBGn2+4vB7et1rsh5eu5wnn4W9Rt0NwYaIklm5aXtuazFUI7SmA/DOzr42dGcayx5hk167gk7OWnrhzQgfNaDkLS5JFUwBAgV6o3/6HHn1Rk0BRRQ6l3RJuaI50g" + } + }, + [ + { + "/": "bafkr4idg6snyh35lnpvzcgesjkaaxx6zjxshpogd64ze64a5kktfo3nzvq" + }, + { + "/": "bafkr4ifigj5hkswtnxpipcaklzl7jjte4u2jzry6azviw4uionctsa5wqi" + } + ] + ] + ], + [ + [ + { + "/": { + "bytes": "k72QbYimqbJUBm4paL8SliiDyvfzbH/W2LVTx73tSvlbi627HaB0Wl3yuCOXyKUsTHnflhG/PlD+FDhxyt41aBci/QCKNcWELMwbThzEvwVpOyr6nmY8CK2xZExMVYZG9X4p8yxoLk7lL7O7dmKANvD1c8dMtZ163XEFn1jfOEF9wgUutpZIJKYv25TNiuR7xQEvrkG12tglGTCFcYTlQqhrGusqStzWN2YxUhwAX5oJGLugzDIYzul72D4tMZTFuBeDfKkPc4AjCIZytRqo5nph+m0w866pHfQWaFVWF1UGjiBjr1bpMjem3/9kvmDIHbz5ul5ZERF+W57CzO/bAw" + } + }, + [ + { + "/": "bafkr4ig24orkcp75447hy2abpan36i3woaerfsg6bnu4z656d6xpa22jsu" + } + ] + ], + [ + { + "/": { + "bytes": "Aviy7qyjHRxS/HMSMxg012YAggdDAltf8w6ryYdTJiigaO6xjanOWCYKpoUOhgnQ1iuwuqnoyizRiN30TRHug6v/mp+8i3fghWAvYJ5rFatUikwCeMQu00iBBEvtBNGWF+xezlqByGPiF+YM2sEn0kt92CSunAOmvdGWAdJ3Eg3AF+gnSNhv2C4vIxFLgPcnbLAQfvB8yw+IH+ebykkMgkxPubPWT6Myu/OV3KsWsxQWYHHyYf7hD8oFn/CAoRMhLO+LNjUbrVg6ISC8eSK6yTOV+pPkstdXM3ew2WZ1sUr+4kV3fsRJTNkygT1dL3QwBzhxRaraxclc5QSBkXj2NQ" + } + }, + [ + { + "/": "bafkr4iabb422gnp45fdjd4onr567olqprcl53oblnyima3oenyqvae3ifq" + } + ] + ] + ], + [ + [ + { + "/": { + "bytes": "q8NwXtwPFv7pCNj+dAhEN2fvf/jJktEWKbkzqbRlTVt4J289ERcIiSEm0jNWLqAJFchuK+3PhPWxqXdchcoyf1a1WS8DihWn7CkC3EId7KyJ5YGyCJ49VgbP7pbzkR/00db2Gkf4YBvoudfnXlA4lAQvz8RD3LzPmn9NQDIaq6m24xSFHTi5cRJhBP9PFq78JOcxz36J3qDdhQj7YOoME1YwyDP6Zi8KqgIofPZOwvTjykUkdfHIlxymI8Fheo4F0kXeffLl/Huqe9b9lydbVDTJliZF3lIw+CG6F+JtVUD8v53g4uLmxwc7CwDzKQd0WRTZQL3LOMYD/5v+665cWQ" + } + }, + [ + { + "/": "bafkr4iczjy3vg4v3snxzouqcf7hos3gta5ewwrqh6sp6243kp6nlxv6axi" + } + ] + ] + ] + ] + ], + "structure": "hamt", + "version": "0.1.0" }, - "bytes": "vG6ZYJMyeptrhuJGi8skFx1dpDnCGMy40/ExTPFIbgoktrjNz/xvzjbksKgkBoampf3u" + "bytes": "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" }, - "bafkr4id27ok2an5uiboe2ssvitwsgrzfavh4ez7wx6q2cw2c4joxxql6je": { + { + "cid": "bafkr4iacv4rx64g5hcak7p3eqh5rjvtctk3tms3l55l7s6524uojui3gpy", "value": { "inumber": { "/": { - "bytes": "1cyBk6sbmPKXUlz40b1pVHvcIwRMHbiwODcdwKumG70" + "bytes": "9pQ3MSKex2oCplmGGVII5Owkk5agvM+2Vct/C+9ZjDk" } }, "name": { "/": { - "bytes": "um9VJDY3OLnrrQnEwNJN+i5t+bcJdwmwF1Jusyei6btilhiR0otUC2MZnzWBg/vVyfnF6j2XZ33LTQ6L7CQR0Bw8fgsU53tl2F5MXobl6sTvUZ8iA2GoJTO6WG7xNhjHdODjlzEF+ggLakMeADwugBT/A06ujzfCYuAWRdP4AgMd7tiE0Cs/ILvwZFKlNczay7us3nLMcIiZ+0XM8APdaoGBKunnQhhYZ7+TlJ+z670w2WLJZXUm18EUNxqUKPS+b/eCN5zL2KcieA1DOIBvLA1XfP3WrQDNsx24x6Bs28/zOLtL4N5Qm4Ucx8YGvNgWlXTY+X9q93ui9lV3geEGVw" + "bytes": "S/ls0kBalPwc+iDXWpahp3wQ2+WOOxYGreewh79e1lFl3+Z2zFkTn4eKu8/HP5/BZqLxy4DwZB4Y/eejZF9ID7+rUizD3kzM0YmGBgiTujuXiVpIPNk4//qJm7Fa9qdZrBYTciHY9aoXip0UJK88GtCP6nn6TWutcuf+7prysBkYjRlFxswEDMfqmAy4dpgUPLWilkdj7IyHrokqo1VT8QzROow9NMv+mPhWF+4M2lQpKKIvQGQ3DZc7C419p5dLUBzzOjS4w9AFrxzElEFGAhqytWoXEyqV5Lz/AtkIBjvb+oTVvFs1r/hpbEhmXURFnELqV+vHMSpa9NGzBosmDQ" } }, "ratchet": { "large": { "/": { - "bytes": "GpPS2eM4KYKxTrnUF4hE+IdT+MMpHQPGyADiOmBSP2I" + "bytes": "jplWEnfjcZTajnfsX7TYhbL2nB3LesG4Pj7uJd8cT2o" } }, "medium": { "/": { - "bytes": "XG+clKQWS4q3xUwFb5esCORwk3h6siOSN8PVcyP/o6w" + "bytes": "0Ja9S3VJOqUQXtJ0nFpa8R4vboY0eYAjXon9WM3ehqE" } }, - "mediumCounter": 255, + "mediumCounter": 39, "salt": { "/": { - "bytes": "htI64YMc+k9n7q66I9iTAHCHdJzTaHv3zIHxja3fHYc" + "bytes": "bt7le++zTEs5jkCzohJnSEiXJZ8uJSGUexDLp7zen2c" } }, "small": { "/": { - "bytes": "pHKRxzsl5u4VWDntI0H67n48J2+UEN+eJ6nmMIzCWy8" + "bytes": "hZBPNt3qnCpdcqWUqvX0SiwUVrdr7rq9l2HHefy4YO8" } }, - "smallCounter": 233 + "smallCounter": 224 + } + }, + "bytes": "2JavjpQDjD/eipAgVbGkNTH/2yZrZxuveDgKCHXLpQWEZdwWTdM23Cr4lp6oTJvVpw3qMhbn2KPFdF57v5tOM3LM+wDU9b8zeRP5lU0ewQmabaR5JEsSp3kE/PPk7xjaOCP1xFT1ZdXkwC+35Yote85VrQH25TBm8eWcAtJ1UbdTJH79r4EzG2ABx+kMoLMOTEUCWu6zRBRwcCL65/BxD4YWs8kL9dpsSV7kQb4xuoffb58Dt7TbY0wogs6XLhO1h4yP+ko1CGaxy6V4dFqaKktsqDShG6eQL5ATc2MEu1ROUB/95uqP+oKVfC8lmNww0aFjpXK1nvhc8hNG45JWVSGsm6m3aLQrTUrJPa4pPWFWyOQw9UAFCS+eEXxbmDfxlOe2R7NmSTpsQH8Ha8X8li7WIwP0c391qc9AYwYL3XBJvqnSwY3GnoZ5ya7MnAovs/hHVd8Lf/3ErkIIGU55OmpoH9PMfHGT9BjN1trw2cMomokSCXJhNHoyT7LtgCHD1XqsmCjw1PcyDoQqDqFXdBsJplna4MEUskaZOFM7M3k7rPh3UEi+Y+ZK2Fhx+iNhzZw3bA43FnX2C067nY3cFz+05+09nwXxZOBuJ8nKtnbv5+/NAsLJgvwwvpQRhSoBWVaQKcXStjlH+Q5JMKWqRYwm7RwYiRLSe8A8VtV+0FX7oIu2f895nw==" + }, + { + "cid": "bafkr4ignsuoyxnoxqlw6wrryymod2qpzczjwqdaallf4ldv4ujzbzj73je", + "value": { + "wnfs/priv/dir": { + "entries": { + "movies": { + "contentCid": { + "/": "bafkr4ifigj5hkswtnxpipcaklzl7jjte4u2jzry6azviw4uionctsa5wqi" + }, + "label": { + "/": { + "bytes": "i+Vcn1q1WampAbwZmkCKZj17z8+hGTZsqojySJW/v3w" + } + }, + "snapshotKey": { + "/": { + "bytes": "xjVdETOZFxTc/3EYwdj6HaxAExeWR13hDrMvlJipxK0" + } + }, + "temporalKey": { + "/": { + "bytes": "8EV+cWCG7lqz5IJseUnKe45Gghwlbhb2Y+hZNxvYUrIL6eEzWhcNYA" + } + } + } + }, + "headerCid": { + "/": "bafkr4iacv4rx64g5hcak7p3eqh5rjvtctk3tms3l55l7s6524uojui3gpy" + }, + "metadata": { + "created": 0, + "modified": 0 + }, + "previous": [], + "version": "1.0.0" } }, - "bytes": "6rSlRYc/JDqMDHabm6I+1yQ0NKkmtCk41qKzfyg2wuS71KZDAbyuYpq+6SGIxGulZofSncSKN+JcrjrXs0T3r5RynGTv6TJozRZXCMdynmAMxUzep1ox9dPy6PBSDCsPN0LqnVbF4cw0fAcH6adUoH5Frlz9AteTcPWJQ73iMtQAnKbDJrLODW0gcekEnuB+S+zSVArP9WguxbddUFoLnVfxFzg4j8dbkgeJB4Ix/AGwJjqZ5ir27PJcRi0hzuuSHAznydOACqUK/w7723pKf34rFyt/lsnNE6ULe9uJbvSU80Qb75Nl+LuLZrmEgcXJfew9mCLgMOIKtjbuOFLMZEgLB/P4vOWk2PIX4T3htgtxE4QWlWkUc/xZfZ+3qvQkxFAPKRoTBzvkmK3RXB+4sVv4E2ViwhBRgaa4SUl7OCp8s+1uS4aAHauB6L4Aqu/ER0ONOHjPj3WdNUjhxWJyRpRQAheOcu8rIfyNeDA/AAvQNj3X+AfeUOM2jZjUDBuXE4ylXHhumJ1Dt6fAO8L62NKzaU8ljOPtb5V/FJPwKBHkmL09ruSREMFVpX3IMP1D2ijoh/kaF/lPH0H7nltbNCHv+V02DK9SMZJYtAs834a1AFlK1uOgANs/kOXk2ft6DH0XAuLl5NEtCGp+RlUtOsToZNC4MB6OX1CkDOASWjxAfMm2jC+zqQ==" + "bytes": "Cza5T+uIf+6zBPzXJcYOTSgpGd8O8kMRKVEAGPlts5APSVvpUjmGAoIoaPPmWZv3Eeo6NeHfnK0916Dhh4MgXqhjbyoMBjvyaXjNe8paWK7qALH4gfOOH+TZJ4rXNTh80kDZ66qC45Ra71XhJiJ2zDfIJNnZiD059Lxmm56qGnoQWYeT0R1K5iBwyJEyxR1HEHOuOEoZo3hRvF24mBQrbBU7ky9G4EvNAwAqL1I2MCPdunDtodue9bhJ2THd5zUgcTUm7d1LsSmPyHzHJHcJJ5ES7lxrTC4MVIfY3LHR/EwkgT2XyHObKuxX+tY8TN1hV/eiQr+sxmmd4EADAfw3KnY4UbQ/pIzZAHQgJr1No8Xakw/UyoYHNIw1LwHYWsTFEhxwc5ptE7L0NwXzil6J/sK4exITR7CbKTkq5/vDf+prsHAHa1gTPbLeEMhMMD5xJrdPzt4WYFhWVG4HFZyCHGMZXFgAg+XAgq18rR+Uq1ZG" }, - "bafkr4id4dtihsnfxer2fetfspcxgakiq23xk7cxmumpvzwn2kyoxfwuh2i": { + { + "cid": "bafkr4iahin3hzsm2b73deeogau3shuwtrq2k5ygczipcdcnvf2xoopd64y", "value": { "inumber": { "/": { - "bytes": "/epnMhLPbaKxJ3tzajufBGYruZPYdUsVFumgMBC26Fk" + "bytes": "wTIY5Lj52cZAPjN2QxQb04Tvs5ben9hjXKIVD5UpCeE" } }, "name": { "/": { - "bytes": "PysK81Y28dr+hdj3ik9MSrpRvYt/c53mpys0bVn8NSeklT2ELDB39dn82P0lBBeE/Y0vMHJIXYqSlmS3hY1qjcdzJhgPXSPZgUnM9/ZgE/IHlMGDNf2v87kzKQR6EsEPG5J3vhj9NKTY8X0NwYH3HW5REIDqJcmLfOxQctKG0PvS6t+NEeepocm6ljn6OMjGoivcpr5VYV1/GI+Ut6vrTfITxU6S1dJNpC8Ov/YvbxNQWd3OXOEnR0yXd/7OtXhCRPDgnp0KZ6GlYUfgfa7J3DzX+SjJBkyKn4vCyV9HIFtraBIA/mBuUcicg+Q+EEI2afXSC4F/xE6RZM7CddgH/Q" + "bytes": "WzUFTg2et93G6urhSL2Viqdf49sAgAv0vv8SE1SgzA2V80ukVHaZR6+PcbbkvJa7kqRzKbUJ8si3pckU/2L30Kmr+JVM38v6cQAT5N0y9KiTmXX6EyUIkQ5r+zfH8xybEhJ00mPJbRpB76OgZ24z9a1VLWQCcenR6GsrPWUkU94p3r8XBQtIBni/uHjKlpFvR/Csq+pmoBqK5qOYaDsgWn6nV8pgMIIRFifu6S7bw9SSMtRUrW/FFfcu1GjRHeq7UV71wyUGGB2gpC4Ekm8Y/tri1S3zHbLnh54ck+tjUZM0MMRSWnL+FvwXcYKaxfRmxooi0Jajw3zF+xGdW8hlnw" } }, "ratchet": { "large": { "/": { - "bytes": "8ufcdgR4/0iTfYELDx5sK9gGQtzOC3BW71VrvSPQee4" + "bytes": "0Xcz7RLjVmm+AzcWeY2i2QLcclCjoJktNy65o58rQDw" } }, "medium": { "/": { - "bytes": "2KAJiog2xofa3Lecmz8sLCBl1CIhaENQsrSE7pAncsM" + "bytes": "Nk4K4fSXXGSIL1hQ0gHHVGKjY/xSLm4fcLv3z0IPI5U" } }, - "mediumCounter": 32, + "mediumCounter": 187, "salt": { "/": { - "bytes": "IvkVvmKdvl8sX9yg+GT5rbhKogrQHvC3YhB2izQJLB0" + "bytes": "ONa5zrgjyuV6QSBzqKdagXT6HqmDbOX6b0+TK6spVOw" } }, "small": { "/": { - "bytes": "xrRN+zDl4vlZZi6V/7XpbxTmurGsLw1D1jRaI8DgLBI" + "bytes": "/L33L32w93i0T7oGYx8u0Yxb9QWBumanpcvXJWQQWHY" } }, - "smallCounter": 85 - } - }, - "bytes": "ii7le04vg5L+Ba8NzLeitiRjoiELZHxNwsAMiHJ4u1iPqhNogDLMaMXYnJvnEyipIJWyJjB2y57EAdQNpDa6Kg/eeHgia3B3jjH7qnaVY89NLSB7yVaONLd1g941kLxeW8O7ljsDbE44U3jB83vR/QSwtBiu5iMBSOzFaf4ehVgNSFXvERjdQBJxNnVFx5qjl15FZyOr/AzxEDdbu+fEDlNRMEg9BG2ztzzsl6a6bU01KjowBhf0RNarA1eIfDxa4b2WmqnX0dqHDJqLceIyoJclMqcLJ/IzxBoq4ZBuqIc75P8bnm8pyPAecacbU+w3rPTMJ69OJIJQYNRwI/q/OPeUE3Yj9cnA+QiYlbbjjyJgODDK0cf5Q+LGlew/FvWdK85SwsASbmsJRxIc8zz1cDWTeUSyQEQoqhuyzUyHdWYiRlP9kKZ828kUl3ppCprdpBI5XyMQcl4vIkKaMKlbBAHzgAHmqColmpJBRoRt6CE7aIB0Dri8jSQMpuNmdkpX/a25VEwU9PT8xmGDLcyw918CmPc04ulN6wIzK3omsnM1wM09GF3YD2STmdlmSiXup4fnizfD45AQi8KwiopgMdQhdZaRzSDTO5lq7B8qs3m+zBXnBJw13wZdFp5g5ePiAR58CENxPBlf8MqZZeszcyi8M6c0S4uY4cJOG0fB9wMe0/5g7dpIfw==" - }, - "bafkr4ids4frwdo3i7vfotshrgrid6tfbbx4bkwpprpt6i5shod7nsauxaq": { - "value": { - "/": { - "bytes": "SGVsbG8gV29ybGQ" + "smallCounter": 183 } }, - "bytes": "SIFrP7QTHcbJxYRf//G+3gbIYuM7r1MNps0gn2k9Y9XuX8mgaZwXsFM3+OCIhXO/48cK" + "bytes": "7hBOK8/9N8LTsZ07nmvXlVYeJuxJi6xLyf90IOlERtDf7KJmA5w7490h3we6S+3wcNH6mxurxELKkcNQSqhWlBZ20jssL4D9iUEtHg0s3AtSbcPjYvPv6uhNGHcF/aNMyokLO6n3NZ1hRdNy7dzxBmAmx8P1hL+2U5IywQCatHraSS8AiDZS12nktfSUbo7PTfW3IfbtN+rAR5Y5/ZwCbBjqzPvhzmdSjXDQ+7m/Ady9GS/AeOnpp9oH6MbdcWT1YwuJXO2e8+hKSmIEdPLpJmgdqfw9NpqUVHenABPjPiUtUScDRx1AiRgwxQKXo3yLyGHTk1GQRCQuvZc21kwBwwnP3RMqXiK8ZkUjiMM11RFeee71mHFcvgzC5RT0YkvDWalR6EoLzs6AV0OX8v4pFhmzVZyByiYcGkX+fb3qnuArbl3RpHLH+cO1iHScvCgqLT9M0TtIB+Y4UiOE6gwZJR4X0Pwdm1PxcYYcBe9Lo4Ln7A+7knWMp1j3SJaFGCu+WCAqwAv6RVwHR3RkJGVHHgFUgLKKCVQu/obEUyjh+RPw8AabldmG62lLzTvamKKpb0xUEG44zApJqlRlztQ0gZ7bSXSE6Wuy52RMB4geEvi6n9vByG/9WsGZZU7AW5JCCVj1BSDc95WZjb0xRw/o+l8tglC6YV1OQa54Dk+/LRK96xudFBHzAA==" }, - "bafkr4ie4v5pcplbse5oplfwh2ddy5vphqizlhzuc27nvputzgypwjkic2a": { + { + "cid": "bafkr4ihzowv3xejcx7gmjdjeiekbdynuoyu3ghn6zunvwu57s4dw3kwhmi", "value": { "wnfs/priv/dir": { "entries": { "music": { "contentCid": { - "/": "bafkr4ieds46knvozeny3uexqfhr6rg2orvvlhu5bvdsbdon3dy72fcolme" + "/": "bafkr4ihhaet6xdsol6oabwqjopk5jpppfd7sshvtdrfhekryrvi6qspxdy" }, "label": { "/": { - "bytes": "GBMA4EKNu+NkaiABT0r+nXE5trYw9Y16BfKxG4/G/3U" + "bytes": "h5sQVvcQqIiy7t2E6J5E+LFlurXKT5QLEbHxGPVlDrA" } }, "snapshotKey": { "/": { - "bytes": "GctU041tbnQXxQghFycZ3NCi9KXp9FEvCpsX1fHN/hI" + "bytes": "5X7tyBMCXzOlkKCsXIbFLWcXexyUQj0hZUIKtp4Wxz8" } }, "temporalKey": { "/": { - "bytes": "mflFW4FzetFh3s+OhhotdmMys+lFVMcJ9W5OnMyNsHcXbcDdS9w7Qw" + "bytes": "F46+nL5NLAa7hPDhWqejs7sWL42jPBbnr+ERUXGAyjmOPchbLDIdJA" } } }, "text.txt": { "contentCid": { - "/": "bafkr4igoes2nc5ibp3kcq5qerw7lvdwx47v4eiycn37kkqr3qngepjbn2u" + "/": "bafkr4ibhraqq4prlc4zsuddrlwebj2l3emgxehgdcuvppohr6y2ruoozx4" }, "label": { "/": { - "bytes": "Pr/Kvof4PIwow7w3/F4NgNc23oJKynd+PIeWrWiwBMw" + "bytes": "U3E47CR00Ze8SwdG3p7H2vciA4ixQzldWgCtKYH2zjU" } }, "snapshotKey": { "/": { - "bytes": "yxUxDoN7Gl3NXf4T8vpSb/1uTLHf1/lP4zUtMN7N4pA" + "bytes": "P0JI2br1vLOnHBj+FvdhqShwftCZmMbk4ev+kVeU8oo" } }, "temporalKey": { "/": { - "bytes": "Tl0NzzZCkOQMJz7KBpoyzKj6emCS+IzbGi29QMSGn7lIhkCk0Xt5Jw" + "bytes": "0mdxowC9s8LBOHOWL/H/yL8IOqpGn9jtLO8kjKeLFoiiJp33clLz3g" } } }, "videos": { "contentCid": { - "/": "bafkr4igkqdavo5ukmdawyydj4jsfmllux6azgj2yb72xars4ljmmwokg6u" + "/": "bafkr4ignsuoyxnoxqlw6wrryymod2qpzczjwqdaallf4ldv4ujzbzj73je" }, "label": { "/": { - "bytes": "MdJqK4GLwV3ODnzA5uF+o1Wgo2IadpsdxNOevRGvaEo" + "bytes": "DdDyd491x/Wbwc6Y/zI7cDEcqTTmtvgQnALgnhiZS2Q" } }, "snapshotKey": { "/": { - "bytes": "bMGva1260vF7e0lkT+FqES0slM0vgN7TryBjZpdZ9Po" + "bytes": "ncNrAzuzVnDzGUSeEtE4x+3ahIoEflbc7y3KcTYfnic" } }, "temporalKey": { "/": { - "bytes": "K6nfQ1mo3dARe1fSfJVc/xlI/ULA2zipXQmZn9e9Mu3fDcPAlPtIBQ" + "bytes": "D8R7Iuad+1HW+9NI4pbFRQuAHbqTPCKB+Ipjyee8MApkjeh3zEFf5A" } } } }, "headerCid": { - "/": "bafkr4id4dtihsnfxer2fetfspcxgakiq23xk7cxmumpvzwn2kyoxfwuh2i" + "/": "bafkr4iahin3hzsm2b73deeogau3shuwtrq2k5ygczipcdcnvf2xoopd64y" }, "metadata": { "created": 0, @@ -173,75 +385,30 @@ expression: values "version": "1.0.0" } }, - "bytes": "35mqAHTW0wZrgWimDb/hhmgqfPCkjxsxlcrOuh/V5GzKIPRMEMfDrI/YHk3kqMCfuGfWoIAHP0snosE2RsbJMbo7+wT2w/tiCOTNmoakRn41dEbr3aNSosphNk41rYH90RoggzQfmScaiWpyogT/z4uCqLOM1OSpuiUm3vf3MBMEvRsWa4dSohraIWdJYx4dS6c38oDjlT9QAuBI958Pi8XdiPAseH1duSuA/WVEAN6/igeiUJCBjS9SdUZ2TygsKnyCMRXu4NGj66WmjUGPO3G9SBgguJWDXqyKVsz++nEbyp4syscM56T6w+6h3OsMiiirVfPubySJ6WqtqHVdUdID3TAgDjcek5LJTi/dCjUlxHnLJNJDdHdMfr/gSPrnmU9b4cuxMGouT+8BlKK8yR9hMARwVazzt1av57uqUkGElpa5e71gPPViVdCe+t1c3POIGOzl/BmUh+qh/bSSWB0o30dFV2uhR+vWqPYTYwb22ZI+PfNJ4H6YRI/O22+e2wdMsNa6WGzR7V01lZ8n/vL5gprkEfdjlotC8EmPbjGHCc3hRrj/8cC53dpQZyklTd4mX7lRVoD6+cWJJFt9QNhEQuncORBSvjQJzVftHsYJgA39jrhadMG/psKR2QWBnv4iGySlCqVxcP8hjsGkcZ5QNM2fO/nIJ1qY5lb+dXFvlAUF8NTuEBRFl/p3eec8F0fbahtHRDdVxFRbKU3/6RfavVND45E1EvjqiFj7bgyAC2GbmVOSTd3+5PPmrTTaiBA+w+fsDao4v+EuXoCEW3+1Am40Dd3XHTAs7M88YmyVWrxb8OcNyY58gBy8dziBMaJ7aqlzbIa131tLdU8dzeAVaHEq1jeojiAZru+tQdbhMnVC001+mIrg0GAdjOftMkchLzUU1ODASegS+uTdzIcXXO54OrGQt3ks09Da5r2H+NqBV67HhM6bezks5O8xe+NEE+MQnvvvSGrLfv38DP7mUqUehBpLgFRZLzUHBjAd4RxzxucKalXVIJMrfhEVPK0=" + "bytes": "2dCKfxMwtLYKoHGOWQffL7tjJ8bbRdU7a0x5374pwy5cjcGVt56PntkCqWbSJDh72nnN58BI2myQOfp18zbvAgkjLXGao99wr4qR8ihsuUpWO8sjMkvWm9IL/72y6fL3zE/JxnsQWBPmO9mJLk/LHy6Dur5atpjy0pxqGT4Ma/2k8Ov5otfOEuOF2UHFjol57tyLaRtIitIUdUsHg2TFa1C6dX4001xXUIKWiif+E61L574FpC0m25Epa2eE27qeFZlpB1Fq25Glk0Z3TH9own31WsXHThcxNFGtyu+b4eaPyvP0D8kC6k3bVd6+QDL7mB2f0SixhfZwZzyRUrXt+STc1GG9as/LQbOZDAdJQtW+8SNtC+G083XPn7wY8kNSoK4iarXOLYNpwWmam9yhW2leKQWPAyJR/A7c6587dCzKKu9tq2fRiGHi0HEiWKvzruAA5BExkieL4Wa0QUEnIOY89kOEtjOlDovbaIGcyFYZopRv6yKeRR9CEqn3GTtMaTH9pR6UPbRjl478JUktRe3RfWuiW0hnMCXk1rv+D5311g/3oNowA7CTGKRaevg/9ajPnJjGLVAkIjmv0jl9AnkwQ2TMc/cav4VW9BrHpmSCA8L+Z8IrC9Ik737+VSBdY1TRZXavnKdJslr1z6SWIEm2K05b8TMJi6lNbteazNcTbHzGkxDeJ2g5Gl4Z85fuO5nfL2I78JNjqMJjqJB1GqdFQTyo/cC7NQz3YHkrETMkFpZ/Ul6Npux6DbwK9HtD9XY+a+G1791+jBsSAc6Aly75uF2aFk44x5w/Qdh7WQ9iX4PJM6aFNH9M9Rt9a1K7teOE4zLp/90wapMru47CC+A8tjTYUFvcAcRGGfDCfqCArju4ZB6xwe0Nr3J+1F91ixdjVW3/f6KHX6nPUlWNSfrTIUZt5XGVDiGu5VVw+wiLyYwSREqnL/pzkwfTkPerxbIl02zI47Clo5sNaoxf+6M7mBwmIfQiIuQkAT0Cb8oKGhkYdXnOo/z9gktGvu4g0jg=" }, - "bafkr4ieds46knvozeny3uexqfhr6rg2orvvlhu5bvdsbdon3dy72fcolme": { - "value": { - "wnfs/priv/dir": { - "entries": { - "jazz": { - "contentCid": { - "/": "bafkr4iet6tkcbjesymahvv7p65qkrh3hd5yfftaidfresulzmes32btkqi" - }, - "label": { - "/": { - "bytes": "CU27qct4Yn3oVYDQIL6XoGDw1yxRcjbGpXeICSW4X2w" - } - }, - "snapshotKey": { - "/": { - "bytes": "sRFISMmAn36+mP7DKw3l+UlgWk6PtR/TRA2bpMf7i20" - } - }, - "temporalKey": { - "/": { - "bytes": "8XKv3Kzu9OlMdVLH55opsyvo0ZBIPQtWVwDcp90Miki+48PpXoeFqQ" - } - } - } - }, - "headerCid": { - "/": "bafkr4igjmm53wzadt5zcedrl4j2xiwzmd5shi4iczwqfk2tuoj5xu6paym" - }, - "metadata": { - "created": 0, - "modified": 0 - }, - "previous": [], - "version": "1.0.0" - } - }, - "bytes": "rKZokOHhLOcKvVUCeWXl+3v2h6SE2zLlexLHf69uLKqmmAHi7AM9RMC3dPlphOc2TrvT1jFOaGT/qfn8K7wcWPhWusEY7wTfzTIQ9UacCDhO2ohnhkK5GhPfgnf5EUnNMuapFu7UlAI8lgjf1Ypy0b8KWeVwjHz0NVpQ3tZbBVWlct06phT8fw1T2ROBHiEKbZev8Qme6zsr1tQDHYXv+i4/SEI92uRPf37MAP5uc8Ev7aXomDmDMgzh+wemHHQO+pMYX78qbZWL20otuR1JwmZCyD/eFALK4HYAE6Kuh6L5KmRH8S+NC2UnpfGlHjLfxUE9ySMyhmLjsJZ+4sm/klLj3+koJp70kqvM9cCYoD5egYaq1EZW+4hOsAZLciIVeIz0N5Cd1zATc7Q+KT0SibecZQE5x+q7Z2EXBt6XTa+rpwbT6KzXMj4o2gEvky9M+JMwTZ42JmXhJf0y2kwasztDSfDk/wHa+OCrX/JIzw==" - }, - "bafkr4iejjjkfbpeflivh436mut6254p7gujytubff65e2kpgqgenvqizh4": { - "value": { - "/": { - "bytes": "SGVsbG8gV29ybGQ" - } - }, - "bytes": "rXpvVcxD9beDA/T/qtOLeX8I7Ie6GXArKOgMjHtOv43tOPmkx1bjBc4KCwXFB2gbq6sK" - }, - "bafkr4iet6tkcbjesymahvv7p65qkrh3hd5yfftaidfresulzmes32btkqi": { + { + "cid": "bafkr4ibhraqq4prlc4zsuddrlwebj2l3emgxehgdcuvppohr6y2ruoozx4", "value": { "wnfs/priv/file": { "content": { "external": { "baseName": { "/": { - "bytes": "XlJObiItJl7E8FVvluJCf2IRdsy4H3Zpn4HqgeMY1GL1AAUqADp6HkOHhYMhqHM7QqKHuy37sswLMewKyA/0cSpNtKFmfztmDImOkpmFZsFYWGtbIdYbRe4C5W/laX7ot7HVS2UQU7/J6r/zqQY8BuoUUZqQ521NdnkjC7bR4wm9Dt6w9axaO3apr7xs9BjdMstUjhxHkzBRl97T2XZL1PQc02Zgs9ThJKs4S2hkosMfco9gc3rcXfegScwo2wU3v0iDIG/kpWxNuC6DJaRnpURNU1PcWDEKwgYWY5YCrgcibINGRbR2aOB7UtpvzXcC/3dH0YhOklW/naLL+SyYHg" + "bytes": "D+6NErtDJP4zX8CQ0KoqP7qY7d+8Qgt76lHJ71OR5gmsccdJZuoezWWA/sROlHDdVM8w1DFXnZDfvSJOMOZm/JOW/aLK66U1Eem36fMWFvQZ1vQdIONmblKs5iWNrzXRRmsIZ0JEgd6s27XlDhYmBp728DLQMlvtcNIw8yZaJYlJMyw6CI0W+XVNqG0e6rmeKsLg8P+jERy04BqymagMIRUzKvP/OJ89UT9e1rZ5kj3WNlPCQ9tJBCvtVokfC7ZP3bNwwWMfilhj/ZMO/6ClzbIPy54JGnf0t55goIQwna4a9sONJnwnf5YRkBBv3kfqxhnHXFI8vjYvAicKrbNA8w" } }, "blockContentSize": 262104, "blockCount": 1, "key": { "/": { - "bytes": "HY11mdYMnUK6/+Ovq9+rZuNFJ6YZhAin0KZFqMaIRwA" + "bytes": "ZKCSuHlM49WxT+92lwlfNPM+XxOoFM2AjU5e4dCLQ6M" } } } }, "headerCid": { - "/": "bafkr4ifutwdq3umnvxedkcatmt2jkmuelhha5r4p2weemjt7husmk3cbg4" + "/": "bafkr4ibpva2zlmfnlujo3znj2wox3bvysnhhhykiwd4xeksazyivwihria" }, "metadata": { "created": 0, @@ -251,229 +418,262 @@ expression: values "version": "1.0.0" } }, - "bytes": "JBRWcLMTiXgVO/n7HAGwjlTJZ++zjqbcuWTEo5z1UpGxTer+m7MTTwLEL+4CEpL2B05rSUXqwmwHMg4E6L9E00pGRj6CrOVejhz5lqq3OEPG6GDFCJthi9xhHBfmOvhLB6mW/r8yXYBVeQqMBygoVaPZh1qX4jlfzPfBJJygcWQhi1BZ5bSCZaWD9m3KkmWGarrw3+X2CLQegIG3s9rdipPNiyPBwCRKucMokWlUDUUr1R62FJ7hvOZdReb7flrxV7G7ucufrxTq5Ty3P5sdLLxcyk4JJxgUtTs0WRgbHSJRCSUp2hSEgsDaTfaz6zNlDV+VZ5kP+F0MCBJH6wW74ixykswHFbHy4nnFNV2XHTkUlsP2l6HLjhiIaTlQUj3I8n261aJOdZS+X6gK8sBWp3Xud81Z/+ytkj5yKO+b976Ff+7raLrENFwzmuaMTF9O2PfWDl1xjgFSg42s/cU/pTOaK/o+SruhBhJV0qJzbWpPMz3RdiXOYjiutIIopOzBy1OD92o+mZX3TrmhP1SEwltTIewbjfbL/XkzNNUfxAAIakutLYqPue8jTiQbjo2Qc1LmlT74H855UAZ8GjMcizGMpTGRFNJ9kK1iIBJrIAG9OwSqc72t7+vHHKIw3QFLPGUgMgHby4BqwS8znfc+FTOltJjwBk1vFXJqoHzD7/pMRPgGIRkoQA==" + "bytes": "+IU4xTGhOAuWwYvbYU3qdgyjhSyIOYpWtVNE1j5IG0GoQ+52FKMYJeScXXH9fpG4WJWhGsZxChQ/icSVclEYRqlcy7Pw7YDB1QSEC156epy9JMm4iATGfi7bU+XCJppUx1CtCk0yu9nKmsTvgJpha6jbN65VpDSSt3GxJouzF19dRtQrmyqBrvepZ5Dp7Il2tOAGyWoe8IaUyxMLTdQYFcuP1r8NvEx4Wkg+TWwRAnyYSWbH9KL0ALhHp0bmDof7htt9PxyofoaV0lC/6xXC/nk5NQ/sML43BQto59hlRudMqQ/s9ydFuQ4R/lGbt4CAvSTrFZ+T4ZT6wXutTEM4XH+MLo/luiq7Pzvhw01SAQ4iDHimvDNM59F0jq8wByJAB16vj+xbk+C8+dr/xpgJXUCTdlIOFBMsvOTvE4YCsJV2xv8asmVTKjHMDPGNBKISw3qQbrZl1L/JjRdbSGLVDFbrqVSub7nGTiP2BDQbHoyyfC6VQ3fnEq4yi/BA4BR+2ImW8onbKB60ovK0rOi0v3B+RF2TcOTYescWtKZmX74//LAZLrsc/7P+sRjcdCK4s3CqXFQya6OUvmk/HdpjiT9iNDOYBHojFfEyEdl0eHm2eCQ+BW/OAxLjeLr7X7Wb93upW0mp3f4B57v5iIbkBsSJsOk6Dj07cde4fPr9U6ymbtlqZaNljA==" }, - "bafkr4ifutwdq3umnvxedkcatmt2jkmuelhha5r4p2weemjt7husmk3cbg4": { + { + "cid": "bafkr4ibpva2zlmfnlujo3znj2wox3bvysnhhhykiwd4xeksazyivwihria", "value": { "inumber": { "/": { - "bytes": "7LI5vb6fJKDlptKRQqtS/K7s1D5fX1pQnlh5e8fKb5E" + "bytes": "Np+etw7KoG7usE5PLJYorG9z/qvF2LRtF1leOfDA3ls" } }, "name": { "/": { - "bytes": "bd0HYCevh6Mraxhx0Q5qUgIA0U+ule20QG9IYQWZAyIT+k4pOaHFxnwRWjMmcak9ssy/lpEeJFsneOas2qnmPyMo5YNIUG6lh64h5VJxi0bOQh6mozelVCIC7VFYCdwWr81pFj3BGGv6nIEIDvIx1ERMQ/S2rgK2l/gY+kfWIFbQaciwWdFpWy0XxHzuY++JkkS4wVaY7hqftDuPLj0bPq7klvNe4iblR6vHfvt59nUJ/TuhAJvQRyEouPD7EljS+mw3FxFPTDsmbspKOAVEg/M1W6LKFuH1dMnJaILW7pHM9v6LBRoOtstJq/2Mcv41rfYA4LCTZO1eIgQwbtVvVQ" + "bytes": "Ha6m9Qtvybi13t8xS6jCJVd8/4vIgb18hy+u3tewR1dSYw/YijfJhTE9SpO9WZWeMejVpHwVqNg37ieT5DogFfBBOo4eBlOaLUE1pUOZCvDHrXz5LXbw62decS+2XKNJMrF8k6T9nK05prowsfrIAOnGrvew2xCmmLoSiCVOrLghXPMNlvqMm8unic9k23fAg/vE4AEfKXGhCNy5zbeqK8vV5wOo0JBHPrWgNyP4IdR76IeiYa6Yrkxs3cPtDqY387JuyUsX8fyWdap4JXTP2ldNsr3X4G66mce1h6vkrVO1jfPvCswFevkdFOcqnoGZJsHuY9I1q0LDP2z3UI4jXg" } }, "ratchet": { "large": { "/": { - "bytes": "+pC06oPe44aEfbeBDfnbmQtdUKXyODqTQdGOW7OU66Q" + "bytes": "Gsgh612kLZy5xCAXrHmAIbVkuVTAaSKQAs061PVJ1Ag" } }, "medium": { "/": { - "bytes": "5aJQtOkloCDd1yk0p13d+aNRqB9v1C6uXnaLwzmvZXU" + "bytes": "o9OePElGO1DER+MHy5oABkbDIblbg+jUVNW7REa2Kyo" } }, - "mediumCounter": 165, + "mediumCounter": 31, "salt": { "/": { - "bytes": "eyr4FS0kny3XDqCtPGFx5W/SH5XWrB0Q+Hklxfjexak" + "bytes": "zoSIa/gNcNGdLwpk591zPxnRl46bR2NVMovEgpAY8KE" } }, "small": { "/": { - "bytes": "ZnyX4M59Vpc3UK3OSeeMIoDydkjYC15BQ/zW5Km1di4" + "bytes": "A0L13AljldlXoBzDH6BVWBvbhZOQgPq8B0+xY00cMjk" } }, - "smallCounter": 123 + "smallCounter": 149 } }, - "bytes": "QNXJEzJ3F5yR5CCyPAlA6proSrphpkXTMek20X83C6oJCAo4wrtaWE+eMIQ/g9o867Xxg9HL9L6AB+UAch4d71ZagCj9b+vJN+UrrfNkgEHaS6pyrNPIUVyqslwMJE8PRhhnOwsMqZeGhF4wsWN25vXw7pFZLqceG82d3wWkvxAHzZv7msGXMZE2GLT9To83lsL25M7TXVJD/q624/xgbAu7Tj7v6JkBeo1fF8fSy4Vk3BZcE7Bw2ZrjpR6H8Ix2R13PULH7c48QY0LadymZQicrglUQvZs/Y3PGwGazhM3yVOVrai0GOTDD6X1cuJRvCBNk/f2Bnc+2QuudKcz2M+S7hDyzXUP934wqDeIWzG35lhdtTzqML7/W4/VPPDVFzZHN/8E+dR5IVNlYoNsToWy/8n4YfcWPuHJqhpIxmVNla6/96WZ96fqXZ5qlVNSOEHTbBYY+NmgwtdsnpaXDpNJflkLDAi+96H58WyPuQuJ4Oovvb3/ynZYnEGUb3QJxdYI96o6JtSLM7+LGjQ1tbOMGRbSoV07BnbGwO2vlP316t9y5/VMuFg7oyg3cTk/6D0uJCGRG+IaCBWU/uEvnt6pdqKdHCJg7WzAGFi81o0iSqQpq+YbDDaaFmPaDiQiIFvOYm83L6SzLTQZaoQTc+I3wg41WLJuNsk2I62zVw1UaOOvzmpEX3g==" + "bytes": "ZdknKoTdr+MZPqhDm9EjVBqUYIYexwzykz6Eqs9W9dIY8hYv3spCQfo6XThgRAaWjOg3otQku5FWcSsMg78767CVaA9ida0NUhOdU+ITZ+20j0Qq964LDT0t4QBeST1SzH3nG2Av6qOWMD4jVaD9d8Qv3bN5W8YoECjltXGen+ZE38HtPJWW+QlGVQedj0LEcDsAw8zXpgjOI+74m7EAYdOdwC2W1cJStcjv0VVunMA9m4ScOJc3Wr9TtorZP0s0P7SlwXStI13MDayiMiMciEWnO0HWCyPkA1Ol9LQPfqfFZhnrzVMhd93xBxj8070wpjWzilvWCDc4DvQscMRwgceYyG6EJ9lxepej8G4pXnO6kJsH8lIldbIhPYeqzQ5FRBHhzx4W3z7GaeRSpb6EgAhi9NmOLEgB6XOTQb46MYIO0Rt1pXJ9LxD/oOdN8yOLYvWPirnuSBh+/smWwkV2WjjstdgCjFzKRJ8VSrThv2cyBPaZWehc2lZzz1DljUUka/4bbeydWtliTInLKF33ZgEcugBZrXzmnzGrR4Qw1BFqie8MMC2BUNMwHoQOlc/AJ+HKoy9vUNxZevOHUMSsGqsh/4+UHIXcPyMfKicJvrc+SzZHG98T/iR3LSlH6UurWn4hlbJg+6sgI0KQKQx9SisBNkUvndfwZfg4d12QhcZmxNT34POoVg==" }, - "bafkr4ig7tinqye3xoya3xvhk7loti67g7fy6jzmlstkjhvk55jmelzml3q": { - "value": { - "wnfs/priv/dir": { - "entries": { - "anime": { - "contentCid": { - "/": "bafkr4ihdaiqkdywzh6uk3m5ey73m27utfmwkx5fbhnjqahw6ws6xc4nzwq" - }, - "label": { - "/": { - "bytes": "G53zVA78ZDufB35+WhsHz4trY1C05sCR57zTkGgVlNU" - } - }, - "snapshotKey": { - "/": { - "bytes": "pGBh5TssmnLpKqtAmK1WhG8HxffP2Wwpe56yafosg5s" - } - }, - "temporalKey": { - "/": { - "bytes": "RmT4PA8pNQz93PXzHmVdeWChh2Ys4r4xnlhpvBHX8sZK4sT9RL8q0g" - } - } - } - }, - "headerCid": { - "/": "bafkr4ihyqn24ajhlatyprnuvlwzm2rc6mifvspd5ky7kzzkb5x5vz2km2u" - }, - "metadata": { - "created": 0, - "modified": 0 - }, - "previous": [], - "version": "1.0.0" - } - }, - "bytes": "jCZd/ulsiIetp68MkeBovSD3o1Dn3CFjnm71LYSiVrDLGGU/a5knP3UmVWtPXyOkBouD1EhIlxlEE9LpWkT3EejGQZxcdz3XpcZ1tE3yRgOBIjV/xWvByWSCRztI15AU/B9HtJkASLdy/mawfVQkW8Dgbijmvb4/8sQj9VRatAWbPmiw84z2rN/OMp+BhIgvXxc0XzaX6HnBee4DwtMY9B1HpWYMoCkYFqmxeqUPMGe3YYt35FDrNnLaliISVdaUqU9YG5j+QQ+ypFJvWgzGPMi5KUuk+/E7xUHUgVegGlmp7iNBPDs/9AJwmLauFhZqq/KHt3IEFJShz8CB9lC3HX4bd4QerhXOe+a47DIq5bSKoOoLJUtRum9cXr1QtaZnKj80iAHlJUM6erR9qFElVv0v9HGobDfuW98wGfqQ2CTxv3EJImkGItaAYnCMBEPQg5IBK/Oj0TxdJahZO9KIqWgKbavtJSwIiJmm8Erkvjo=" - }, - "bafkr4igc3l4da4vqhyjmr27pys4iw743v3cii5ovwitxmdqmqnincr7ujy": { + { + "cid": "bafkr4icyunetfy6kvn4wrplm7mruibripujkyjjbso4yoixcvoi53qfboy", "value": { "inumber": { "/": { - "bytes": "3Z7G3JebhuU5yeJZkofUBTlfs2Zs7sV+m/PkFnUmaqM" + "bytes": "27rTEmtE0nyKwyJ0LUnbDxvnpRHreQvkG4mrh6ed1NU" } }, "name": { "/": { - "bytes": "ayUufv6djgi/dODTvVwJ2IaXn7af/mK0nGskm3IT1bK0tQ2QBlocw1SBb36DPlSx6q66jJ1OoQhSuaSGRiGJ9JF4CFECtBAbzpP0+IsgjeePZbBpi75FNiOLdVP5QjcXLLj1FQ9LfWJs47ULBQlG3mDXR039e8KZM1Jp+K9UI5I0UUNNN/vZr0ogtuEIulPHShkBZNZ33g3WOBZwPo/aMAVyWcqHZAsOFbYSdJmprp61Yh1GuzH+EQsLn69Cgj+nczsxoFttojrbrk0oj7ZEbQfNjR9+yKRv5knLtKtOQrwmYMaXWkABGZfJWzyjwdJYnnuScTwgG6xnhEaO4kJQSA" + "bytes": "tUCUwv43o9ajn84gq0Gkow6PtTAIDe+uuViNVctIs4XNTnM6fi3Hk+X9eNJnIr5o7lvZr9Gf0DiENsQ/p4Vm9rtLP3KS2Hw1EBs/lLgqazbbK4At5GGgBhUL+NSvKJ1r2pX7urxx4iQy1Ag8i1zII143TuzFBe5nuN8jMLGMbLzAEuDwUTRL9bOCFdjJHvzbslyvMj6S60qqoNzxO+fgbvj0bRWaPaZvKCvdj/gTlaIcVOJ+jzR3ULoofORvPvcnGaC6XDqVL6wIShN/f7QgFRi05r0FcmIEP3ekAuA76KtA+ubULRMQg+JUMIi8srkckPaYlo3a+KvQ5TWroIXwdQ" } }, "ratchet": { "large": { "/": { - "bytes": "YaC+JBrbi/0ijSebZNkA9xlgjdq9f7ycFPE5/78HmO8" + "bytes": "GJqV9EMwaCbW8We2glA8bmgKkW5fv/bad0Ur8b+fvkI" } }, "medium": { "/": { - "bytes": "v8M5ThznEBqsrvylEFG1AmyxTgjdYLS/20+SFA0HHTk" + "bytes": "ZK2XGLHMoU5tLdTlXGYR9T+/nCf6h8iLKoJORu9qC/Y" } }, - "mediumCounter": 28, + "mediumCounter": 225, "salt": { "/": { - "bytes": "NO8dg+rac2jR64nn/36lclXxGlyXlvONt0TTdf7Wv10" + "bytes": "YuR9jMoolPnCxP1IUZDVuuXjvducRLiIJHWGwoB9VAw" } }, "small": { "/": { - "bytes": "Sp+YoS3lup4NgJbxkdgnptpbs8o78HqX6vqqoteFrLM" + "bytes": "CTVUMi4+gZVMOAECcB2vCDYflrCxctMqOcFuKpV7j7A" + } + }, + "smallCounter": 233 + } + }, + "bytes": "Qh/sW1x1Kho9Z1zVqz2MgQCC/nE4rvvbJEcrq2SkhsO3Jr5JB5B9bKRyUA44gDSvtvKff3eCMTQh4/CTcC5twPDcuPkPf4gh1u1SsE8Cqyy8aiGczewq92N/1SjRpxHj1iTicUa+3rjipR788bCNIt0eYZ7Mestmr71rUVZ7n94ezyj+WTLCg0PX6sPpIj2ox+HemhKwzbZW7izfRwqIFsOXKx5C27Ge4aLFs9JH+8baszOS185y6n+wuWBnOPOEjHgdkxEaBU/egUzAkMnaXs5OLpg9n980K0oN8Ysp+enPoXebD7Ws7BgIcxygVWyqPDWB30rDJE99siHIHguoF50Br96l7f6gleFeQdvf1Qi/Q+Yprbzpu3TLn9jpNzwuQ++xqg+L4zbsWjao3Hyj50h9RW36HcXIrJPpMj5KfHDTeUukaGrX70igwWuq+GiwA7814DEXReRNkNrbI2CWIONJVi1Pl2Axs7NhL+eUvs3e74zuJwn7Dx8COizC4sLw/QzKRyfOTvM9gq93V/W9dgiLMKZKlm9eTSaT2seFK8DJImEjqyXYN7o/zRz4iP48hC/9QaFQX0xAVG17PtIZIVUphQMvvhw+uEl/dI+T4AgwT4zFF4TMPIqBrflWSF/ZSnXu1mAsOsYyRDBw19ccPn+Wqoo73xoEVozbKRQiMS+lvhb8K66B+g==" + }, + { + "cid": "bafkr4idfb6czevqvtq4r5m5trlchtxo35gmhm3tzqiyhzldtn4aaey2vpe", + "value": { + "wnfs/priv/file": { + "content": { + "external": { + "baseName": { + "/": { + "bytes": "dVymeXd4adLmab4jsI0csAM5VOUW+87ceK/LaaPGseoozJqUDT9ZtPEFTxMRJPRMdOonmdcC09jM+0NyGhCCWftzsNrbvQz+iLLBpfFETG5JHTNH9Mn0lHMdKFhs5b0P0s2Y/jhljSepRgQ0XQAC76MNllO7xSjoQx5TW8X+ppkqNsAW6YljncWafmAvrytjEFw3AWZfLhUjCWCcxcpPxa0yrUcMbu7gIYKr1IHF+7oMxFSpsfdeAKTr+1FhNeClA3fnzrWcHPIbbYT74SaSXq/N1XNIk4BEu+aUEjDkTcZeY+VTen9/OSCrWLYzcaJgqGBTijls+I2gA3vik0EE2A" + } + }, + "blockContentSize": 262104, + "blockCount": 1, + "key": { + "/": { + "bytes": "jVcwDN/TdjHv5AfNidTSi4YTVNCx+2xZGF9Z1+pTi88" + } + } } }, - "smallCounter": 9 + "headerCid": { + "/": "bafkr4icyunetfy6kvn4wrplm7mruibripujkyjjbso4yoixcvoi53qfboy" + }, + "metadata": { + "created": 0, + "modified": 0 + }, + "previous": [], + "version": "1.0.0" } }, - "bytes": "V2+csz7KVJCwphgG2/Qd1z+kanWLJvF7ke8qsFIHqwD8/elLwgTGzDtp2ZQXwXLOjfQMoU+iZrQRA4X5SrRzmFEXIhEE+cSOqR34tROjh82eCYJN3q7JIEyQU7GdbB9FwDtwb2HnZEOVTmq60nEjl8zWuYwQXlBbnDUK/jVjtkVo5F8AEHpqJx+bbRNWxpK1E/sIzldycp4mvD1Kk5sTIz28xB3zNFj0DmNGzmLn7il/7+GPlJ6DA9DS94kKSNQPjjQWqcb82B3R3vAVih/D6erXE97v3LGQOlSJvJq47PrJsrsezsXIyw10ncJzZePFg/UxgKzYr0RCvQmuRszG+G9ijF2yIr8+/mplRmfiGaViJ4IpSJtZjFnnKkFzhoxsniRJZpdxywfWWw1Y4cPcImcEbdBUt7XhmVeoZv09Ydi7Jy2FAUwiHhIFx2vwwP2EMHn/It3FmgwT6hOq/AQLJlnQu1cIafZqB2TFZa65ucjLHiXg/vX8X2vjQ9mFPokaGnbFIoJrkwV9cjn0v/8rkDG3mxnQ63FDgyhjXm2pHQkX/JhQ/EYnv5GG05jWznuPkQDwbIW+KhVuwNOovxm2UsbkNkyaIT7C2c+GaSR+5wgQbWkV45ERnhT8ZEK4QrBbbKsFSJH4RU4kCBngPn9q6DtFmJFqUy8wzL7qK++eGqUmI0t+e35EIw==" + "bytes": "KNb/g8e03KQjyeUy9xeoZpgabhtQAkR7xRrY6QLQXuspUPs5yZ8aGFQ6m6z+ZCzEsIeDxnjojh7460X7McSYYxQo7sawTELaROAt6C42xtgeEn9G19QDkgvPDfCXXsrKCN/veTcNrWdqpAKeJbIAmpxAqI2b3WGBF3b00khLTQd8Q9KRpbtlMXeAP8bW2gRl4tR8w7DBU0q12S7g7FSvZQ77t+JwNPXwa8P9vr1Fpped+CzHU0dn23p8sk+Ex65nT2frBFrYv/+ZVyydi6l8SK0WzXoXutRSfm37uzpu77zyGbgxhXF8/G+8G1z/+COO9cMMws/S/ia6x9H9xTNAnAgLgEKB7yO2z0FMR5JCvePe6mCc/5HnKbf/NZJgo+1bj4Vcfzio1eb7dnqEvybGvoe20lzKAM/je+M1floVZOsqrJ3QWTzMprSKx9P7IjnUrlgZFBTnIlKa/OiGTDDUA+LB88suredrkYAlvinxyM+MDGsFb8O8QrL1uSE3COXeQoMXwA7+Gj/gC/qKiD1G5eOBymg4lZUVJorgUI1XyMd9XgVjpIkJ77z1AxZlH3hTzltM27zbRAqvWOyejaV0CAlUZvzUjpm4qv6gutJPRvFEs28NqeohAaMnFlcXPQSJjXozo71EsGHh8pmDqrHKgdpJVWH4lWe/BmQ1s0tR/us/iw82FPuk0Q==" }, - "bafkr4ige3uogilhvhm4ofo47g77o23h66wsmahzvp4wg4skdxorlej3caq": { + { + "cid": "bafkr4ia5xkxzhnkaxwvtfvz2ot4m4pf3aapvusg57ixrnubf2g2pe5vsdq", "value": { "inumber": { "/": { - "bytes": "ypaJGIrS8i9y82KczwXG0wtvpesf98lrTfEkPJFh9JM" + "bytes": "8oaNxyAwPOMftKOeX6vYTKpwmJ7RnyhOvzlheOziGUE" } }, "name": { "/": { - "bytes": "thu93ziRXeiShpo34RV3DucMrwZcIjPrXbUKTmD7lBPrqkwUjvO1bM2FPyNq0Hejp+c7xXpaUVyuIFtdJ6uoJu12ucIpkMXEtyxAIDcJWxnMK5BQyGL1k+T5ED+S5F8CYnSnLsFivkfwif7z7jS87zbDaOqM7o1wO60fAYJDDV0br70mi3jz/U0gwyL7ENo0tTdOyx/7kkmMuxEhdXfAXrnKeUWJjqlOFym+koeKkBSYWaqqlwcW+fEUhvuN8BOOkV2rw0Cv6yneZAHMhCXjeVhB4bEq+TeUzjDKHGI52cITqgi0EIoly4ry4FP16fRKxPp3MA+SHNmXm5cvl48H7A" + "bytes": "spIDAZGJKcmGiQzqOkSlfevPRmOkND7dmfxoKGSZn+L2U72swQgZWyqEGYFoBHkAOVfREN5puBpD39wif7cle1/NA6VmsEKTVVM2kOs9wWUj1ltUOjJdem6cIHGHKuuBfyT4cKkMeSlLIjO4G8plynMsnk2Wl06HATb9Z0OrarINH9Qja4dZ8LPIP7TqpKOjhmY4Uzh8VHb2/4J7LBKrTvu4uQAgZCEDixnZ0DlSCUtqEtVM7pz2E3esfx2EJtA8Jxu/wVwt1ca82sEpkZYKIqV8qxK1Mt6B7Zm91fjm4MhtN6UkHBNZyn0IflhZphLmbIxlfcViPHEQSBq8+Z1pXg" } }, "ratchet": { "large": { "/": { - "bytes": "qORVSKgvnZ0QKrnDS+icXs0/CehJuHXOiAM0c24yGZo" + "bytes": "b7PHfJFquImGboCHvDVUIuasqPla7vum7OVpZjvwltQ" } }, "medium": { "/": { - "bytes": "HkeMDQSmvMWFtXcJgg2+ybJmMKeQqCPRBOgCP/w8c54" + "bytes": "7+aipcV8QxNDi5CI5u3xNERS/26h7l94ZtxVji53mNQ" } }, - "mediumCounter": 204, + "mediumCounter": 213, "salt": { "/": { - "bytes": "Eyss3p6SPJzhIHH68fqEu3kNQQC6JHe+YHlpB9NH0wM" + "bytes": "MlXknXWqPUtUIQ70Pc20OmddXfgd2u4lHRFt7GuDGRo" } }, "small": { "/": { - "bytes": "re72wkaCmnH6qXpCXL2O7cAJiii/JusVg4z5Y8cgdQA" + "bytes": "Bu9qjHcXjCr6W69E2B64PVPhOEfEmvGXYd8+LbJa1aY" + } + }, + "smallCounter": 116 + } + }, + "bytes": "SP0a5PQ6pa9IfNhACq2KTEJxNTFxcBoQlwrescKL8inIic6kGQFh2JOZYHezK8rWGcYey2Hlc+7QdRma1FzOQjxDylzDHJnRb9Qzb0UC5K2PXHGi9+a4cNRdedjiJ44IliMe/egLKAV2Sj5VTy7NltGdmIhf3A7mBKJxW1rswvsvF2fT2COKzoqYTpXhq0aEG481oJEcYWI+UK+9HLrFdTO1LKAjLLZ8/+gwASEBnMJl9Km+x6yX2CNI9HA1VieXGFmdCUwB8aBLQRGCDhcU+fKbvG9rP6sUP4s1VNZ+1zd6kTfgcl3LR+CFv3ZuWQ1AC6f5nB0YnwcCy+txXB8aaPZrF/pOOe/VZmyRHQhBkaCCHIsD2BfdKAX2DlyWYyRoZ9X3zuCs96ggJeSKVeT29+1/46YY/P9PzQ8TXpTMiSl1+mMgnQFKgzGY2TeaRFaKARp9JI2jPGD/xvbP9kp2NZ36p6fhILKG6K3M5K0HL79mHY1WvlF7Q5ljX410fKi1YWO2qW8pmPszcQ0tyyFlsp0JLF97HCrOMV4lWcdSkAHefX0Etk32+CQqJhomb8XWKfdIpYfrFVoHVRq3+lPTiKN0+sCHh3Xm6JZ9EllfmSLxJl8QbWqJr0D03xfC4uVfwpqP00dJ7TrM3KQ7J+fingMRYJ0Rv5RG7TVNzL2Iw6gy3Zwd92NwuA==" + }, + { + "cid": "bafkr4iev75qq7mmrndgf5rtrwfbp7h3acwrs6ws322micp6lqmatzuv6iq", + "value": { + "wnfs/priv/file": { + "content": { + "external": { + "baseName": { + "/": { + "bytes": "qQgCU/1D0NPNpIAhSuG1+XTOKJiuQ9DKZTjVlJbJvMFV1l3esP1n9BClQCOf0YiKDwMQQ/jCxwhZwETlXpSbnFzZksgDBgNqzpYoGsDGBvjQGa+L1yWBbW7+ASlMTLajbJSzuLx7I8wp5KKNuLsqaeCv+XqhBWnNbG8Td16nuNX/hkYQ551hAGpl54drXgEFypcQvcwdV4oZSM08+VcPxqPio3uHRLi+Gw+mF0vs9UzdZFVPhaRjenRSYH7MvuenvWD8MISws8cxolYicaJkBoQEvP17qGCJq+lbSwE1vtyEI5NsAOWYQo6BcRC3e5UYXMEeLD8/gcrh3YtAa5PsyQ" + } + }, + "blockContentSize": 262104, + "blockCount": 1, + "key": { + "/": { + "bytes": "RTVvKoRFbRabxFk8iiPjWbiY2+UbTvYvEOuZ4hjFvoU" + } + } } }, - "smallCounter": 96 + "headerCid": { + "/": "bafkr4ia5xkxzhnkaxwvtfvz2ot4m4pf3aapvusg57ixrnubf2g2pe5vsdq" + }, + "metadata": { + "created": 0, + "modified": 0 + }, + "previous": [], + "version": "1.0.0" } }, - "bytes": "t29SYUDcNQLlRwQb5mpQHsuINtI2uso3IphjqHMmtMlImHg+FF3RIxsnSd7kxApqZL9CfoCN3MAg5TJOxDu+JJZFi7IEJzU7uqD3V+sPUJLCg4Lojwli0H7VTElpb5W8tiF6fuH+V58qNVdmaNlnEwfQOagOpgD1Xkax4NArgmox9nS1HmkNtcj8C5L1QcErfHgKcskMOCllDjAlogpDOyvUU6OgqajzTgJt/hhF6bkTSb3AF43Dp274aK0HurwXK6pCqotaBuXwwIA6SUwAKWj38v7e1HO3Py089LGSvz4/Ys9pdjmFyhv2seSICJ1j2JTMOZFgHX9EWMhWtfiUHkq2tWayS/hMfEEPdVp+HndVfYAEMoROLBo/n0pAV3lxeIjFKZB9j6/FoRH0P3NAlO7HIrjIRNKHYnkGcENsahyXXNkaDuUCAI+Ty4c0vTsbH0tGUGJ3GKXiRnCdVN1AVnlxR6bgLMPmK0QOpmua8j9bvQSUXytzOjKQ5iMtOrmO9QHuL4KgtyarpX1fVsF1gA0J9Vb8z+/yM0FPpDrWaQPQ6ZHAzV5oJiWMUCHyATIFy4xHeudR6Ycppau2Jvg48vPGZjrdkHR/7oAe0EK7HF/FSe1r96Cuba4rDzJKZQSbWvNZrxJIMlqsw9b4H50e9qit/5Ez0uPnGCa1QDwlxZuWKrR1/Cv3eQ==" + "bytes": "UxsjWntevfOu6Qzk1fNZJm6/iIpgysHyUiqc0wcGJrkynPLYAp44wsfTpC4XZIwCHiiY6JDGSWeDZtwmW09XXdMYmSygNH646nBix42s24841SgZyBNkKIMUwtGcED7KMrL8Bc13+0VMUvztfoR1LbzeZsX4mp5VgREP/yFPicpX68bVwmJmgaUepDzsRQM2UC+TNxklM3A9YH7kb6RDKHuhcM1yI+95s0UNgqm1iUmRRZGv+xWzdZQuvgGsCtbNbHirho40lfLbkXdHYQmFbFfoIOV8zTQ2YMOlVC4uDwZJGBKDOFdb4Qru5pnIk3+2VNKOmn+Kqj4MVyKIBE5TX3g38Cbgmc+57FSWPWACRZDYneNrOBIP1Wi1D/U1fO9DKabZJVbhMzM88M//vGmPqqQv33oJEwyw9b19x72XPXYw/QDtA6F61atljIhxifw9GxJM2KcBUDYKfm93JqWjrp0ONM59lGWoKzDyydK532kAnoYU7D+xUokGxhTlXu87YiuuYolo4RBnNJu17lc74mvzy15Hc7Qgzjz3XHKjD6uZHc/wuyWNF3lVc28BcFr5v9UUdNzAsnLGo02Hymx1HgFgMeXM+OzM+CR7CHtZb/i7TEhXxkNjoZw6m3IlfQBggXapL2I+ruBvn6Rz0aG6mtwMk6vDhWt94iUThyy3nUxCsvJBUrKyIg==" }, - "bafkr4igjmm53wzadt5zcedrl4j2xiwzmd5shi4iczwqfk2tuoj5xu6paym": { + { + "cid": "bafkr4if2ng6ts2xei6cca53d6tgq2igjioiirk7gm4bvciwhdddhqno77i", "value": { "inumber": { "/": { - "bytes": "4Rw8Wzk9Be77iAS6n5C9UOLatGrg4UmMm1ST3GT3oqs" + "bytes": "F56/XmzyfsCdLoUmc9ysldn7Aq1AG+TAuAScnONygQE" } }, "name": { "/": { - "bytes": "SkM4IhExInZkPcASX4xPUscgI/S+hwXKidMzNBvNR/9MzxbPLEhUKHHYcEHu+mUMu2Mve+SISnvIAgQ2XW0gYZMf02o4CYeXMCPD5wH0HXwXaTZz/wZUkR2uATkk4828x5b3HKIRJ9o9CgxGnCR45yHT+g+QdF8FiX4DrGmdSOLLP0xRUGvhQ70TDINPtM1PMUGwYTtiUCpo1M2rNaVY0+wda2wB3DTyFCJlj6D/WbvqZtCzJNQhJ6QagO+XIljujKg4puyRfLD8I40/7yXFlNoD+fbAClBttA6UKnJkQf5buc5Ghek/Xn1ctq4BuDuGy0G6Tul75GTbs4G1fyWhMg" + "bytes": "hJOiX+spJVS+B8BTf9AHnee8iNlFnZEaANNQeHtoucSOGgUoHkD+R4KQ45f9nOB96yiLFtNb1SqBFDenwt1kHozDfFSnfVoUMg59lbsuAzI8HwzRsoL37HDemdDaRWOYgGNEN6UUyMHTZUPN0XQvfYv8OmAvQMi3kj5xgcRmj9P/iDSm3ZT2SofpPE9YEMV9f161S6XeLcvDd2cu5Sxa2bOZEOWzNAzEFgUMgRH5ZoGrQsznv2O/0NTtcaFIcDl5+/t0huNdjen1a/SIBWkr5amN33cwXzSujvrXxy2bVUTguY/wSZOsrNnG2LBn/sblU7g4c/d+SzERp6LmzOEJ5w" } }, "ratchet": { "large": { "/": { - "bytes": "WHu5AC1kgPMHil7KNZNllEduLodbVzRKVclTlkwjrmA" + "bytes": "J9y/uUtzPtr2uMrizZhRSPKiYbj7mIZ5mhVGlY7QSUQ" } }, "medium": { "/": { - "bytes": "gdq1GlHQkbPXDVcaRV9xeRiO2k8pYY5yEfDE5wxaRYk" + "bytes": "N7+d0A5VZ5QcCMrARPPM7Lp6pwjRYolfbfSBPAuv4so" } }, - "mediumCounter": 74, + "mediumCounter": 227, "salt": { "/": { - "bytes": "x7rdS4zEr0dhMT/2YTABBjNp3pMuc21XGrULhUr2UYQ" + "bytes": "wJknDy/chixgR3PN4i/umUKgu9w/dBQkKPcc8bpPtwM" } }, "small": { "/": { - "bytes": "/MU0z9MqX/+KFJ+g1PTMSXAKuVoIpwd/lUbSk9FZUW8" + "bytes": "0yP5KKkIA3gskFH3ElX5nv3Z7iRD1GQSee7S4+xMSYg" } }, - "smallCounter": 164 + "smallCounter": 253 } }, - "bytes": "gaPUJ9X60+2qhw939JL0sDDU2QlTgnq7iz0YXZl8xNNBhIDfg3fJ0vdNY0GQJbw9yUQ597kSLWlDGnGyMSWWKEgR1TZhewEpe1PF+g5BDkKBQTEv6G/IbJhZN3FiL/Zp0PMX5yxhpN97ChnrmkvsE6x9ofdKJclOW2nm/y9oiOW2xHD+lJVMmjWQFQoSWQFGRBTrRTtDreKXV4OjfSgbSYKmiD5OQLWMudfFHBUtLrw6M8gVFKK0CvkYJ1+16KpQPgb+K+K2buTXo8LrrUB50BQxlVD0iCxuMkqfCtKDjtub4iyxZ7OAGTGDmdXpfqUxc2/C3zU2QaZIKn1EaT6K0IcdNh51ZARobERH8kJTZiLcO0Mw6w0HabfNjzqcUt5oZDgZL9gGkWCa87WD+nzKGaLINJwUHdgDR4ngW8UTh2I0tgDCvZf1Nt730JVPOyjYjbv4XLCgm36ngBeXPYIQ7+VHXgSsVKQpaspcz/219doBKImL1FYbeddOQiYhCMm2i3GwPGzyBPccTblKAsOdFrnd/Ps86wib6Sg3zOyXCcAKDX6yjfEZJNZN/USTphxm5PQUXcuqLIxEEEd5vJ31E4z2Klln+ooMDh4mnCI5H9Kx5+CjQN8NXBCeZfmo2zDQz4uGU0YCOZBw8zGMytGMdy1jvUQ8i2LTkbId8X5bxw/vZJRUR+5lkA==" + "bytes": "1qsr7kXq0aun7B5+QEwVoq6tIP8PItdhqcY/pKO6MERiWJcIgaE9ELzipX+OnI6rlyPElEiZGzbArxXgD1m5lzL0H3kFhPidxlQq/oQOUiGbrBYXlHSgJxYOdh4YLq0nWCzM43uB+QlTNUnTA5/efGmrd5cI7B4ER93MAC+ozIJL5C0EH2lXEoOP9RD45//RvjCDorpcnUKkv4ChDO0WaF0RtMvaSM3f8aOpFEIFugxM3YnfNrBwjn9iJeRnS3JFiHFYwjc51jE9t4XUrJvmn6/jH4EhEg4pKT3jNZD0Blvo6MkSVAbnRzHPLzMsG7yCMn8HM1+TfZGdrP/ILuN2r4/3/0wa/PuD0lShnNrQWXd1h+scqvJMdo5C+TB9AxBK8ts18AcF7ICGUbZE80YdNVgtSxmF7ZFc5E6qGt4+PDMsq4ULjjA2FeYI/GQAfp2rkdNiUK2JGANs4FQWYxwEhB4gJ5WU00L6kHqd4wU7K5A6Ol+bNx1FACTNW6lxlkUtbKp+gVnFGkq2okbMGht7NCIXaquPY7AMkgJv24fNsEuRax+6aE0CnJMBuiYI+yoCG/GHvr4ZeZUQ1q62bUKAB2gkYp9IsV5zqtKx2Fzzc1MgqAQm9a2P1ajPFVNqgZKKblHEzZqyd9PFsV4SjvWtAIjldj7Vyd4Pav3G940maa/DQsbnb4NEyQ==" }, - "bafkr4igkqdavo5ukmdawyydj4jsfmllux6azgj2yb72xars4ljmmwokg6u": { + { + "cid": "bafkr4ihhaet6xdsol6oabwqjopk5jpppfd7sshvtdrfhekryrvi6qspxdy", "value": { "wnfs/priv/dir": { "entries": { - "movies": { + "jazz": { "contentCid": { - "/": "bafkr4ig7tinqye3xoya3xvhk7loti67g7fy6jzmlstkjhvk55jmelzml3q" + "/": "bafkr4iev75qq7mmrndgf5rtrwfbp7h3acwrs6ws322micp6lqmatzuv6iq" }, "label": { "/": { - "bytes": "qWd894Z7QT4ujw0IWo7cLjO1pe+TqtPtJNR5fFBGRN8" + "bytes": "dQ5WMVfLlOwXDDZN7O0UPMOyDxztE80f9O8NLSe8Nd8" } }, "snapshotKey": { "/": { - "bytes": "qSPhgHBAaCREG4O9l195AmUsyYVE32tu5G5CVHJD+KY" + "bytes": "wgoQtwsOrB+0hooUC/hIbIqrhOi2E1V0f6edZTMzNSE" } }, "temporalKey": { "/": { - "bytes": "hjA4fGrsKrUx6IaNMaQ96dLYfesG/6GySY54RUk7bt5JC2SaMzq4QQ" + "bytes": "Z0lE6T/vSa4vXjn0BQe12aJGA3wkotPuNb0Yq7yx0TxhNatdy+iFxA" } } } }, "headerCid": { - "/": "bafkr4igc3l4da4vqhyjmr27pys4iw743v3cii5ovwitxmdqmqnincr7ujy" + "/": "bafkr4if2ng6ts2xei6cca53d6tgq2igjioiirk7gm4bvciwhdddhqno77i" }, "metadata": { "created": 0, @@ -483,290 +683,112 @@ expression: values "version": "1.0.0" } }, - "bytes": "f7Z6Q+0RfkBPBWsJz+Gs3268UR0ooT5pmFFp4RID/f0rCWwlyfBp3zdQtrPfSiqQVSFJyIS2nnhHJXjhEDCUs4fr457aq5k89B8WtAqKmYH6erDF1wsUjhOIQqlRFVXAWYnr+m/plLQeGLm1Zihqlh9JDWH0RgQkFqR0bOePGIcWgi6QDF4JgJdNUI3XCCsb9mYGe+4IcLxRCPcuug/ZOHDxwi+3J8ynbL7nan0PJ1dBl1aAUo/n1gfwSMoKgA/a3JNvIwF0PW5aIjIcaGMMqp8F2MEzgcR8VWa22Y55XoJ6exBo0AYCxxcZK56ga3Jjr3Kk0//5DudSVh8ylAdgMx+6XZz6/qkj1QLC0bDp09fBOhfAfulU1X9JKFqaN2i0A7BdE5o7Kw4BnD+1s9TPclIhbL8IkHIrc5La+y40LG6uWQLOIoqIT0t+ndUYWnWF6GBWrHfnaOk/y9pekCu7CTjLS16jm2+WZjnszEaf1YyY" + "bytes": "L4pYG5OW5YyMbIdJgNTG207RdlwnC6q86F59KgR/7lfiinXMhTN+Ha0oFYEFrO54s3SILC33VEgft5uC/naB327csQxqlGMc7OtJrs6tFymdqlOjfjgpC9HvA2Azl6RYy1YwGyV/8UjFM2FLdPfrdqQLh1Yng+o66D2c9Q9mQnSHCN+jnrACKykrYu2WNK0KhAyYP1dub5K/8HxVWcZcXypB5sdaPNhuR76ByLwA+ShKiklAX3+p6Op5jANlztHO0FO63AOYTcb0d0boWaytKDl3kJcRhg7gjxSAiPruP294D+8g6C2kBWWhpp2o8BSAPSrQ6f1i0uzsNJJSQ4G1V8k06J1efzCJDq5b5ZYtYXBMVcceZ+HQuGOEvG6kewkfWx2/uDnv2W3FMiCg6R731Q95YjGmITOYA13yrffxWnhQEWNji7zTRoUdTbVEEr2sAm+cwN9YrRabIiQo4EzvJG54Uo6Fd+8EbQKcN/OD/Q==" }, - "bafkr4igoes2nc5ibp3kcq5qerw7lvdwx47v4eiycn37kkqr3qngepjbn2u": { - "value": { - "wnfs/priv/file": { - "content": { - "external": { - "baseName": { - "/": { - "bytes": "OWJDv/FN6RSs6Wv1rsBVXJjI+DvZD4aLnXdM+9Cohv1wHVUWPK3cETrbjiB48N0i517YUKpyf2GEKUWSeENRYVj4Q3AejzeDIKuJF7d+YdSuqs+ShLUv6yXaPAFBpmj/k9hH9qe4pI3AfuvTiCwqxTiz0PseK0SV8gtoBRRQq8lHFBZkmHjcwydKnav8grvt8qcu4xKS78Ug2K/KS6khGupGAhiDO2xnMIhz2coM+rOfn1qyXwcdxeRtdanVn5HYnFZsx72fx/mALYWcE++XgOml+25nKnUlLGuVeaBKODcied3y6uOsy3UvfLxWqo9e1l93sSmuINFGCTwHUV+v2w" - } - }, - "blockContentSize": 262104, - "blockCount": 1, - "key": { - "/": { - "bytes": "wYGfU86hcikcBpbCe+6Kuv2P53356Ae9rOBxGeGjeJ8" - } - } - } - }, - "headerCid": { - "/": "bafkr4id27ok2an5uiboe2ssvitwsgrzfavh4ez7wx6q2cw2c4joxxql6je" - }, - "metadata": { - "created": 0, - "modified": 0 - }, - "previous": [], - "version": "1.0.0" - } - }, - "bytes": "4xPLthg8lZC4Q2TKeFIrTtOqmrcLRaPOIKuhWMVTjj4GejvOAAsq+xRT3u2SqIyVKhYo0Vayl3T/zOfjIzFtBHhvPtR/06Ao7Q4a7zd5C306x0hFAenkbCaw2su9OJiiN/2p/tJw9GNkktdynFXJ8RAKqua3WfqlCU2P0BfURglsrH4PYjz4T07MQ8F8bA9pGIm9q5NrJvdI3bB9VJ7e4D15GLfO3+Ax8kwrtE8eEV0oE6WmG2rsZTbMu1lDIu/b9MU5TpwhFpMmzbfDkBIpjnHkgwKsa6PcOhFovTVtqq698fipU5fJypLJfiAf0dZpYXT54Cj2UnFlB5rEeHpZuXvSA5lv/tc89ytqofnJFLT9/FbwikBTqpw+LgrucwgilKMvD7drYD2S002fBGntNJ9GKcDkz/FMr2B5Z9NtAfcYznrE5BYX96r0T1XcO8t//ENiuCMg0HmT92/fb+WkWtcaBRnEmSFNNBIBHWdC35/hHywkl37oekirTdqFkA0+JYTbFFvOkLMn+icgN3EMxW9oAg1DQfMHmRgeRA6xQgGV32a0demnRUYCwXfXngY/rTzRG00XR6ZVI1hSkRG1ZRrsZdapnkhfKuXDH8TIwxoEqL9ehisY0xUS5zk9XJwVj3VjUaq74RXBpYIEb/uAxlZWRSmCGXWWuV7KPDGiugMaptp/1RN57g==" - }, - "bafkr4ihdaiqkdywzh6uk3m5ey73m27utfmwkx5fbhnjqahw6ws6xc4nzwq": { - "value": { - "wnfs/priv/file": { - "content": { - "external": { - "baseName": { - "/": { - "bytes": "OQzghzyCvKlcMeSn3LlJ17S0ADe8C/5XVfObj16Yt5/yXhzaF6k58g0wt+Z8T4787Fo9120nb0VmWncjIiE0TtWrTeAb6T9euBlgZ9ZaMjX27RsBZNEustqinwLsC2y54bFqDdhkcp9qbNSKYz1gyGVdz+8aCCFWW+D3s+p0ZRbIXx30tlyqzd4Lrs3Fbi5oHwMBkTf2+w4m7w3ekLPOxLVK34E01d5YYHeWvRXHfIJ2Ry8dkdFs1atalTrtQG4YPNjiC/HIDUiAxfLaKM4iFViEqimYziuJUvjs7qQfhAqdKpnZHXR07cQLzI8dDggP1LcAGkW5TTh5tLMvrEOXqg" - } - }, - "blockContentSize": 262104, - "blockCount": 1, - "key": { - "/": { - "bytes": "Iiy2P33Xr8poiQUr2ZCBYGdnWzZZJsXlJukDjcM075w" - } - } - } - }, - "headerCid": { - "/": "bafkr4ige3uogilhvhm4ofo47g77o23h66wsmahzvp4wg4skdxorlej3caq" - }, - "metadata": { - "created": 0, - "modified": 0 - }, - "previous": [], - "version": "1.0.0" - } - }, - "bytes": "74os63KRbRUtxxjkQivsoC4DeRKbpUDB7q7YSWThpYvCEALNycd9x0hQMAX+g8IEi11kxh8vhl5cZcyfDqSR7CGAOyMMKqtZZC1DWzwNiLbMV9am+0NOwl3JnfFkYfrmWB1juapQBBIF7rK2Rfc4S+pF4n1QC8DqFAyrXUAUq77Kkl3HRvEdAi3vp1T+mQm5hozkN6sEokwNyFKj0glmCRjFfsWxi9YkwVFJHz1ozb4Pep729/ruDR+WZ3/nm9FnlwlUeIomk1Gg3XM3hW4jVgSQhS6Rh78R+Emff13CSvY4b/xYq4XLn8TOtm9zgiBrPd4ukDbFp+Ew8Bsl8I+krMjJ0yEEMwoMuCcPdTEAvjGrb2FO8h/QJVXgaJBsHOUKaL1+kFqebJhhuXW6VSzWczMO9EkoMCcc+MSokv6T9u1usvk/h/nRi5RNz92iNfpK2T8IMnPxpn5bu2Qxm8Xq37qUg9aPZ6EIskDBQ7U+teZkDHwMbX01RI5WxGBQsGLwk3MMjCnTHeL3wPTx8K/y6745jWordbigoUghWMukFzz0oTg/tlfOXUQ2j02IKEzgG7QsIe0PkTZ9d2QZr6MrbYGvezAuAuu/rsCTsgegpRfhnUut+H4AoM1N8MX20/giXitJneULIaam5j8rE4iv4JmjNSryFlY9MG0jyTcEx6mIiL4o5bunGA==" - }, - "bafkr4ihyqn24ajhlatyprnuvlwzm2rc6mifvspd5ky7kzzkb5x5vz2km2u": { + { + "cid": "bafkr4idg6snyh35lnpvzcgesjkaaxx6zjxshpogd64ze64a5kktfo3nzvq", "value": { "inumber": { "/": { - "bytes": "7ZvvLa9s5/MxqtesArctKhbSHrGHtv4ndDhloMGL5aM" + "bytes": "vne1WpMqViJqa03c5qoaSLUpA3XIBiJxwuMf9osbWlM" } }, "name": { "/": { - "bytes": "aCl7M9B9ISc0FKfkXlC+/fQrBieSdFa7UHfg9pxWUysSEqTFDNmSnAtJrTLHKvcrXdHNABZnh+8xmzLMsMWDfhbpgUcy8JbGZHUE5tdEPJSjmfzymH5hcA/5ZLK4GveiCpcwnzgF4rvBF+8gjtmlAcfgZODJVtQXpakP7JEv4/0oaD4RfFSCYbr7dI3ZwMbTn/0ksZ4GLWWGtPSbzca9i6r6Rf+94k1s8Du7HPzflDtHvhhkYPqRG4od8xElyNKD9kA7PchcDyEO903zaRgnOdlx8+jxVeTAnDa2fYb9uBvrmQVxp3aKG8onzWPqcvyOxFVUyA36YYoflrmgEWQ2DA" + "bytes": "ElVG2/MKo+xcz+1lm3nFkl2MpM/PoWElg2C1H5sPfQ0YBSQW9+nMJR1otJy+dm0bg5bImWHMUpenrCxZ+W+JPdb6fXPe59F7gTO9j3zRJOVceZF9z/pDjTR9Ub8wNcilyrAA3T0DYcmD+4PDJXzWMlhDpMaTyEb0Ktza8ohwPwqZ+l8dGyMYAqoL+tZ1EdZeTaj2vH8D0GZ0G3jETwv0Sei9rpsraQD/sYvTFn3EiGSvmFfJciXVXM3nQ1iVp/qydKwlDxyW+E2qpL2ZAE/MsZ19l5FfaS+ZICT24TZqXP04r8LXdH8OmTwwusDi/RupMQQcHDieCGMVbeu4ClPDrg" } }, "ratchet": { "large": { "/": { - "bytes": "b95XEkEp/IWq3CHcuY/FLd9TSA14bbv0QE9Mrq7sQ1o" + "bytes": "fkQysCnE9+L5U6SI6r6TEjxAg9ypPYkILcyntk6i4MA" } }, "medium": { "/": { - "bytes": "z7xgOiJfD8LlFflXWeM0gvUBHx+LXf76SWglSQd1PPE" + "bytes": "Qyo7Rw0IyXRu6eL805pN9Uxlb41DahrvEHbw3qib1Aw" } }, - "mediumCounter": 128, + "mediumCounter": 18, "salt": { "/": { - "bytes": "N0VVwHRctdFamy9wwLDwDau8vOm4vw38NzLZ91fvvJw" + "bytes": "/8FmnP2I6CnT0N6iXzyETzANlYRQeNrs9z+z/ClDPzQ" } }, "small": { "/": { - "bytes": "7DSyYV83IQ+FL+/xhT8sHLrYn9A+vvfkwuc/atd4MOs" + "bytes": "pZ0fTz4FIqjw54lxpz8l0NEGPo5l2XYgFN9dmGeHlZg" } }, - "smallCounter": 215 + "smallCounter": 207 } }, - "bytes": "yB/GOP3COI5493qCebpqK8IBORKcnE0QJ1D8KmnYKNsonP6/JEF83d4enhASDjeZQkYNKsXOjnYnnGb7bDjo6AJFTjRvnAQhXyg3cg+rSyZ40S6VoD5MbO7OgdIb/J1uYXnyb2iOwAxC/zU+kH6mEhEFuWOdrKdtYrXMdTVOqrM8QGU++Cf5PZT50S2bLgQ9mzwfxn0DgiqsslxVWqSoyqbLxpjBS7Czs/EXycqN5bH0Jeh5rPuKoovLN77VNqM1e6jexNyGjkTU4QaPIvSoC2aPdV294rlWA5DowI/RKojFupwchApwcIboH0qxXZVL40OzC/b5Dg49OmF5L17otl8NL07SiHCXeTxPsPJs8CVav6odVgpuhWEA6TMSKJEKfoHPjx56HDMVKfujRZhceJP0Y4v73Sn3g2BQVtahDVQZUMo2rxhrDsYTGHqaJaQzFC10DYfsEpJ0Wp3tfWB4F+cqHA2ACZKtIHXgK1Yc6FKbX21Y87CBzYSvBDkh97EaIJoyu7cL5bLUdwrmskyQF0Nok8hHEErGEpTCwJ8Nz6wCRHtu234jOkD7xrhgxYQQlS0bioIlWs4ZFRo3Dltes8EzEE7EJP4CSy8Qd5y/dYjei7r7W4FYw0r98VwSdqRPrLQaFWm7zjJJBn22bSUv9+yOeVO3KMiTWj5kVuDPsml71G986iDLWA==" + "bytes": "NBHV1M9vcBaFL5XMgorch+zRyoL9Oqe6yvc7+3LKN9mO384eIB5ponXqDTpULoSVnB5y8eDWLaeDr/EPVaIqR/qyivMyvm6Oz5vQG2LZJ7H5UkrA0Rhl0k8G8EZUhVmLkBWdHWQ4x86FFyfGkdGZyqq/zCKVrMZ+1GRSbFoT1b7Ps+DIjcg8o5haF7h2Eto6S1ILZjzjnqA/vaDlcjsBc+wh5fzKxInj1tXZDhAe+XXHbpkdLN9fDlFuIFfcJsViJFhm/kBeOH+IidzbsU8+axs2KGh1paeecE7HtCl47XdSkHzbUlZw5hV3TkQcaYGGYvAnYBtId1O78d9Hd27arzv64nKiH1krYo4VGxVrwloXrwM3OOtFkn2Rh3jbFMEqDFO0vMt7EC8uS/FIhj7eYLofuNj3NDlWqYU/KVALtw9WnqhWEZJ8+fuKRdHF/gRRO+OEpnJ2Ye+cj6aHGgbEzgoVn2aWjcL8C3004uM2BUOrlCKXLEH8FtS6QmjXBY5BISx5Apc5dX5vXG3aAwhX4KcgmsQ10RObQf0UT1BCwtDdiYZyZCGPTFjyAksAsbfCEJTq0apXydMXJ6HPa+SkO3x0UGg/+zMfHQ4+5/sdbSM82CHoU5SZQXbi7JwGZRJHJKSG57UO0JghOjc22cMccVCv0LzjwF1uuTrIxVyOS7erPCIncRC1SQ==" }, - "bafyr4if7e6v454vdr6u7lchzyvnf2dl67va4iov6izm4ws4wzzkwrkxmke": { + { + "cid": "bafkr4ifigj5hkswtnxpipcaklzl7jjte4u2jzry6azviw4uionctsa5wqi", "value": { - "accumulator": { - "generator": { - "/": { - "bytes": "rGCe5WHIjiZjiFxYSolBMJVjSSp2tGS18oeHuU2n0RFR3k5UcbjIjxzCF03Lsndi4sCURnnka6qzIs9sl96XpmOG3b+ds6Kn2sdqnw22vdIWYjL5J63NtT26i09JMi8JWNYiF8aNRLSdXGg+TZTd1pN4Kao7k6ThdaPENnQeQB4IzzkputboM2ZUTu6Jxg4teVO5D1yXImQfJ1VgOGwWBC0j4xuRRZ9STH3tZw+boy4oC584XoRpagF0B+PM7/r8Pjmz/Bb2qVA3tTebeY6ZUeftEvodt/DPiEsvKvag2SdwzuPQ3IVTZOnNF3CZSy5G+W1WwLbMl3yXDxO4yMmcPA" + "wnfs/priv/dir": { + "entries": { + "anime": { + "contentCid": { + "/": "bafkr4idfb6czevqvtq4r5m5trlchtxo35gmhm3tzqiyhzldtn4aaey2vpe" + }, + "label": { + "/": { + "bytes": "YmGD28vSqSCxHVHCEKfRZnW9CwlYr51JDIU1mA25OMg" + } + }, + "snapshotKey": { + "/": { + "bytes": "NlzXezeSP3RAStijGSnUAoKOlGrEzqfMCphY424Jzww" + } + }, + "temporalKey": { + "/": { + "bytes": "j1sB3oEoYLgh4K2F/oWn+JcYBs1n0f5dqxkYw5blUDz6vRn2PREmKQ" + } + } } }, - "modulus": { - "/": { - "bytes": "x5cM7tzDsHVEkCAaeqYTzXOREIHHkPXxqHJvRjVQu1t/8NuOHqEYnscvk9FlABG9chrurMKs3jKgQQfwZIwoE6MfWwt3Zf+LRLS2/8kzhLZG6wnHz16FktQOozyAA581tPFKBLUfe/14G+TRZzFkuo65kcLE1zC7vjX1kr3vUkr36Nrv0mxm/ALEea+J1k03P0QnCUOd5mzrlV8+o31RWfYTWAn4UzS1yxgTrdyAzQVgnxCsapWtZYcskJUlva0yvHKVkmQpIPJMYdxbPDt5I+VrFqTZ03PYch8ko/wPGzEx9VYVFyhmvMww+VBUyCTnM6XraBf3vBY5nUjGNhzH5Q" - } - } - }, - "root": [ - { - "/": { - "bytes": "Cyw" - } + "headerCid": { + "/": "bafkr4idg6snyh35lnpvzcgesjkaaxx6zjxshpogd64ze64a5kktfo3nzvq" }, - [ - [ - [ - { - "/": { - "bytes": "lymDN7MkGgG3u8iok4B7WlAfHL9C8A6hQwzHRv6gPtvhVs85AFvmM+JtfKbpMiVfpzcWk0JzpkfHPu7DT+lB+a+1gQf29eISR5WdAjjCzRtpON6Y9saLYzcnlutq2VnOp1271GmDgXhc+TSLyQh1PonZtwE9hpnusmK9IYKlaERB9kMPVSjEz1oxFDD3iUibNh/Rc8e/8YoKo5oA2gY9eVNJbt88fenpTz8N1zX+yN3lg+NkbdNmZfyICrX7fmX3z5xQ73AJJtkgBwItQOo/yU5oXFGioMp8Zz8NEGPXGr0GqyN/nY7iDbTcqhkpPnwSQSn7SE0F+Zrx+xxpaun7Rw" - } - }, - [ - { - "/": "bafkr4iet6tkcbjesymahvv7p65qkrh3hd5yfftaidfresulzmes32btkqi" - }, - { - "/": "bafkr4ifutwdq3umnvxedkcatmt2jkmuelhha5r4p2weemjt7husmk3cbg4" - } - ] - ] - ], - [ - [ - { - "/": { - "bytes": "w14N/BqAkyHzR6pXkHQmVmcyMgU8BWqTAXdI9ykot08G9C3jLTRgtwUsPMZeaJViArFE5uxSDbxPwirN3WJuwpSU8jx24gfRMOKhqP+8hfsAmRbnX9V8MOUy7WG7XoHOZX4LqitSUTyb4Hp/zpfzPGYTrGXeJmpuHPK15bffkIH45Gf80uVuNk7M/UXoLDI3p0ngcNsT9f9ZW0QtO3GbNcmeNjnZBc1xbCG/QvjyMtYlPl4UCNVIrYqHaWBt8w9aunMleVju2CScpLReoD0MRfaj8t98qmOzxt7CqjZrd1oL7h6MBoGOO/6loD1HWd/aX1kgVzVVbrtKV06d7KRjcQ" - } - }, - [ - { - "/": "bafkr4ieds46knvozeny3uexqfhr6rg2orvvlhu5bvdsbdon3dy72fcolme" - }, - { - "/": "bafkr4igjmm53wzadt5zcedrl4j2xiwzmd5shi4iczwqfk2tuoj5xu6paym" - } - ] - ], - [ - { - "/": { - "bytes": "UvkoRXdjAid/x/kkWYsYBYxNZ6RhDJvUUU1CTo4HgYfMrFOOBADJqO9ahO4WDmImBjZ/03mNlACLhe1LkLPU6dI1QMmUjBHjmItLqOZf6HtmX9aZL/BTGwlCBtuVE1+QcsgnKzZm6cSB8wv3XECn4mz9nZvSS4sFCwzPFHobZg9UZ0Ry1ZNHRl2cOBz9MwW4A+Y3dSkvWmjCOZlbNuKofUcYm3QWuVDTXALj83myPjgAVaomFV9KKxITefjuNdlN72iTGx6H9Ts+wFOakUHw9/KA4owMovi1Klz2bg5R7/d1BWo5lW6GSjL8IsUC4BrQskpgi3VkVNQvwDfmGBJqOA" - } - }, - [ - { - "/": "bafkr4ige3uogilhvhm4ofo47g77o23h66wsmahzvp4wg4skdxorlej3caq" - }, - { - "/": "bafkr4ihdaiqkdywzh6uk3m5ey73m27utfmwkx5fbhnjqahw6ws6xc4nzwq" - } - ] - ] - ], - [ - [ - { - "/": { - "bytes": "SosaSPL/YisdSxgR5F/wrHlNaxyA3/JLcYo0pe+YE8CkKA9Ig944iE7KLSP/J4F33rsaKHyFZUK2QfgYzAF1rUf04ks3vj8QZ3VXiB1hViIRBucSHsOunGi3fQHViH+7yHDzzWbAsUYa+qjLpUwkQVK+YrIxJxi/8CmJM28Wd/hdUq37CHxDX9lVIGzd1QKjgkTay6D4T5szk3TpwX0MwunwdJL9FT4vYfwXhWNpEUPPCfFkG/8KlvZPBBSL3Hn1YjaW5zc4ox1Tp5EDokxQAsvUaJpbkNkQUceYSPIeIOX0FTqc+u9xbseXyfqPIGgjtQFSYFrruFveckdE4Z7izQ" - } - }, - [ - { - "/": "bafkr4igc3l4da4vqhyjmr27pys4iw743v3cii5ovwitxmdqmqnincr7ujy" - }, - { - "/": "bafkr4igkqdavo5ukmdawyydj4jsfmllux6azgj2yb72xars4ljmmwokg6u" - } - ] - ], - [ - { - "/": { - "bytes": "ba6bHfa4ErLwY1ivuZ5i4MyMrO1ElocflmRJMiuaBn8sOQIQi864mbluXipI2I+qbYtaqX989L4c1Kv/CXOvBY7plgBzLn9BKY+A7mT0pXX4R375LZxl+I7jusIF91mYHzjkOX+BfsIGu8BoPx5vM8y0U+fwTo4JpAZ4nU6Mj44xd1b23hym6qnnbnwYHQfCxZ+cVYqX1c0IPelWb9b+YQnCVsU3BU6G3BfD8C9ZWqW960ysjsJM+isz5Hr19UKWuV+8LPLwiXgQRnGGx7yiC5B3xRSVrjrgCHShWoNIY3E6zYb41LX/zjOtQiCm2TILH7T6xdEG9s7PehTLHs9KHQ" - } - }, - [ - { - "/": "bafkr4id27ok2an5uiboe2ssvitwsgrzfavh4ez7wx6q2cw2c4joxxql6je" - }, - { - "/": "bafkr4igoes2nc5ibp3kcq5qerw7lvdwx47v4eiycn37kkqr3qngepjbn2u" - } - ] - ] - ], - [ - [ - { - "/": { - "bytes": "wrIWSys1EK/cJwoyd7gS3bgRRJmyQt7QAQyspEuED1fHCJh7Clvaa4Kxw1rVgrySArThjLP3lCPRUlwhPC+54i74ZCygCbfYj29Z4blODYlq28s77dVXDKSZpF+zCMA2apLh4ZNlNTonxySu4jrmVv1Q6nYvmQ/W+eMkXnELvNAReu37PhvEriZwi4s7XJMSKZQqAiQ0jba7mBZVR7FbpV21No+qIFFB0IQG0UM1lp5bLAvwCnBCTls2LOvvvk7gaBrLTgVgnt5r0uOYQnb7SCiS0kmI6JLwV8Cngm01ICg/ct/ACnRW8Bcc5Cvf4B5C4ZKUFSKnJW65J0dHug0nIw" - } - }, - [ - { - "/": "bafkr4ibpbyy7pbkq3kppxasqy7gh6nnfg35on3n76vamzzku2gberpsype" - } - ] - ], - [ - { - "/": { - "bytes": "G9SXAdfVIrSscPqMWXXU4WbgWYPMfRFjEz9PL93gDN/Ewju2SZIeA/Sy+6T3M3LPVyvzRBKMRBVuhp+NAco5yJURFDI/88sbwA7bfcxzYHv08De61Ni7F4jnrEfm8fu+IwHsXyg5c2Ld3iu8fKl+kiMC+WIoOGOBrr3Je1G5l/i3CTFV+H4VwRCfmQxLo1DcSWbXm+aE1FoZkWn4P5lkGDYGmJXQmOTEVYLHs5K7tLHNKPo/ZKw7XJvJLi5Knt2gb0wNZR7Qv4IrTWz95laf3IVgM3/iDHBjS8jfxfddj7d58iu1i9HNiDVFtAPV63c98J13oIpLUkg1H7jdpMhjOg" - } - }, - [ - { - "/": "bafkr4iejjjkfbpeflivh436mut6254p7gujytubff65e2kpgqgenvqizh4" - } - ] - ], - [ - { - "/": { - "bytes": "ScNoEItIf9TenchTnWtxd7NtyHrtALuwSOyiYfmvzl2eOt9d6f2H28/Dmi9UmlyTIdJZvscfo+yyBkzikF7L7UDGUKhpa3ARPqT37LFadO5WqFg0+cZ642dhVHC99L5KcGDMO55e047gGDsXVyhaBDlmDEc6g3+nwnGyAyrw6nr1qkEd9TiLGFMRu40+On0KHV+pWZYKxXIzFc1rsHsjcSxqQ+3SC3quCb0UftRQskTGh3IifFEp5RVTngWFj+M3jDgw3ll0zUlH2Fj6UpbMcMY++ekVtbD9sZHMbieFCSu2neyuBSgzM54fWwSVtG0dNg4Xybd9Fh+uGt06CE1Q1g" - } - }, - [ - { - "/": "bafkr4ig7tinqye3xoya3xvhk7loti67g7fy6jzmlstkjhvk55jmelzml3q" - }, - { - "/": "bafkr4ihyqn24ajhlatyprnuvlwzm2rc6mifvspd5ky7kzzkb5x5vz2km2u" - } - ] - ] - ], - [ - [ - { - "/": { - "bytes": "D3XBvmf1N+qQkCb+VUSRLr1cScJlkhGp4sCLfZHhG5XpAngrMmdk+BHCN2lSwcmtPDvoBdPU+1nK0n1cV92WkKQasBS3WA+O0/20OGjCOSL7V6T2BdYPutuYWZcgLqReJO0qJ2BfnEYBXMowHnOYY7Ks5RqJ/pCR3w9sntQ9kw1dxclp9lTqjWm4edw/TtO7iPKnXm/L8jMwXnxiwMY5QSlWkC4xeCCxDjw2PZCbhrOB1+XQ9mRtV7PQnIRvKW+3FXUkg1583s1Bz/kNakRGatf6eOM16AkLJ1IOTRTL+E6CZH5KhtTy7TbArJMNv4LBQ77MdYWbUPdWzDyhxdVFIA" - } - }, - [ - { - "/": "bafkr4id4dtihsnfxer2fetfspcxgakiq23xk7cxmumpvzwn2kyoxfwuh2i" - }, - { - "/": "bafkr4ie4v5pcplbse5oplfwh2ddy5vphqizlhzuc27nvputzgypwjkic2a" - } - ] - ] - ], - [ - [ - { - "/": { - "bytes": "dd7aAL3Yj4H+GeraKglooRrwzrFI5NRzjCfmQ971jXW9MxqrlCC4E8yqnBAcncv8RJMaN5nDOE2VFVyelhx2kfLk8XVXWFpDxNlj6isWZcD4z26BoxpXigQnkuOYPqpVdH3Zhfe1Hj1R1/zsJjQnFognt+Y7cP/rCiujE4MIzO5Clpru/2iikFbxwjEc2jaxvfCq3+VE9ScoZKsSWxJOj9GABIalj4r7uTkqfw3qcE3eccEn6k6c6FnVSzzT4/jui1mMEEHomm0EGYwIKamuXeQfRg7asrWJEL23GP6RU6Np72pVZPIUb/1a1IEua9FM8O0x496XJ3oCinUFAf8F8Q" - } - }, - [ - { - "/": "bafkr4ids4frwdo3i7vfotshrgrid6tfbbx4bkwpprpt6i5shod7nsauxaq" - } - ] - ] - ] - ] - ], - "structure": "hamt", - "version": "0.1.0" + "metadata": { + "created": 0, + "modified": 0 + }, + "previous": [], + "version": "1.0.0" + } + }, + "bytes": "T6EjSLJGR1Ckk85SRNTa+2HUBkjM3oPJWq8lThHbxO1NzlGPDx3qlR0J8XVUegpx27nsxDAzGVOUMSKDC5A/6NbfqNRbou56de2rMyeDc26hJb96kCmsFoIliNXEWAFg+6+Qu4Ho8uqcO2S/p1cnKNG9l3JYYd0UeIRt1Et2QsNXbw/CXz6IS8QnaiJG+WFldHk4iFBSJZFuzSel1jak/Sg4mYKm2IQ4Ph+9dA/I5jP2e80TzTLDXs1qKlT5ME2X60ZHYjOzsXQu0F5ECUvdRmT1pirIykBEChWRVDQ9wR7COPRf0xuNJ/Jp26fFl5+TosmieSXjNsC5Oy6HY0T0yDRpkEz+72jhLg0ttBwiHYjAhlM7SQ/HCykEYjgwgJEW9rcFJ3+UAejaXpDTSmGTj2tMjCOlwXthu3WeSmQb3Zo29LRylIts/mm75KpmVzvGCTWNy9xh/6y58t2QgP+qaQk2FDY1NKbSZFVwUOPantk=" + }, + { + "cid": "bafkr4ig24orkcp75447hy2abpan36i3woaerfsg6bnu4z656d6xpa22jsu", + "value": { + "/": { + "bytes": "SGVsbG8gV29ybGQ" + } + }, + "bytes": "XfKFnyZ9B/oCShlpO5aJQzasQmcQIQpAbn63DLcIBTFdjX2mYM5HJkXCjt+et7E0+Aro" + }, + { + "cid": "bafkr4iabb422gnp45fdjd4onr567olqprcl53oblnyima3oenyqvae3ifq", + "value": { + "/": { + "bytes": "SGVsbG8gV29ybGQ" + } + }, + "bytes": "2ARXvwnglXovkitY55ZG4ColKct8mePeDZ5fiwOGqsKPJKYCSecliCfU6Qosi0kfW8Cd" + }, + { + "cid": "bafkr4iczjy3vg4v3snxzouqcf7hos3gta5ewwrqh6sp6243kp6nlxv6axi", + "value": { + "/": { + "bytes": "SGVsbG8gV29ybGQ" + } }, - "bytes": "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" + "bytes": "VWB36mFajvViTP7DTRDQD6bINeHM4vYFrdw43P/I978t7cD4xwCQrnWrHHau8ViPU25T" } -} +] diff --git a/wnfs/src/public/node/node.rs b/wnfs/src/public/node/node.rs index fab6ca53..4eb9ea81 100644 --- a/wnfs/src/public/node/node.rs +++ b/wnfs/src/public/node/node.rs @@ -380,9 +380,9 @@ mod snapshot_tests { .unwrap(); } - let _ = root_dir.store(store).await.unwrap(); + let cid = root_dir.store(store).await.unwrap(); - let values = store.get_all_block_snapshots().unwrap(); + let values = store.get_dag_snapshot(cid).await.unwrap(); insta::assert_json_snapshot!(values) } } diff --git a/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_file_and_directory_nodes-2.snap b/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_file_and_directory_nodes-2.snap index 2966f538..3477be6f 100644 --- a/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_file_and_directory_nodes-2.snap +++ b/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_file_and_directory_nodes-2.snap @@ -3,6 +3,7 @@ source: wnfs/src/public/node/node.rs expression: file --- { + "cid": "bafyr4idombemml3z63t5smrs6ktag3dr2ckvvzbq2ngtjklwqkotxwzs3a", "value": { "wnfs/pub/file": { "metadata": { diff --git a/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_file_and_directory_nodes.snap b/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_file_and_directory_nodes.snap index 7bdbb8bb..a7704e02 100644 --- a/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_file_and_directory_nodes.snap +++ b/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_file_and_directory_nodes.snap @@ -3,6 +3,7 @@ source: wnfs/src/public/node/node.rs expression: dir --- { + "cid": "bafyr4ih3k2ipwwqryrlmtmwtolma4t772gknmx7pxqu5opjwsrr2nc27qq", "value": { "wnfs/pub/dir": { "metadata": { diff --git a/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_fs.snap b/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_fs.snap index 1732dc0f..af29680a 100644 --- a/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_fs.snap +++ b/wnfs/src/public/node/snapshots/wnfs__public__node__node__snapshot_tests__public_fs.snap @@ -2,16 +2,38 @@ source: wnfs/src/public/node/node.rs expression: values --- -{ - "bafkr4ibirkdkphzauplnztoko4j35lwrpb4yffv57j4rh6rkmlmxe67y7a": { +[ + { + "cid": "bafyr4igcgvnnbd6xh7waotpqdopqcesi4wfmfcl2u42gyspjfc3djzt6wa", "value": { - "/": { - "bytes": "SGVsbG8sIFdvcmxkIQ" + "wnfs/pub/dir": { + "metadata": { + "created": 0, + "modified": 0 + }, + "previous": [ + { + "/": "bafyr4ih3k2ipwwqryrlmtmwtolma4t772gknmx7pxqu5opjwsrr2nc27qq" + } + ], + "userland": { + "music": { + "/": "bafyr4ieu4jffr7sjcakgzk6jr4w5gbbmjs6oe7q2trrutjqcugr4orvmuu" + }, + "text.txt": { + "/": "bafyr4ihsg6l6g5tw45a3zh2dilphrtafnb6pyc7dpdxbuncgekjycqchnu" + }, + "videos": { + "/": "bafyr4ifobgzwli26fibfladmtouh32okhnmhc7jpy5dvmocz5dgg3wqrnq" + } + }, + "version": "1.0.0" } }, - "bytes": "SGVsbG8sIFdvcmxkIQ==" + "bytes": "oWx3bmZzL3B1Yi9kaXKkZ3ZlcnNpb25lMS4wLjBobWV0YWRhdGGiZ2NyZWF0ZWQAaG1vZGlmaWVkAGhwcmV2aW91c4HYKlglAAFxHiD7VpD7WhHEVsmy03LYDk//0ZTWX++8Kdc9NpRjpotfhGh1c2VybGFuZKNlbXVzaWPYKlglAAFxHiCU4kpY/kkQFGyryY8t0wQsTLzifhqcY0mmAqGjx0aspWZ2aWRlb3PYKlglAAFxHiCuCbNlo14qAlWAbJuofenKO1hxfS/HR1Y4WejMbdoRbGh0ZXh0LnR4dNgqWCUAAXEeIPI3l+N2dudBvJ9DQt54zAVofPwL43juGjRGIpOBQEdt" }, - "bafyr4icjyr6bcipvqzguj3gctaihetpeqxgine3zw7zkw4eyzrn2ojxwhe": { + { + "cid": "bafyr4ih3k2ipwwqryrlmtmwtolma4t772gknmx7pxqu5opjwsrr2nc27qq", "value": { "wnfs/pub/dir": { "metadata": { @@ -19,17 +41,14 @@ expression: values "modified": 0 }, "previous": [], - "userland": { - "anime": { - "/": "bafyr4ihsg6l6g5tw45a3zh2dilphrtafnb6pyc7dpdxbuncgekjycqchnu" - } - }, + "userland": {}, "version": "1.0.0" } }, - "bytes": "oWx3bmZzL3B1Yi9kaXKkZ3ZlcnNpb25lMS4wLjBobWV0YWRhdGGiZ2NyZWF0ZWQAaG1vZGlmaWVkAGhwcmV2aW91c4BodXNlcmxhbmShZWFuaW1l2CpYJQABcR4g8jeX43Z250G8n0NC3njMBWh8/AvjeO4aNEYik4FAR20=" + "bytes": "oWx3bmZzL3B1Yi9kaXKkZ3ZlcnNpb25lMS4wLjBobWV0YWRhdGGiZ2NyZWF0ZWQAaG1vZGlmaWVkAGhwcmV2aW91c4BodXNlcmxhbmSg" }, - "bafyr4ieu4jffr7sjcakgzk6jr4w5gbbmjs6oe7q2trrutjqcugr4orvmuu": { + { + "cid": "bafyr4ieu4jffr7sjcakgzk6jr4w5gbbmjs6oe7q2trrutjqcugr4orvmuu", "value": { "wnfs/pub/dir": { "metadata": { @@ -47,7 +66,8 @@ expression: values }, "bytes": "oWx3bmZzL3B1Yi9kaXKkZ3ZlcnNpb25lMS4wLjBobWV0YWRhdGGiZ2NyZWF0ZWQAaG1vZGlmaWVkAGhwcmV2aW91c4BodXNlcmxhbmShZGphenrYKlglAAFxHiDyN5fjdnbnQbyfQ0LeeMwFaHz8C+N47ho0RiKTgUBHbQ==" }, - "bafyr4ifobgzwli26fibfladmtouh32okhnmhc7jpy5dvmocz5dgg3wqrnq": { + { + "cid": "bafyr4ifobgzwli26fibfladmtouh32okhnmhc7jpy5dvmocz5dgg3wqrnq", "value": { "wnfs/pub/dir": { "metadata": { @@ -65,35 +85,25 @@ expression: values }, "bytes": "oWx3bmZzL3B1Yi9kaXKkZ3ZlcnNpb25lMS4wLjBobWV0YWRhdGGiZ2NyZWF0ZWQAaG1vZGlmaWVkAGhwcmV2aW91c4BodXNlcmxhbmShZm1vdmllc9gqWCUAAXEeIEnEfBEh9YZNROzCmBByTeSFzIaTebfyq3CYzFunJvY5" }, - "bafyr4igcgvnnbd6xh7waotpqdopqcesi4wfmfcl2u42gyspjfc3djzt6wa": { + { + "cid": "bafyr4ihsg6l6g5tw45a3zh2dilphrtafnb6pyc7dpdxbuncgekjycqchnu", "value": { - "wnfs/pub/dir": { + "wnfs/pub/file": { "metadata": { "created": 0, "modified": 0 }, - "previous": [ - { - "/": "bafyr4ih3k2ipwwqryrlmtmwtolma4t772gknmx7pxqu5opjwsrr2nc27qq" - } - ], + "previous": [], "userland": { - "music": { - "/": "bafyr4ieu4jffr7sjcakgzk6jr4w5gbbmjs6oe7q2trrutjqcugr4orvmuu" - }, - "text.txt": { - "/": "bafyr4ihsg6l6g5tw45a3zh2dilphrtafnb6pyc7dpdxbuncgekjycqchnu" - }, - "videos": { - "/": "bafyr4ifobgzwli26fibfladmtouh32okhnmhc7jpy5dvmocz5dgg3wqrnq" - } + "/": "bafkr4ibirkdkphzauplnztoko4j35lwrpb4yffv57j4rh6rkmlmxe67y7a" }, "version": "1.0.0" } }, - "bytes": "oWx3bmZzL3B1Yi9kaXKkZ3ZlcnNpb25lMS4wLjBobWV0YWRhdGGiZ2NyZWF0ZWQAaG1vZGlmaWVkAGhwcmV2aW91c4HYKlglAAFxHiD7VpD7WhHEVsmy03LYDk//0ZTWX++8Kdc9NpRjpotfhGh1c2VybGFuZKNlbXVzaWPYKlglAAFxHiCU4kpY/kkQFGyryY8t0wQsTLzifhqcY0mmAqGjx0aspWZ2aWRlb3PYKlglAAFxHiCuCbNlo14qAlWAbJuofenKO1hxfS/HR1Y4WejMbdoRbGh0ZXh0LnR4dNgqWCUAAXEeIPI3l+N2dudBvJ9DQt54zAVofPwL43juGjRGIpOBQEdt" + "bytes": "oW13bmZzL3B1Yi9maWxlpGd2ZXJzaW9uZTEuMC4waG1ldGFkYXRhomdjcmVhdGVkAGhtb2RpZmllZABocHJldmlvdXOAaHVzZXJsYW5k2CpYJQABVR4gKIqGp58go9bczcp3E76u0Xh5gpa9+nkT+ipi2XJ7+Pg=" }, - "bafyr4ih3k2ipwwqryrlmtmwtolma4t772gknmx7pxqu5opjwsrr2nc27qq": { + { + "cid": "bafyr4icjyr6bcipvqzguj3gctaihetpeqxgine3zw7zkw4eyzrn2ojxwhe", "value": { "wnfs/pub/dir": { "metadata": { @@ -101,26 +111,23 @@ expression: values "modified": 0 }, "previous": [], - "userland": {}, + "userland": { + "anime": { + "/": "bafyr4ihsg6l6g5tw45a3zh2dilphrtafnb6pyc7dpdxbuncgekjycqchnu" + } + }, "version": "1.0.0" } }, - "bytes": "oWx3bmZzL3B1Yi9kaXKkZ3ZlcnNpb25lMS4wLjBobWV0YWRhdGGiZ2NyZWF0ZWQAaG1vZGlmaWVkAGhwcmV2aW91c4BodXNlcmxhbmSg" + "bytes": "oWx3bmZzL3B1Yi9kaXKkZ3ZlcnNpb25lMS4wLjBobWV0YWRhdGGiZ2NyZWF0ZWQAaG1vZGlmaWVkAGhwcmV2aW91c4BodXNlcmxhbmShZWFuaW1l2CpYJQABcR4g8jeX43Z250G8n0NC3njMBWh8/AvjeO4aNEYik4FAR20=" }, - "bafyr4ihsg6l6g5tw45a3zh2dilphrtafnb6pyc7dpdxbuncgekjycqchnu": { + { + "cid": "bafkr4ibirkdkphzauplnztoko4j35lwrpb4yffv57j4rh6rkmlmxe67y7a", "value": { - "wnfs/pub/file": { - "metadata": { - "created": 0, - "modified": 0 - }, - "previous": [], - "userland": { - "/": "bafkr4ibirkdkphzauplnztoko4j35lwrpb4yffv57j4rh6rkmlmxe67y7a" - }, - "version": "1.0.0" + "/": { + "bytes": "SGVsbG8sIFdvcmxkIQ" } }, - "bytes": "oW13bmZzL3B1Yi9maWxlpGd2ZXJzaW9uZTEuMC4waG1ldGFkYXRhomdjcmVhdGVkAGhtb2RpZmllZABocHJldmlvdXOAaHVzZXJsYW5k2CpYJQABVR4gKIqGp58go9bczcp3E76u0Xh5gpa9+nkT+ipi2XJ7+Pg=" + "bytes": "SGVsbG8sIFdvcmxkIQ==" } -} +] diff --git a/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__directory_with_children.snap b/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__directory_with_children.snap index 749d8aae..38a884b8 100644 --- a/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__directory_with_children.snap +++ b/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__directory_with_children.snap @@ -3,6 +3,7 @@ source: wnfs/src/public/directory.rs expression: dir --- { + "cid": "bafyr4ienz6vbjac4c3izimtfccu56denasxijdlxtivnzr6bcccij47i2q", "value": { "wnfs/pub/dir": { "metadata": { diff --git a/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__directory_with_previous_links.snap b/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__directory_with_previous_links.snap index 10f2a498..ad67c077 100644 --- a/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__directory_with_previous_links.snap +++ b/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__directory_with_previous_links.snap @@ -3,6 +3,7 @@ source: wnfs/src/public/directory.rs expression: dir --- { + "cid": "bafyr4ih337krqssypjw3gxte33y46ou4dh7looyd3vv2whxgyxumntt6pi", "value": { "wnfs/pub/dir": { "metadata": { diff --git a/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__empty_directory.snap b/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__empty_directory.snap index 371717b5..ec1ae046 100644 --- a/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__empty_directory.snap +++ b/wnfs/src/public/snapshots/wnfs__public__directory__snapshot_tests__empty_directory.snap @@ -3,6 +3,7 @@ source: wnfs/src/public/directory.rs expression: dir --- { + "cid": "bafyr4ih3k2ipwwqryrlmtmwtolma4t772gknmx7pxqu5opjwsrr2nc27qq", "value": { "wnfs/pub/dir": { "metadata": { diff --git a/wnfs/src/public/snapshots/wnfs__public__file__snapshot_tests__file_with_previous_links.snap b/wnfs/src/public/snapshots/wnfs__public__file__snapshot_tests__file_with_previous_links.snap index 25c6f392..a134a162 100644 --- a/wnfs/src/public/snapshots/wnfs__public__file__snapshot_tests__file_with_previous_links.snap +++ b/wnfs/src/public/snapshots/wnfs__public__file__snapshot_tests__file_with_previous_links.snap @@ -3,6 +3,7 @@ source: wnfs/src/public/file.rs expression: file --- { + "cid": "bafyr4ibvauaso7jbhy5f7tuyrhdbbrxxvfo4ds5ylzrnvnosbn4sbgv3n4", "value": { "wnfs/pub/file": { "metadata": { diff --git a/wnfs/src/public/snapshots/wnfs__public__file__snapshot_tests__simple_file.snap b/wnfs/src/public/snapshots/wnfs__public__file__snapshot_tests__simple_file.snap index 1f8e5b26..51547e4c 100644 --- a/wnfs/src/public/snapshots/wnfs__public__file__snapshot_tests__simple_file.snap +++ b/wnfs/src/public/snapshots/wnfs__public__file__snapshot_tests__simple_file.snap @@ -3,6 +3,7 @@ source: wnfs/src/public/file.rs expression: file --- { + "cid": "bafyr4idombemml3z63t5smrs6ktag3dr2ckvvzbq2ngtjklwqkotxwzs3a", "value": { "wnfs/pub/file": { "metadata": { diff --git a/wnfs/src/root_tree.rs b/wnfs/src/root_tree.rs index ec54ad52..e11b7e3b 100644 --- a/wnfs/src/root_tree.rs +++ b/wnfs/src/root_tree.rs @@ -467,9 +467,11 @@ mod snapshot_tests { .get(&vec!["private".to_string()]) .unwrap(); + let root_cid = forest.store(store).await.unwrap(); + utils::walk_dir(store, forest, root_dir, rng).await.unwrap(); - let values = store.get_all_block_snapshots().unwrap(); + let values = store.get_dag_snapshot(root_cid).await.unwrap(); insta::assert_json_snapshot!(values); } diff --git a/wnfs/src/snapshots/wnfs__root_tree__snapshot_tests__root_filesystems.snap b/wnfs/src/snapshots/wnfs__root_tree__snapshot_tests__root_filesystems.snap index 461f49ed..2d262127 100644 --- a/wnfs/src/snapshots/wnfs__root_tree__snapshot_tests__root_filesystems.snap +++ b/wnfs/src/snapshots/wnfs__root_tree__snapshot_tests__root_filesystems.snap @@ -2,122 +2,181 @@ source: wnfs/src/root_tree.rs expression: values --- -{ - "bafkr4ia5qq2otfmijhh2z7dflkcy3vjb57x4wwghefugom3wzurkpzzzei": { +[ + { + "cid": "bafyr4ia2wpujoivisxr2m6kidkzkfsa3rosxc3rd5wnfdvjpupfcfdsyay", + "value": { + "accumulator": { + "generator": { + "/": { + "bytes": "OiFUpIl3+9YLl6mb7DAncdAcsA4Es11CHSwuUrT3qLIOa01g8tx/05d13vLOdYGxlW0qJQM/pcg8gjI2RVQsXgxX5g+dNepL1LR5Sx28Zw1i1yL8T9HTDf+3H2DCAwvGcfmjd4VU39gUUzkBH1Wc8oHyuI02wgX63iRUNcj0l27f/qB2vX4XfVaLm+KXH6UXq632/EHP5pUPbbE06/EkkhPOGSalSCeCsARLNSvmtupatiJchfqwjpUQZ63zacDr1kDC7dQzChI/69V05dCrOF2YYU/1SmWZUvOcevMluzTsKoUQ4B4DxV3PK0nuXN07oP+Ns8wGLPUmHGIguZ5YSw" + } + }, + "modulus": { + "/": { + "bytes": "mWvJwnuqVAwDETG2orQL6iW4a/cF5KWD5HdA3iBMoU7m1nscxbalzePs54YZy9WIKLSJSFZAhCST1VIiLa03Q/VStRrKuJema4Ls/BCxOLT1edYYrjJPoDnb/zcEcqfS/Ft0Uk0R8ZZvxnstx8y/wT/PcCGdY81mwORO5J8iGLDvdFJzFaRrMhfXuhakr52KevCXztvUSSHjKp+U7b5mP2H5a6LzrduBVZzD86ifjTx9bFms9WvIfDwOTGQHci4oe27ihqs3LsuBAcV3IvlXYH4YEArKwUh4XxOJJ5/LJb2lrVNOZWV/sNuusMGxzb3DdwrR9gTVMZuguUzys8nz7Q" + } + } + }, + "root": [ + { + "/": { + "bytes": "QDI" + } + }, + [ + [ + [ + { + "/": { + "bytes": "VEAJHjZxrRoB/8mTrX4UuMtnHM+itbCFH1vIWpXbbfAo7xBmlBZrzLJaCzkEQCCkbkj6rrU55B1q71h+sfq38SOllRERe8XmvC5jWngd4IPzzDQ1i57G7pnu7/MNbNU0UWfV74+a2XoS8eLoQv+3mH+1XuBGh14Z7sZgpz3uzMMu3JaAG/tJAK5vwgCM7I2M3a9rungzf0ssumEs1GK+bwDWPLt+Olby9LaR65VFjjXYlPx+wbZUWwohNeDAbLp12+pKBj/l3boO1Qn6HWfq3ntxoXhYZAB+h2GG0Q/1Y+eHdVRV5ZsEZ66em5HjdMdqKlapsTUGe80nV0ZhwyYdQw" + } + }, + [ + { + "/": "bafkr4iariqnpyd7e7cbyjnao6cumagfnogxpcnvvlmuean7ulvni76zmqm" + }, + { + "/": "bafkr4ifolkmx6m5tgmadmeplquvuj6n5436zqwgh4jmrdpzzvcd3nfaynm" + } + ] + ] + ], + [ + [ + { + "/": { + "bytes": "TRAkpJcR25M1t2wCygztw8j2AAbi1ofKdj16AKCNzPrzKPcUml/ImOwJ5vDYZfUylwuELjuC4BK+h6pz4q8eijGB6zGxrwz7e3mmVcsLup+2isXpajWIBIeYDEW9NhPxl6ZE2fuQTTT0lIlhDO/PCdk48nq8kCbkovBarG9my/605H046R6oEvE3tvxGIinEGDEmOJ9Z92bMFsf0Y31f2q8wcZncziecQN0scPYBgEQnbX4FUApdikWD2HLdLSBsq95+G3MCsRNxkVNl20tybP0GdByMkM2q1iaYXQo87AMXmcWWuN3OIEOm+LTdJOlDLb6aw2z7DpjY7siiFbvrYg" + } + }, + [ + { + "/": "bafkr4ienirlkygapnwl3sghfweqvliryz3ljip7xsebi2ojowksg7hkr2a" + }, + { + "/": "bafkr4igujtuwoy7dfdfwyv7izywttixyj5ca2lnzgbjjspx5sds6zs6w2m" + } + ] + ] + ], + [ + [ + { + "/": { + "bytes": "JmHW6pYm05+aa5nfqqVFPsB+bIkFETkbH4jxFFDsz3v0qoaeoql1j7kVZMo+y5q9wr/980bbWTMPuxGOsHvGevz/etbHvT4wIjWYevyiJE4GQyhc+A9MfnzOXzsJYGCg8ykPx//RsE97Tk//uhyOV2DEl0hixOoyS1rqo/p/vQhHsgIMD7mttlALLIrn0hM15aRRJUlTzK7x7zhYeWgVW7SuF5yHkxm3o21oE3C5nKegsFoSdeal7++o+q2PVAgwxfHgwjhSizp7iikTPLDn7ZGkSdRM1BKPSIF17exSBw8rGb5k2QGA7fBrw1+JLmRE0sUd3p9lmT+YgDLPQutxmg" + } + }, + [ + { + "/": "bafkr4ia6aehlkv3fe3tyeqladznq66uaebxilra2jfgr2mai7cb3wimbbm" + } + ] + ] + ], + [ + [ + { + "/": { + "bytes": "ePgCFhgNtSx4LVwRtKr0BQZs2dHAt8c2b9BoCHyat3WmPGYJobH3IO4nesTX/RGMxAuCJBMYW4PkUyc9yFCwq1RlryfD96U9df4WpCY16auNJ8dYOSPCBvPK2B16RVrkKvkSr5M+17molPkeYpSJAmOJGt4HtWSuoiMiAReBnn4pwWcGr/pyGkR48CVM3u06xyYjWGzt2NG2NszHb7O5gdO7G77GiBwtKqsPY7B7TJWoRdUKTf5GBVpaba5z3fXVv+hONvFkN2zQ4GSv7PK7+YkRNt5G9C3LHdoXq7AE2Zsm4ALB8vSKm0tfps49aYbcvfDB4f/x/HWK67Y3NdSdnw" + } + }, + [ + { + "/": "bafkr4ib2p54jvv2bxpo3cp5zxbreqzinyz5ruhr2ssf5db74o27vvb6rwi" + }, + { + "/": "bafkr4idzdwor5tagoubrsjgmoqei45pl3gz77e47wegx47p6k4yeoefhyq" + } + ] + ] + ] + ] + ], + "structure": "hamt", + "version": "0.1.0" + }, + "bytes": "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" + }, + { + "cid": "bafkr4iariqnpyd7e7cbyjnao6cumagfnogxpcnvvlmuean7ulvni76zmqm", + "value": { + "/": { + "bytes": "jY27HPNui8oCbUGk7drT74knk3kJkF7V8mxwpTZIjqCDXI19ejA+KWE0YwdqUJ0NavLJ6OLnuRVZiN2zVGUeQRUpPq1n1Y16g139Gwcr0/V2jGx0grUdiwZEbCSqFO8RblDZcZV35eaS8B4/6jiaa8I+3Mkp9AkY+fXwNMjjC5ICr4OoGN0VI7A+KAEenDpuP91v5R/WnleJ/qDAKWBAfSnBSuJdBO3zaw1AFVwaeDXnRz95SnMFU7hmE38Pa6gNzqFzxLe7BqPgML4lC5QVZPTPjQB7usys2DySyLqchF/X1EwbMXXriSZv6HEVDULQV85NzKDl9s7GTcDDZWtcY+Cbb5yatoxAYe+fkN24XNwQXe6D9i4KP//8gGhtysBnJaaozks+WDp6KMbglgmkq5ECDJviWHfJC/xTBkUhbg94N6yFQeZEQ2K5PfDer3p3S9TYO1IBK2wBnvQQvd8/dEOcHwplKb/dMkz95LgExhu5m7TAoXrBdwVIxJIBT7f8dj6I3l8RlSBVeDpgXMfY1mSjkS/eF26qb1AhD3/Ja5JrxBGVpAu2k1Yek9UZ42PDyUSIJYHr9V3ElLy5jSVf3V8VsZq9DnTbEoNOt5BiVYvyJ4HVozIVJTb4TI8VoPyzbMF5n0SlFPar0CcOru24QjXcKFGtY+P0S2rZzin2ec6Yi3hFSJRbyw" + } + }, + "bytes": "jY27HPNui8oCbUGk7drT74knk3kJkF7V8mxwpTZIjqCDXI19ejA+KWE0YwdqUJ0NavLJ6OLnuRVZiN2zVGUeQRUpPq1n1Y16g139Gwcr0/V2jGx0grUdiwZEbCSqFO8RblDZcZV35eaS8B4/6jiaa8I+3Mkp9AkY+fXwNMjjC5ICr4OoGN0VI7A+KAEenDpuP91v5R/WnleJ/qDAKWBAfSnBSuJdBO3zaw1AFVwaeDXnRz95SnMFU7hmE38Pa6gNzqFzxLe7BqPgML4lC5QVZPTPjQB7usys2DySyLqchF/X1EwbMXXriSZv6HEVDULQV85NzKDl9s7GTcDDZWtcY+Cbb5yatoxAYe+fkN24XNwQXe6D9i4KP//8gGhtysBnJaaozks+WDp6KMbglgmkq5ECDJviWHfJC/xTBkUhbg94N6yFQeZEQ2K5PfDer3p3S9TYO1IBK2wBnvQQvd8/dEOcHwplKb/dMkz95LgExhu5m7TAoXrBdwVIxJIBT7f8dj6I3l8RlSBVeDpgXMfY1mSjkS/eF26qb1AhD3/Ja5JrxBGVpAu2k1Yek9UZ42PDyUSIJYHr9V3ElLy5jSVf3V8VsZq9DnTbEoNOt5BiVYvyJ4HVozIVJTb4TI8VoPyzbMF5n0SlFPar0CcOru24QjXcKFGtY+P0S2rZzin2ec6Yi3hFSJRbyw==" + }, + { + "cid": "bafkr4ifolkmx6m5tgmadmeplquvuj6n5436zqwgh4jmrdpzzvcd3nfaynm", + "value": { + "/": { + "bytes": "Y4zodSij8DA8epzsuk7V/vBVHzr9HHhlUjPVEMYeeYMPkA4GydTcDrhOV77MMg8wlAFxb2/jmRkqrgfkRhrjy531sHolOZ7o7EXrjya6ptXmXR0O5smhfnv4f63nCk9ZeJmlHyYhPuUVuLGp62OkyXzW7LAm+bYW/IXnDctui53Mn82Hck/cHHUXCklxoyQAFvPPHzun5krrWCtvf4pndWOMbEUs/sH8Vw" + } + }, + "bytes": "Y4zodSij8DA8epzsuk7V/vBVHzr9HHhlUjPVEMYeeYMPkA4GydTcDrhOV77MMg8wlAFxb2/jmRkqrgfkRhrjy531sHolOZ7o7EXrjya6ptXmXR0O5smhfnv4f63nCk9ZeJmlHyYhPuUVuLGp62OkyXzW7LAm+bYW/IXnDctui53Mn82Hck/cHHUXCklxoyQAFvPPHzun5krrWCtvf4pndWOMbEUs/sH8Vw==" + }, + { + "cid": "bafkr4ienirlkygapnwl3sghfweqvliryz3ljip7xsebi2ojowksg7hkr2a", "value": { "inumber": { "/": { - "bytes": "0zPuE+juQ9VSNKKbQ+CLCHwFFlbb+I5fEfXzegfeDtc" + "bytes": "GFMkNG0zC5/viOjhdJIVS/w8ISMFLO90PAG33K8hPF8" } }, "name": { "/": { - "bytes": "KIgXpOcthnIqZ2P8yKngSMdwP/CQCCXILxHK7cOYsN9rABXcYXU3XlvP9H69jN7jFRw60e1boXkdEZdqdA/bvCvKQPM0jq36Xct1Cv+AScR0dXb96o3WfUEQYdkD1dYGYD6qGUWH8lxn1nIcBjxwFuvEbCTZCrgg7Gk6yp1iPJ4UXVvOXppyqb+285ZYSdineLavZedj5atCdREy88RJ6V5lKkt4xsUoNBQPMc+i8BYWNUAwKoMpMNnR+3+U7Q4YhLjZSiZolWCnhIARfvtwgJUI25s3gCH5p69Qxpjz/Frd18ihov333N3BFyUzoP5M+8QExJy/BiDu1xJAC/2Xpg" + "bytes": "YYged5yfTUvukA6Igm4LJvi1QdfAFL6rmt6OjbSnm0c9gIFQc+ayqL5ZKuXo8s/uka52sObCFFI39D1SexJKvM5Avt0YTgtRIB04JgQ+TJqe6KsgHXUXE+CIfvGWZq5ySlmCkn6WU4EZ7Nv8P8o0zUrpveFMM32zUFyBhZwMRDD0AUcGnI8UYTc7kqWODFo2a9FFWAc9imbI6ywZukHu7/u6Tt7PxOwF/Bp4wLHLfa90ZZ6UcCayz3DbJqqTXVVakObCheXVQ6MEKmpFlNYbXzkTm7TUhc3EJ1+WXLd96lvnnuhP+Zy6Vo64RnI6JjyQH7M4ln3yc2O92Qt6h17S1g" } }, "ratchet": { "large": { "/": { - "bytes": "Vb1tWV9AhqWIYE1ICnHiWANgCwFwKKRuMUIP0OnP0pc" + "bytes": "DHT6+9qQ1z3H5YIAYJWRyiuWTJ2Fawa9cSd4WbJskqY" } }, "medium": { "/": { - "bytes": "DuTEIA4KyE7IfgNvlKxIS7sCpQoab6QToceNd3qnFKo" + "bytes": "oMjrCrGbBq9hrEhSpPa7wOaVR912bDWsgKYExTG50JE" } }, - "mediumCounter": 26, + "mediumCounter": 124, "salt": { "/": { - "bytes": "SYZOkP3tc7/xlW1UPTvOJNRpGQEc6Cw+GBtGOMWUuqM" + "bytes": "07rvJ/l9/D/jZTCYmQDIgs36puSrnUzl7eSElSSdt4M" } }, "small": { "/": { - "bytes": "qp6S8dJY5yA23lcZgxPM7uwGGbAjya4b6EXHuAUlDgk" - } - }, - "smallCounter": 139 - } - }, - "bytes": "yasBVsw4nFEG4bbw1Mcoh0kvcZGKfCEcPvMXscVHgdUpZYoRpoc4s8gUPYNN9A02UhLEV4gVNnIAbwCrxMNPUNxscUJ3a1V1zeK2+71XTraSbdedAujf8jlDeHv+1lhqk/OxvUjJqiDGcMGkV4/xyeu/4fhlQ0dQ2Fw5odBmsEaFHk+w2LBRfWB+C7hqSoi6s95B5zGl4ZFPBWmLpHj9a3AkTsHEE1wBi19ho59tDlgOtv/d1lpGJMsqOMf0go8F1N4Zy4Ru8l7Oh2hPdGZ8yyJCwHlUsgtt7p1kXNqmbR3Sv6rJ8OK8oq6EANOXTGwsi0WpQcu7y9uqDzfbwg+sxFRnWm3ZxQUrCz6S3gRRTOtZKs+WgALrpOyct89qYcnSNGZ8JKLYcd9gW2RzoywgU8hLlBn1Zs/+y5hRjyjgZqNR0qHPabuA3gkG5YiTu9EabEbvQEgw+ZW/N67VNgmJDx0tlSM61/0q9+mih2ByZoBKGb9DvmN0YXXMsWx48SkZx87wRM9RavBorFBrHv4EjS19kTwoBAeKDFpW520Q8uEXnhGIrCd9eZ9q4NG/yZzN+pAUJj+lMZI3J5KA1DfTpaXjCcR/D6xDHD7RuuEgGDjHmWyGR2S1ZZc9K3vWctCgvCCmxGHEUooLxKkg/1PZE7Q9W0SACT4xCD17tgm0V8EP6DSsGlKx0w==" - }, - "bafkr4id7tonzrr3j5f33erkpudqpnx3o5qb3g2wq2nn3y6e6sbx22uoaaq": { - "value": { - "wnfs/priv/dir": { - "entries": { - "videos": { - "contentCid": { - "/": "bafkr4ieddzi7h76vmyg2uwbwezs3tkoir3kpqi2medlkarebbfcyuyjj5i" - }, - "label": { - "/": { - "bytes": "/utq/bjqBVKjDOyd4uoJYyiJUi+9udotQlWu1llBkvE" - } - }, - "snapshotKey": { - "/": { - "bytes": "VLvB1/9ylAKfYDf0mHbyi9z4Lqm1ZccFZkDrAFvXsqE" - } - }, - "temporalKey": { - "/": { - "bytes": "nTHPSaNnSW4u+wFakpIA4mlJmFjXbdmiLAzKn+DqVkWbjzg0qqMPHw" - } - } + "bytes": "gKe1aAXWaK7CiWvt1+O92sF+BqIN9Tz6xHYsKqt0x1k" } }, - "headerCid": { - "/": "bafkr4igjtsmaelhxa6jhlzzaane5zae47ytyvrsr2vufk3fkvrtyd7k6vy" - }, - "metadata": { - "created": 0, - "modified": 0 - }, - "previous": [ - [ - 1, - { - "/": { - "bytes": "DU8Yzdq8psunbnnZiDkfxUrSu/AlD7uSMzip0WbZQ0fWluAN6+N4XoojU6cl/qhJ2mp2J4ruWFc" - } - } - ] - ], - "version": "1.0.0" - } - }, - "bytes": "6isyNxx0srLIYzICld/UOoGiOZiAmQpJ6Dto2pz79VKRKVfYs++1t5DD2/qGiqpXFzewaV7rn2Iox7yrIs6PVgLkITyHHSguv/A/JLZpUpsRKZISZKNcN0ddAmWlZsKh4b9xXMZSnWw1krvuJKeagjLob+X5UxO1NyDCXg9EpL22vpf+jLXTS/clyjj2EsPmSrgXkoMoI/viZnrI1Fo977Wj15HT+2Ync60N4lliBy1gaR4UFQ9WR8mI2EgyH7T7vTC3dok+vLS+AgsQ7z6imRMOVolXKBE/JsNSknhF0ga+VeeD4i1uijR6sLG7FZ3vftf+j6hAATvcuziwH5uniuGuwyVmuJlDTdhWybuodGdaap0/qMQsR7eQ8WZRKBO3hWJWni8cdJadbtz0TvwQmDKEK/8Q/9/X741Sd/dY8DL5vmdyEcAgjwRXg64VUZOBx1fSlpxG2vTAeVl7EXSrkEjhGMsOwiRdzjqKcUpTMbI2/B+XTvVf3HzP+vQoAUesLy8cR5TgB6N/f1dmcmEpL31aQvuilI8UfruHaECD+kpGb9rXo6XW1RUKLEjL" - }, - "bafkr4iebdj4gxv437oi4fzjkbrkttr264sx2z6aya4yxiok7c2ffcbzrx4": { - "value": { - "/": { - "bytes": "KureFvu0kYp5e6Es9dauanzuUZVOnWFnWrXiDSrMN67FsZndLhfNsXRhGwwM8iUVm7sSAWvdMUkegIuRHDVvwhSrnZLONfSVljQ6XZOzpRBOLON+flwuHQXcTnXx75SMkNhMw0BIWxgEG3p/FbpnWsluuG5GQq/hY+rH51T/FLNOe/gO2RzAftu2z7rY97ftW87oANjNihypykS3ZmCq91T78Cu457MQDw" + "smallCounter": 153 } }, - "bytes": "KureFvu0kYp5e6Es9dauanzuUZVOnWFnWrXiDSrMN67FsZndLhfNsXRhGwwM8iUVm7sSAWvdMUkegIuRHDVvwhSrnZLONfSVljQ6XZOzpRBOLON+flwuHQXcTnXx75SMkNhMw0BIWxgEG3p/FbpnWsluuG5GQq/hY+rH51T/FLNOe/gO2RzAftu2z7rY97ftW87oANjNihypykS3ZmCq91T78Cu457MQDw==" + "bytes": "MBCyzB+5fh+QOIE5bqmWzf/Net/g5PTKHatf0uABkBepce+7JmPMAK82OtiSvSYHYnECeLpFF3pNfl8Md3Ta1QtOszNBrf997XgYoMIA8a5Yq6oXKpKS2lKpoGnGXvkJT+7U817d40YHu5RgSW04PtVYvIPjWHepB7JJ5PJ3ynh2zx6kYh+4oW4qCi8IVpR0EAK/xCK2UK3J7RwAIBMaW7JchQm3w+FfxrTCFD5Q59uUduWTPaFs3nkSY8MijO24guC31k74GuNdr2yjXZhwbcZhHKxPTUSSriWABNEt85GhRMldLSFC/q/LS3/V9VqdlK8FV6qfeVFqpe2z+oMkDlOaz3zWc0tR4VQyQ92s7hh5RqBDs5x6fMvLczCQRAQfm7PoEyUU3ER52cuuC7PzLJSp1gOAelNapfWrMqZP/4JYB2K2IipJqqPXfXGtLF31r/MS8El3K9kl1CSbalRmRmdcbBoUmIJmnkLMTkGFiZSmMGrRWicZgGMY/UJPoJF0rKdXJL9+lXn0941i/9dM/dhaOiJI5vJKdv2C0OPWB38xbt3uwqOKn6IhZSDUkSzrlSvdh6svojvqxvgBTQANTn5hLC9+712fruLZ3xQE2G6luj7Z0OkUxyfdg1LMq3Q/bmfvtyCRQJv/M0nCcLRcGoGB6Ukaqb7b1LjaE3aHpZBo4dCmE39ivQ==" }, - "bafkr4ieddzi7h76vmyg2uwbwezs3tkoir3kpqi2medlkarebbfcyuyjj5i": { + { + "cid": "bafkr4igujtuwoy7dfdfwyv7izywttixyj5ca2lnzgbjjspx5sds6zs6w2m", "value": { "wnfs/priv/file": { "content": { "external": { "baseName": { "/": { - "bytes": "DUUMhrPcVxAOHt2QgZNZz2qYQk5ni08z/fRelGwDBGzh+tmTfwKZgAki047508dETfAOpwbi/cv9zJEvZPW1HBI7kYimDMkQy4y0s5O9Xtzn6rP6Ei2Cd4Wmiz/NWJj31ZyylIYa9ualtbSfRVdi/mSjZvHYB+DjBhfSCDx8G6wk+cKnYE0uxhLRDaXKnkm1GG0nrtlg6URTnEfYKWAidkat6zEAPlZENHPoYIFuWHEBB5iQ7a0LJ8KPcOCoaBOvY+NXeGqGS79yA2dADvUZ7xAaaAc3yNB2fKX0hE8JjQXJJ0Uz0YeD81Kx1gzzoSNtiZMydTzl7a5zxv9GxjykwQ" + "bytes": "hNDkU/HKn8pujw5HfKcBAuyx1r4wnvl0I9BgVr3hVQ+P69Cr4r8fIdMmGUId2cyVOWLZDh90HMkTeVWjbSypm8OhX+CEH4C9Ka/7G66hiZ87I6PxifVpZFwz1+ZpiS3YddG6aGwG32OxsnK+9FQd7Tdrp7orAQfSmgxC4ByUcpKGdjC/0RwUozX4S26qGl41cyXTZ/xzlkekdeAV2f6KWcp8Hw5UKtuMczYRsRhWSUvBAC2sT3A8uqy4INqoptDn4oCzjWGdzfszG12aFIKZuVE5ruXHOy2Zx0+zu7SqBbzYN3NLkog3orlPb+FRrXqIzUmiUqTA60Rphip3M0gkwA" } }, "blockContentSize": 262104, "blockCount": 1, "key": { "/": { - "bytes": "jPTfK7QN20PpuP+PiA/Xx7ByqHW6bYcq7O/3vwNXMC4" + "bytes": "VgFiuyjwLxAVo9zsONyk/HNTWymLC4A3B37cb+IrIPo" } } } }, "headerCid": { - "/": "bafkr4ia5qq2otfmijhh2z7dflkcy3vjb57x4wwghefugom3wzurkpzzzei" + "/": "bafkr4ienirlkygapnwl3sghfweqvliryz3ljip7xsebi2ojowksg7hkr2a" }, "metadata": { "created": 0, @@ -127,183 +186,103 @@ expression: values "version": "1.0.0" } }, - "bytes": "mSnOvap3kHBnNt95vtCKWncBu/HIGmawJhKrcM5Zozbld+VdONjH4NDq8Js19zHjyLFEA33Wg27IFR4wiJvIJWuFnda4bvm8U1kOb/zjdbvNz+eSrC5gy6s4PAo4tNcARkTWIz7nWRqjKlF2ZonbOMtBRfTZufHSBGyPkpW14kPIyuBMWV35riWwpqvQIc6HObDNHZZWdh+iJtNwrHBhldql6mrubij2dURLHoZlZqm2DdZX43nU2DTYLjJtX5cBQu83NzhsdHfANha5aX2sRldjxVUdLD9u5tdsvL9WY+XyWYlM0DDrYKjewwCny0oW1qH++u1IbT3qKbHQ/8YyQ5RephmYKYJRYk2Otimas2tieNpvMngfRd2xDpiBbmLrX7KalxhB0tXXxo3CGB9py6HUJSZkHpdMC/VMcV/pfjviVZYD7MQ/i24X6S3Y29ib2Ma0DfbTEnSgEuTXL8uTz4PyJVKdOljDGhNrVxCddt/viV4SybjHjjIg3i1nIdvmsrzLKz5AAtL/E4G4odbT6g/b4Exz9UWPgLFkw2tRYdiS79dkKou7s7zreqPIWczIYI5v+ldWvR1OKKDuiThkRuy5JOLI2Ugt93HS0doLkzI1h7Csp667boeRTnrDaxnoeD5jR/A4ZN4d5572XA/+kFpmzDbKJNIUalxQehq7lmgcKxxsHQXu5g==" + "bytes": "l+qS0TqCuBHj/R3bKGE/nq2YabOS+h+dhF5XqTCHDolfBEFrOhsXkGHmPgt75jemuQIAoElYcMBBMA2Qb/0gaPgIXMzkw4lhBm1OivyvX4zl1XelII+QVrVk701SFnMO8fMlNiohneI5D4S0sW1utyKYeJRRSjCIefCx5hbRERoAZ6Op2Z5xO8reweGkpQlmYK6jg54DsEAiJDEU1C1uznMQdc/r0maNOvJMReha4UoA3MrYaZesz+CN+cTpLD6DWWiuaTSdzlwovNEq+nRHN4dAzdUi86lmRhc2JrqmqoGwStrzsRbQT3UsxAAZMLa8M8S5LyufyhKR3+ViNcFBFlHtCXJfaaO1lMZRSwLeVeXfycYBnVLQDOUoj4/ILwBFq6ot/tJgHyqIAST3NVYYhu4bKeezsOTgWkbOEWYwRV6Tke9BreSrJMYWTgkXqZ+73quknRVkdLfsbj7TZChfECqGUnyN0jH5c30VTv9vNj0u2zi3vd604eKl6uFgXwyEQadC0xCW5K+z3OoKiRB+XnmWJXEXNB5OI+2gPGfFbDuHU8gE7IIfP4pdgv1QP4BKQyBdXPxR+oEQk+ovhd43vm1mOISXNlWSUK/XdRNfX6lNRTivhaI8yqfdVraNYz/jIjLhvp+UOw5k3a4Cb5J0w8UxOlJOJQ/GK3LbJm492XofORvDgRd7dQ==" + }, + { + "cid": "bafkr4ia6aehlkv3fe3tyeqladznq66uaebxilra2jfgr2mai7cb3wimbbm", + "value": { + "/": { + "bytes": "aGVsbG8gd29ybGQ" + } + }, + "bytes": "cswLTO6Y3eqloGJjETVdrZRpDmEQrtgDhDjqmfEzoUGMuPgNRRziUmbll/NejAX9EL7r" }, - "bafkr4igjtsmaelhxa6jhlzzaane5zae47ytyvrsr2vufk3fkvrtyd7k6vy": { + { + "cid": "bafkr4ib2p54jvv2bxpo3cp5zxbreqzinyz5ruhr2ssf5db74o27vvb6rwi", "value": { "inumber": { "/": { - "bytes": "+TSv2jieheAn4mBV6tSQfS4IZuigGiXQeCQNRn2Zc2k" + "bytes": "BoN1qGYHdYlEkw+RiyTTdczVzcOJ4jysJ7ZKPATyUFs" } }, "name": { "/": { - "bytes": "dobIKL6WvlAGN4ZEQRtRphUMtQSIlLQTc2lxc2Je7kKkNq9ooldHWcd1NG55AEAWqCOGbH+Vf3AgX6hNtrutFa6e7KJ/rSF4pTS7uuk6r2G/zOQ1leVnIvVeW+CYE3lcWNPB1yA6WSbMgfia8UIS46rgtOrfsYkMSdRxpkltthEiWmyQ7ahaWZaRXelLksMTYfwLVks+XI+WqG4Bzinvr9cV8eE7uGtIFeK7n2IGyfEv8fpE4jyjlNc51A+j85+VAT21EvT4DNaQwLVQ5PYdSZ/7qHvJOJzDCiluIcmX6TKsQ+XHqNzI4f0oJdzYFCKBG+C5Tjte9T0JyEABfxdvjg" + "bytes": "UxI9IKZpzhgA2jMAOdrLG64FHRlxy0YJdH7fX+SS13xpdzLQHftARaK5qAkxflHKHa0Ch/dGqmRwiDM5aK21nux6ha4vAlg6UpzbZpQWVS3mlBPA/eqBfjwHN5Uf0QOW66eSpnjV+guIE+wigxZJYllzSp65EeR0XlRmXn7pMbo87Q8pxGX+r8zM7x5BIcIA9FU28n2RBYpOMWeH6qwZ8K/CJ51j0FuE6eSyXW8SFSj5WDd38OMsM+W4Pg1X1PfVayXFzPBqhPUXF2LPU1NkjgeJPqzdPX3D7mL3RuGTFU2FE6ifn+cZRh8iby3l6bK7/vH5iw2C6sF+lO5fdgV77w" } }, "ratchet": { "large": { "/": { - "bytes": "9ywQE1NYvFOxpnkYyimeZLlHdo/JPfhWQ8ARmvR7f+I" + "bytes": "666g96bE4qyOoxxUywVa7Q/epb3Wp1aXaEo2kszzeaU" } }, "medium": { "/": { - "bytes": "yvO1gGRmolMO5jeGE7tjY26HiIbjJe8zu8b6OHf9Xio" + "bytes": "bz3wwx+gSuhInYJgnwfQJIlzeJZ3Q1fm9CSlJtAUQtg" } }, - "mediumCounter": 20, + "mediumCounter": 154, "salt": { "/": { - "bytes": "J6dQrLG9Do1fdEEl6bBBBp3gASVKF4GyoRoIkB5mT2g" + "bytes": "vEAU2QYIxP/ZnOkdA+IXGbGjAknK435hCXeEqKUiJgk" } }, "small": { "/": { - "bytes": "blxep4f4qhR48Wqyr7uuGQh7cdqdWtXm2cjXLef36GY" + "bytes": "r7c1yehJQZypOvqs3sh4zGZvYPqoZCEud+jzi78rTxQ" } }, - "smallCounter": 40 - } - }, - "bytes": "/KVWZ/d0jJGnaHzYuseY8Kxdt/qq5iUDG3U/qhbeNx4GT8aL+JWN4/pzcQSfDp4NftdI9gmfuI26xzVcnEbDRSgHCqEHi47gkXcu8qL5cBI8NNpihw3q/T+AN4flMHztDE1SKNqS345MZW30BdFkG3dUI/hiOMgr/fQx/GYa6KDXhY5R/1Z7/IJ7Kxl7rW4g/JGCJuqQDVC489NDQQzwe0Vq4yXQnXYpxcFh469n1NokLfmnNy+lDoeVl9b2OU013jIQhY3Ghyg31ZhS6R1OQap0Z+sghlOUqF35mXg4wLCnp9IyxUcz0xzrjQl/jQdLEuqGlVgTyWkViTAHWysqDKbKR52UgZ0RIxjW6JwACHmJqc9m0OspjrZnMWeXJ1ypFNq4QgSog0MQBf+/Xyt1nH8dwVbbtvDRZXDopnoMdswC0DplhlKWW3/1X2BnmzEcGYCJ6m5NP1CjfG7yvDv7Y+OCGLOCeekYLyDswW+H/GbAHUbCRDyUsZVmCV871qN9Ez/EGlN15u22setZdcOjq6aj3sbvm1Gi9SmnRIIYpalKUWzImtaU2LMgX23Fia4enAhBO530eC89W3PMVrdoRPetjIFwJQCL9lAmCbIuvANhgnhwWjGV8LuAGU+fwL1a6kxhey3uEarwAFSmUKtqpN7Q2oaZh2+e3ar0YZvDSPtA1FfEU7zB7g==" - }, - "bafkr4ihchxthsvjbnmwsdk5pt5ukhk7g3iz6gmbtptamhcwuzpekgckboy": { - "value": { - "/": { - "bytes": "CaIElIejgMlk+GUpLGC40Qd1Zp+ulPs5UR5/75gWam2YgGXr8r2h26Vslc51CGqVQsBfqV3npthQgpqRr55bzU4UpZ22Q9Z6dV4W/5eTatTGjFYXXEbraleqK7NhRes3db42xjpvf019sdcLzXZd2tci9pDu2/N91NDJ1jtLJ8CimeEUvbs7B/Fy7JibFeMaAKa3z/aQMZrPgzVQWQjBbQeCyu+eNOCmiGr20bxtOG+YnQKHocG+3U1MA3tJ7v64IMO9n5AlZaZxJX0CzyGuaxtHHAQP8QY+EK+/a+RzuiUCQKfSJXDJHXj/qg19nmxuZ1mkSZ13ifhZAwJ0bB6zgljqpJ73FxupiejSYcNyKjOq1529Miy4Vtwj28iBtSR9Vq2W3x7t9GGXrNBEPTjIFO9+y4XTlOqqnp5T19fNDPGeApJ8C9rolO55gXa/OVPF2LtOUR4gN2s0P41Pe2damDx90CbT9e6QEZO4UWdsVznszC2QOAT3e0EeSd0T1ADNqv5hJU4WGyEc7hSgFvnIMWnKTcmnCEp8NOfJvs8JFtvl+oS9VK1pu3RVBWLiK+Ocan9lXZB9SKzgr5oj+g4LlxSr4LTfv+xmsqOlGTMH7RE1vLOaN/+4imqI9VXQygayQE6rxLY3lERcaIdp2qatXYHYUtjf8dmZjgHGCnE1Xfv2+SE2RRsxZw" - } - }, - "bytes": "CaIElIejgMlk+GUpLGC40Qd1Zp+ulPs5UR5/75gWam2YgGXr8r2h26Vslc51CGqVQsBfqV3npthQgpqRr55bzU4UpZ22Q9Z6dV4W/5eTatTGjFYXXEbraleqK7NhRes3db42xjpvf019sdcLzXZd2tci9pDu2/N91NDJ1jtLJ8CimeEUvbs7B/Fy7JibFeMaAKa3z/aQMZrPgzVQWQjBbQeCyu+eNOCmiGr20bxtOG+YnQKHocG+3U1MA3tJ7v64IMO9n5AlZaZxJX0CzyGuaxtHHAQP8QY+EK+/a+RzuiUCQKfSJXDJHXj/qg19nmxuZ1mkSZ13ifhZAwJ0bB6zgljqpJ73FxupiejSYcNyKjOq1529Miy4Vtwj28iBtSR9Vq2W3x7t9GGXrNBEPTjIFO9+y4XTlOqqnp5T19fNDPGeApJ8C9rolO55gXa/OVPF2LtOUR4gN2s0P41Pe2damDx90CbT9e6QEZO4UWdsVznszC2QOAT3e0EeSd0T1ADNqv5hJU4WGyEc7hSgFvnIMWnKTcmnCEp8NOfJvs8JFtvl+oS9VK1pu3RVBWLiK+Ocan9lXZB9SKzgr5oj+g4LlxSr4LTfv+xmsqOlGTMH7RE1vLOaN/+4imqI9VXQygayQE6rxLY3lERcaIdp2qatXYHYUtjf8dmZjgHGCnE1Xfv2+SE2RRsxZw==" - }, - "bafkr4ihicyuqqoaiorr2ger3323vm6lprkxfeubscfpozezepvfmnq7dri": { - "value": { - "/": { - "bytes": "aGVsbG8gd29ybGQ" + "smallCounter": 51 } }, - "bytes": "JtzBivNEvSIfnxKEEOl2Hi7pfMQAvf0HY3HYYF58iFHxFuoe3pCvJlRsRag9snel5oCR" - }, - "bafyr4idgh4ldbfxqjlmxgco772vow7ady4hxgq2t6vpypczkb3m6nexvrq": { - "value": { - "exchange": { - "/": "bafyr4ih3k2ipwwqryrlmtmwtolma4t772gknmx7pxqu5opjwsrr2nc27qq" - }, - "forest": { - "/": "bafyr4idoqvkdibijvfvmq4kjcdawhytpqerhogq7tnf6m5f6w3csv2lq7i" - }, - "public": { - "/": "bafyr4ih3k2ipwwqryrlmtmwtolma4t772gknmx7pxqu5opjwsrr2nc27qq" - }, - "version": "1.0.0" - }, - "bytes": "pGZmb3Jlc3TYKlglAAFxHiBuhVQ0BQmpashxSRDBY+JvgSJ3Gh+bS+Z0vrbFKulw+mZwdWJsaWPYKlglAAFxHiD7VpD7WhHEVsmy03LYDk//0ZTWX++8Kdc9NpRjpotfhGd2ZXJzaW9uZTEuMC4waGV4Y2hhbmdl2CpYJQABcR4g+1aQ+1oRxFbJstNy2A5P/9GU1l/vvCnXPTaUY6aLX4Q=" + "bytes": "LVULMQysvfjOGXf9UwRWPvIjKUGQP8uULdhZltI7eansOrY2KIgQbfJIFa5xv7bu6EDAZ3PHxKPIwZsjKqS9qXiECOmwPkGX/KLYffAJq9U2+IryKb7rSSieLhguHRfIcPjVZkgySK7TtJPXs83js9vsLeZaphSOGdSfBUp2rIVG+maHlrLaVh801ic6NpnSi4HwILb9D//yZFHLIM6xLaYH/oStyywk2FecY0YH2tHVg6MBzyJUe8RvfXHp7xoAIIZJ64JpvHvCyjh/sxnvGCaMCfJwXoJUHf3qkkw8EYHSdIRiA5sTQA3MLr+q3phWUZMKP9Wlzau7BhYZCpIGBjnzYa8Z4zO2y7YX7f/P0+wH5yMOx5uHl5rO1xCzyVJd1tRENjnzKQ9JqFRC1v4F3ONrUeO5ZJfnm3BiB9n7XE00K89DxyeV4tzIMKPu8H/L8LbHGJZ9hxY/XEjEA2JPIDL6tUCLozXCx7KiJFyS41HobN78kUcd1433nGgJHWEnJKpOmTVU0tkQAN8N2Qensy5ENfNHDdNDZsPn3Zly2pzLmXt6PbklFFh/ODc3tBDnEvT0FUGjH7j0GUvUuRjxBAk4s7ANeoguWv8Ac7G9twnMQBktbQoXMhQNif0IKMTXQdtsw1ax4e05wEtRGQcbu+vHikUw3A3e71Pd6gsFGfTAn/CkqNTswA==" }, - "bafyr4idoqvkdibijvfvmq4kjcdawhytpqerhogq7tnf6m5f6w3csv2lq7i": { + { + "cid": "bafkr4idzdwor5tagoubrsjgmoqei45pl3gz77e47wegx47p6k4yeoefhyq", "value": { - "accumulator": { - "generator": { - "/": { - "bytes": "SxhAYVIS6TcgcK8rZ2LEY9siAPMu12U94+xW09MjqxR22cX+Jb2eeq3ykgWbIo+buUs0tfCxU7TiuFZo6oP5H+7DPbR1vkPAntUel8GJVL97bl2CYlK0UNfkhxGR0jfrbNAkhYCc1A0M4aR6IUCZhMxDhSMKtXnPSd8us+pTpyTuL+SoxAdj+hU8mcsbPg85CPHx/y5H/BFfWjb5BPLtaR2jN4hnOC4kcMkuxa/akWJk4zrPWKPWrX8XvfjkwTyixE5G21eG7c5h99FglAb0glDVptIbaULH2aDkuQnbqp8G6ZPuZvQrT3iOXZxRbj+O3hKOET631tQFVr66eR9ayQ" + "wnfs/priv/dir": { + "entries": { + "videos": { + "contentCid": { + "/": "bafkr4igujtuwoy7dfdfwyv7izywttixyj5ca2lnzgbjjspx5sds6zs6w2m" + }, + "label": { + "/": { + "bytes": "mHNzb3ThL9fcezvNcPrUEAjmd9fmzy05clIrQ9qeQDc" + } + }, + "snapshotKey": { + "/": { + "bytes": "5mrHzS9XJ7JY789rEKALx03jXXWwLZKgiXWfCqIcG+0" + } + }, + "temporalKey": { + "/": { + "bytes": "fP0Fyq2RByxJiVBVWdRW9F9w6jTRyoAMUxO0x2lRXAu7g4m2eBH8NQ" + } + } } }, - "modulus": { - "/": { - "bytes": "tfJY9Ns02diq4Acy25Bps3PVn1BcdwzIwM/p2D8axaFaUKZNoFepJLk0spm3XlPcQxPoJhn5Fl8Z9+7Ldb3nz5WrgGykTaRWBdRfw6frLPJA1KCVZ6svaaavJJw8bADgbgZJR5UjWbSORMbsQzeaO9EO5zkxO/Bz9C6hYoK+sSB9WPUd9ecRT9OEVVdzZLrs2wmDYwB9UD/Cn8gdK1gxLoFggxVNTxJVHlOcGJ8yOxAVpKmj8eHjqVMSVIYZQcZPKAppESw6yfFwZ8m0obszFtQDMEukgHEe/sUfktjYnqJEaFN/5U6DOuHCuPPXwRSZj+bbDAkr/Z583TJOWGJR2Q" - } - } - }, - "root": [ - { - "/": { - "bytes": "NIA" - } + "headerCid": { + "/": "bafkr4ib2p54jvv2bxpo3cp5zxbreqzinyz5ruhr2ssf5db74o27vvb6rwi" }, - [ - [ - [ - { - "/": { - "bytes": "PfjGTXoUJKdi2jSyFoPY3aAlEqiVi+BwqYSLe+DxQPCgVwxdSTUZQv6nVJtt/NRb/+nT9UbXQfOY3qHpCyiWQW6DkHBof89sLi855MPr/mA/ZIjcv956Xu1TRnKhJ2axp6pAqrBHPLUexrcN2QAAT7YgzM7pDUW5OYQNm9HrBrqeB54fUSDpgnhGtHTSVRELkBgskdD4tCGBB6ccpIMm4c124VeZXF5uZhey71WtENhAGNIA8jF4GRwPdblzLACmsga5BBiYT3pABcIDe2pcWWcRVxxm2XrT1+wBvkK33wqUQVOOg23t109ZHVwl/RFHWNoGn9Gp4iTz2fqTgZwpSg" - } - }, - [ - { - "/": "bafkr4iebdj4gxv437oi4fzjkbrkttr264sx2z6aya4yxiok7c2ffcbzrx4" - }, - { - "/": "bafkr4ihchxthsvjbnmwsdk5pt5ukhk7g3iz6gmbtptamhcwuzpekgckboy" - } - ] - ] - ], - [ - [ - { - "/": { - "bytes": "oFRKVnLhRiA24SFH9unmkPw401RB+tRYqW+c5JRg8x2SYVbhjrCKfXmG8tM5x8b3Vp6BBuWnXHO9a6UZ+/HVmgMzT1VB1lA0fViuHXBPQafHetehZLOUP9jgSyvjgC11fFU+tgSA4Nax0TCuRYt664sL2OfoSBAe56iSEZMJxmdRy23+xzTpHWic6e8qJUW5OCoYQWtwA8CwcY5BOo0H9gcJ9jfoOuQPbeRISGJ4lA085VSPQCxd9stHioUcDRsYW0YDuYaxV0ax9Qr3316fDJ/Ynbpi81bo+5dKPwqmJ8IupcCy9eBOQS9NatFCpBA+KxmQWwuQ9cV2S13VsJUxKQ" - } - }, - [ - { - "/": "bafkr4id7tonzrr3j5f33erkpudqpnx3o5qb3g2wq2nn3y6e6sbx22uoaaq" - }, - { - "/": "bafkr4igjtsmaelhxa6jhlzzaane5zae47ytyvrsr2vufk3fkvrtyd7k6vy" - } - ] - ] - ], - [ - [ - { - "/": { - "bytes": "Qr2ZI+cZd1gPOv4QpAslhNanVZITJ5N+oAkmtxtySyaVupeWsTxYSRiwelVDJEnGDkO/1Iu8WzI/a6lL3lfOImC3ZaSlDBAIHOHZdeh7T74pty233wR8V2CL0X/JG78YGECKczEaCcY/oc3K+nYgna6tx9cRe03aE9XP/SnoKGRvYpS34lNec6fg0jAA0t4JqZM1BJe9y4/pnhEtxd07sCIBbvJIYOThLOIgvkbPj3uKhUYiiZNBhsydl/klMo4XhuksW87bkjjYFwnUnVDzO2M3K8J2EMdMzyu5lsmvlMT8Xd/FB5jJK2LGSb1ShMANhsSiIyJwPTADKBdzCioUbQ" - } - }, - [ - { - "/": "bafkr4ihicyuqqoaiorr2ger3323vm6lprkxfeubscfpozezepvfmnq7dri" - } - ] - ] - ], - [ - [ - { - "/": { - "bytes": "mDoQjcWDa6hu3spPu3D/NOaRiXNA8z/CPHQsMn6n25dX+NnA22uDihzaPfWk+pgk6pxp1XMZ8ewttANgcnWvdhhLnyIkZe0614UmFXPFw8A4ywObAUYjCGbNJb+/Py9N+qqYg1/XTh5Ci50qkCWb1B4YnOxAkUOTA0GYpHRcLbXwL61kkuMnv1N5S0VYJfq3Bu/tvJun3nsOgtJx0yPxo5k1fRwzVluE9vuXlKOIXIkCLdlrCVtXMWReTS940PMONioT4MuColdghYRBY9c3ABZGzN9BqoVyY2B/7vH+K9KKQ5I3h5B3kkBBTPaa5aFwYM1uFUL+1lQrpaFgFK0dRg" - } - }, - [ - { - "/": "bafkr4ia5qq2otfmijhh2z7dflkcy3vjb57x4wwghefugom3wzurkpzzzei" - }, - { - "/": "bafkr4ieddzi7h76vmyg2uwbwezs3tkoir3kpqi2medlkarebbfcyuyjj5i" - } - ] - ] - ] - ] - ], - "structure": "hamt", - "version": "0.1.0" - }, - "bytes": "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" - }, - "bafyr4ih3k2ipwwqryrlmtmwtolma4t772gknmx7pxqu5opjwsrr2nc27qq": { - "value": { - "wnfs/pub/dir": { "metadata": { "created": 0, "modified": 0 }, - "previous": [], - "userland": {}, + "previous": [ + [ + 1, + { + "/": { + "bytes": "RplBHdBsKUICnZekEjRhbwkFd/CE58AZ53QWqhP2/fYlafOTs/DFXIvYjD+YEFV+T7/1F+gvctc" + } + } + ] + ], "version": "1.0.0" } }, - "bytes": "oWx3bmZzL3B1Yi9kaXKkZ3ZlcnNpb25lMS4wLjBobWV0YWRhdGGiZ2NyZWF0ZWQAaG1vZGlmaWVkAGhwcmV2aW91c4BodXNlcmxhbmSg" + "bytes": "kb7xq2JWBcloxy9TEqx3qo6JWN3bqJsVZp6Wdos3zPRzgB2kG8mjI3LbwdRXxhc34/csiusA+GbCCTFaJOTnzJTDuda4OC/du+rn/GTg9oL1eXZqn7ldoS+KRxFVzcxFLJ0elDRbGqIUGyN8YXsChTwt7E3GLm3xg1L7QldPnCdUv9dNUkc9rTPknl7pLdIkw57KY2dDnKsPugNBLjlwgRbdCyHnyFs0hetZ28ZzSphvYFIViAHbjQ5x1I8/lIhSyPcFqftkp0KvahxW315UDVRZy72N+OZwEZni4/ne9IPeUQKX7r38ynXCrzDDa64f0A6YvR7aPNG7AfwcCvrTg2zKKXsPvGhEd/TXtFV3laSrt3kYnkLy2L4ZmL/qa+mjJU8ygNrAM+d7C4LzYbekbkFdb4GXbUwwmnkZOxFD0shwvvDblvV5pWuPpQy7SsVg8/N9luv6CgyBaObn+24avDGV2haoVHd5+ULuSkJfX004wBCPmJLVAFxpf46+yracTIRYAiLN5znbx8Xhgf9+msr/4f4hODMftNEV5XbjBxq7zMHzQSlL3rG4ERB8" } -} +]