neptune-rpc-api 0.14.0

Neptune JSON-RPC API contract: the RpcApi trait and its data-transfer model types
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use neptune_consensus::block::block_body::BlockBody;
use neptune_mutator_set::active_window::ActiveWindow;
use neptune_mutator_set::mutator_set_accumulator::MutatorSetAccumulator;
use serde::Deserialize;
use serde::Serialize;
use tasm_lib::prelude::Digest;
use tasm_lib::twenty_first::prelude::Mmr;
use tasm_lib::twenty_first::util_types::mmr::mmr_accumulator::MmrAccumulator;

use crate::model::block::transaction_kernel::RpcTransactionKernel;

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RpcMmrAccumulator {
    pub leaf_count: u64,
    pub peaks: Vec<Digest>,
}

impl From<&MmrAccumulator> for RpcMmrAccumulator {
    fn from(mmr: &MmrAccumulator) -> Self {
        Self {
            leaf_count: mmr.num_leafs(),
            peaks: mmr.peaks(),
        }
    }
}

impl From<RpcMmrAccumulator> for MmrAccumulator {
    fn from(mmr: RpcMmrAccumulator) -> Self {
        MmrAccumulator::init(mmr.peaks, mmr.leaf_count)
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, Default)]
pub struct RpcActiveWindow(pub Vec<u32>);

impl From<&ActiveWindow> for RpcActiveWindow {
    fn from(window: &ActiveWindow) -> Self {
        Self(window.to_vec_u32())
    }
}

impl From<RpcActiveWindow> for ActiveWindow {
    fn from(window: RpcActiveWindow) -> Self {
        ActiveWindow::from_vec_u32(window.0)
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RpcMutatorSetAccumulator {
    pub aocl: RpcMmrAccumulator,
    pub swbf_inactive: RpcMmrAccumulator,
    pub swbf_active: RpcActiveWindow,
}

impl From<&MutatorSetAccumulator> for RpcMutatorSetAccumulator {
    fn from(set: &MutatorSetAccumulator) -> Self {
        Self {
            aocl: RpcMmrAccumulator::from(&set.aocl),
            swbf_inactive: RpcMmrAccumulator::from(&set.swbf_inactive),
            swbf_active: RpcActiveWindow::from(&set.swbf_active),
        }
    }
}

impl From<RpcMutatorSetAccumulator> for MutatorSetAccumulator {
    fn from(msa: RpcMutatorSetAccumulator) -> Self {
        Self {
            aocl: MmrAccumulator::from(msa.aocl),
            swbf_inactive: MmrAccumulator::from(msa.swbf_inactive),
            swbf_active: ActiveWindow::from(msa.swbf_active),
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RpcBlockBody {
    pub transaction_kernel: RpcTransactionKernel,
    pub mutator_set_accumulator: RpcMutatorSetAccumulator,
    pub lock_free_mmr_accumulator: RpcMmrAccumulator,
    pub block_mmr_accumulator: RpcMmrAccumulator,
}

impl From<&BlockBody> for RpcBlockBody {
    fn from(body: &BlockBody) -> Self {
        Self {
            transaction_kernel: RpcTransactionKernel::from(&body.transaction_kernel),
            mutator_set_accumulator: RpcMutatorSetAccumulator::from(
                &body.mutator_set_accumulator_without_guesser_fees(),
            ),
            lock_free_mmr_accumulator: RpcMmrAccumulator::from(&body.lock_free_mmr_accumulator),
            block_mmr_accumulator: RpcMmrAccumulator::from(&body.block_mmr_accumulator),
        }
    }
}

impl From<RpcBlockBody> for BlockBody {
    fn from(body: RpcBlockBody) -> Self {
        BlockBody::new(
            body.transaction_kernel.into(),
            body.mutator_set_accumulator.into(),
            body.lock_free_mmr_accumulator.into(),
            body.block_mmr_accumulator.into(),
        )
    }
}