storm_node 0.9.0

Storm node
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

// RGB node providing smart contracts functionality for Bitcoin & Lightning.
//
// Written in 2022 by
//     Dr. Maxim Orlovsky <orlovsky@lnp-bp.org>
//
// Copyright (C) 2022 by LNP/BP Standards Association, Switzerland.
//
// You should have received a copy of the MIT License along with this software.
// If not, see <https://opensource.org/licenses/MIT>.

use std::collections::BTreeSet;
use std::fmt::{self, Display, Formatter};

use internet2::addr::NodeId;
use microservices::esb::ClientId;
use storm::p2p::AppMsg;
use storm::{Chunk, ChunkId, Container, ContainerId, StormApp};
use storm_rpc::{AddressedMsg, AppContainer};
use strict_encoding::{StrictDecode, StrictEncode};

/// RPC API requests over CTL message bus between RGB Node daemons.
#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, Display, From)]
#[derive(NetworkEncode, NetworkDecode)]
#[non_exhaustive]
pub enum CtlMsg {
    #[display("hello()")]
    Hello,

    #[display("get({0})")]
    GetContainer(AddressedClientMsg<AppContainer>),

    #[display("announce({0})")]
    AnnounceContainer(AddressedClientMsg<AppContainer>),

    #[display("send({0})")]
    SendContainer(AddressedClientMsg<AppContainer>),

    #[display("process_container(...)")]
    ProcessContainer(Container),

    #[display("send_chunks({0})")]
    SendChunks(AddressedMsg<ChunkSend>),

    #[display("chunk(...)")]
    ProcessChunk(Chunk),

    #[display("processing_complete()")]
    ProcessingComplete,

    #[display("processing_failed()")]
    ProcessingFailed,
}

#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash, Debug, Display)]
#[derive(NetworkEncode, NetworkDecode)]
#[display("{storm_app}, {container_id}, ...")]
pub struct ChunkSend {
    pub storm_app: StormApp,
    pub container_id: ContainerId,
    pub chunk_ids: BTreeSet<ChunkId>,
}

#[derive(Copy, Clone, PartialOrd, Ord, PartialEq, Eq, Hash, Debug, NetworkEncode, NetworkDecode)]
pub struct AddressedClientMsg<T>
where T: StrictEncode + StrictDecode
{
    pub remote_id: NodeId,
    pub client_id: Option<ClientId>,
    pub data: T,
}

impl<T> Display for AddressedClientMsg<T>
where T: Display + StrictEncode + StrictDecode
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{}, {}", self.remote_id, self.data)
    }
}

impl<T> AddressedClientMsg<T>
where T: StrictEncode + StrictDecode
{
    pub fn with(app_msg: AppMsg<T>, remote_peer: NodeId, client_id: ClientId) -> Self {
        AddressedClientMsg {
            client_id: Some(client_id),
            remote_id: remote_peer,
            data: app_msg.data,
        }
    }
}