radix-clis 1.4.0

A collection of CLIs for developing, building and testing Scrypto code, from the Radix DLT project.
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use radix_common::prelude::*;
use radix_engine::system::bootstrap::*;
use radix_engine::transaction::{
    execute_transaction, ExecutionConfig, TransactionFeeSummary, TransactionReceipt,
};
use radix_engine::vm::*;
use radix_engine_interface::prelude::system_execution;
use radix_substate_store_interface::interface::SubstateDatabase;
use radix_transactions::prelude::*;
use radix_transactions::validation::*;

pub enum LedgerTransactionReceipt {
    Flash(Box<FlashReceipt>),
    Standard(Box<TransactionReceipt>),
    ProtocolUpdateFlash(Box<StateUpdates>),
}

impl LedgerTransactionReceipt {
    pub fn into_state_updates(self) -> StateUpdates {
        match self {
            LedgerTransactionReceipt::Flash(receipt) => receipt.state_updates,
            LedgerTransactionReceipt::Standard(receipt) => {
                receipt.into_commit_ignore_outcome().state_updates
            }
            LedgerTransactionReceipt::ProtocolUpdateFlash(state_updates) => *state_updates,
        }
    }

    pub fn fee_summary(&self) -> Option<&TransactionFeeSummary> {
        match self {
            LedgerTransactionReceipt::Flash(_) => None,
            LedgerTransactionReceipt::Standard(receipt) => Some(&receipt.fee_summary),
            LedgerTransactionReceipt::ProtocolUpdateFlash(_) => None,
        }
    }
}

pub enum LedgerTransactionKindedHash {
    Genesis(SystemTransactionHash),
    User(NotarizedTransactionHash),
    Validator(Hash),
    ProtocolUpdate(Hash),
}

pub fn execute_ledger_transaction<S: SubstateDatabase>(
    database: &S,
    vm_modules: &impl VmInitialize,
    network: &NetworkDefinition,
    raw: &RawLedgerTransaction,
    trace: bool,
) -> (LedgerTransactionKindedHash, LedgerTransactionReceipt) {
    let validator = TransactionValidator::new(database, network);
    let validated = raw
        .validate(&validator, AcceptedLedgerTransactionKind::Any)
        .expect("Ledger transaction should be valid");

    let kinded_hash = match &validated.inner {
        ValidatedLedgerTransactionInner::Genesis(tx) => {
            LedgerTransactionKindedHash::Genesis(tx.system_transaction_hash())
        }
        ValidatedLedgerTransactionInner::User(tx) => {
            LedgerTransactionKindedHash::User(tx.notarized_transaction_hash())
        }
        ValidatedLedgerTransactionInner::Validator(tx) => {
            LedgerTransactionKindedHash::Validator(tx.summary.hash)
        }
        ValidatedLedgerTransactionInner::ProtocolUpdate(tx) => {
            LedgerTransactionKindedHash::ProtocolUpdate(tx.flash_transaction_hash().into_hash())
        }
    };

    let receipt = match validated.inner {
        ValidatedLedgerTransactionInner::Genesis(prepared_genesis_tx) => {
            match prepared_genesis_tx {
                PreparedGenesisTransaction::Flash(_) => {
                    let receipt = create_substate_flash_for_genesis();
                    LedgerTransactionReceipt::Flash(receipt.into())
                }
                PreparedGenesisTransaction::Transaction(tx) => {
                    let receipt = execute_transaction(
                        database,
                        vm_modules,
                        &ExecutionConfig::for_genesis_transaction(network.clone())
                            .with_kernel_trace(trace)
                            .with_cost_breakdown(trace),
                        tx.create_executable(btreeset!(system_execution(
                            SystemExecution::Protocol
                        ))),
                    );
                    LedgerTransactionReceipt::Standard(receipt.into())
                }
            }
        }
        ValidatedLedgerTransactionInner::User(tx) => {
            let receipt = execute_transaction(
                database,
                vm_modules,
                &ExecutionConfig::for_notarized_transaction(network.clone())
                    .with_kernel_trace(trace)
                    .with_cost_breakdown(trace),
                tx.create_executable(),
            );
            LedgerTransactionReceipt::Standard(receipt.into())
        }
        ValidatedLedgerTransactionInner::Validator(tx) => {
            let receipt = execute_transaction(
                database,
                vm_modules,
                &ExecutionConfig::for_system_transaction(network.clone())
                    .with_kernel_trace(trace)
                    .with_cost_breakdown(trace),
                tx.create_executable(),
            );
            LedgerTransactionReceipt::Standard(receipt.into())
        }
        ValidatedLedgerTransactionInner::ProtocolUpdate(tx) => {
            LedgerTransactionReceipt::ProtocolUpdateFlash(tx.state_updates.into())
        }
    };

    (kinded_hash, receipt)
}