tc-chain 0.5.0

TinyChain's BlockChain and SyncChain data structures
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use std::fmt;

use freqfs::FileSave;
use futures::TryFutureExt;
use safecast::TryCastFrom;

use tc_collection::{Collection, CollectionBlock};
use tc_error::*;
use tc_scalar::Scalar;
use tc_transact::public::{Public, Route, StateInstance};
use tc_transact::{Transaction, TxnId};

pub use block::{ChainBlock, MutationPending, MutationRecord};
pub use history::{History, HistoryView};
pub(super) use store::{Store, StoreEntry};

mod block;
mod history;
mod store;

pub(super) async fn replay_all<State, T>(
    subject: &T,
    past_txn_id: &TxnId,
    mutations: &[MutationRecord],
    txn: &State::Txn,
    store: &Store<State::Txn, State::FE>,
) -> TCResult<()>
where
    State: StateInstance + From<Collection<State::Txn, State::FE>> + From<Scalar>,
    State::FE: for<'a> FileSave<'a> + CollectionBlock + Clone,
    T: Route<State> + fmt::Debug,
    Collection<State::Txn, State::FE>: TryCastFrom<State>,
    Scalar: TryCastFrom<State>,
{
    for op in mutations {
        replay(subject, txn, &store, op)
            .map_err(|err| err.consume(format!("while replaying transaction {}", past_txn_id)))
            .await?;
    }

    Ok(())
}

async fn replay<State, T>(
    subject: &T,
    txn: &State::Txn,
    store: &Store<State::Txn, State::FE>,
    mutation: &MutationRecord,
) -> TCResult<()>
where
    State: StateInstance + From<Collection<State::Txn, State::FE>> + From<Scalar>,
    State::FE: for<'a> FileSave<'a> + CollectionBlock + Clone,
    T: Route<State> + fmt::Debug,
    Collection<State::Txn, State::FE>: TryCastFrom<State>,
    Scalar: TryCastFrom<State>,
{
    match mutation {
        MutationRecord::Delete(key) => subject.delete(txn, &[], key.clone()).await,
        MutationRecord::Put(key, value) => {
            let value = store.resolve(*txn.id(), value.clone()).await?;
            subject
                .put(txn, &[], key.clone(), value.into_state::<State>())
                .await
        }
    }
}