radix-engine 1.3.1

Reference implementation of Radix Engine, from the Radix DLT project.
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
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 crate::internal_prelude::*;
use radix_transactions::model::*;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProtocolUpdateTransaction {
    FlashTransactionV1(FlashTransactionV1),
    SystemTransactionV1(ProtocolSystemTransactionV1),
}

impl From<FlashTransactionV1> for ProtocolUpdateTransaction {
    fn from(value: FlashTransactionV1) -> Self {
        Self::FlashTransactionV1(value)
    }
}

impl From<ProtocolSystemTransactionV1> for ProtocolUpdateTransaction {
    fn from(value: ProtocolSystemTransactionV1) -> Self {
        Self::SystemTransactionV1(value)
    }
}

impl ProtocolUpdateTransaction {
    pub fn flash(name: impl Into<String>, state_updates: StateUpdates) -> Self {
        let name = name.into();
        if name != name.to_ascii_lowercase().as_str() {
            panic!("Protocol transaction names should be in kebab-case for consistency");
        }
        Self::FlashTransactionV1(FlashTransactionV1 {
            name,
            state_updates,
        })
    }

    pub fn genesis_transaction(name: impl Into<String>, transaction: SystemTransactionV1) -> Self {
        let name = name.into();
        if name != name.to_ascii_lowercase().as_str() {
            panic!("Protocol transaction names should be in kebab-case for consistency");
        }
        Self::SystemTransactionV1(ProtocolSystemTransactionV1 {
            name,
            disable_auth: true,
            transaction,
        })
    }

    pub fn name(&self) -> Option<&str> {
        match self {
            ProtocolUpdateTransaction::FlashTransactionV1(tx) => Some(tx.name.as_str()),
            ProtocolUpdateTransaction::SystemTransactionV1(tx) => Some(tx.name.as_str()),
        }
    }
}

/// At present, this isn't actually saved in the node - instead just the
/// SystemTransactionV1 is saved.
#[derive(Debug, Clone, PartialEq, Eq, ManifestSbor, ScryptoDescribe)]
pub struct ProtocolSystemTransactionV1 {
    pub name: String,
    pub disable_auth: bool,
    pub transaction: SystemTransactionV1,
}

/// A set of transactions which all get committed together with the same proof.
/// To avoid memory overflows, this should be kept small enough to comfortably fit into
/// memory (e.g. one transaction per batch).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProtocolUpdateBatch {
    pub transactions: Vec<ProtocolUpdateTransaction>,
}

impl ProtocolUpdateBatch {
    pub fn empty() -> Self {
        Self {
            transactions: vec![],
        }
    }

    pub fn new(transactions: impl IntoIterator<Item = ProtocolUpdateTransaction>) -> Self {
        Self {
            transactions: transactions.into_iter().collect(),
        }
    }

    pub fn add_flash(mut self, name: impl Into<String>, updates: StateUpdates) -> Self {
        self.mut_add_flash(name, updates);
        self
    }

    pub fn mut_add_flash(&mut self, name: impl Into<String>, updates: StateUpdates) {
        self.mut_add(ProtocolUpdateTransaction::flash(name, updates))
    }

    #[allow(clippy::should_implement_trait)]
    pub fn add(mut self, transaction: ProtocolUpdateTransaction) -> Self {
        self.mut_add(transaction);
        self
    }

    pub fn mut_add(&mut self, transaction: ProtocolUpdateTransaction) {
        self.transactions.push(transaction);
    }

    pub fn single(single_transaction: ProtocolUpdateTransaction) -> Self {
        Self {
            transactions: vec![single_transaction],
        }
    }
}