amadeus-runtime 1.3.6

Consensus library for Amadeus blockchain including WASM execution, BIC contracts, and state management
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

// Consensus application environment and entry processing
use crate::Result;
use amadeus_utils::rocksdb::{BoundColumnFamily, MultiThreaded, RocksDb, Transaction, TransactionDB};
use amadeus_utils::{Hash, PublicKey, Signature};
use std::collections::HashMap;
use std::sync::Arc;

use crate::consensus::consensus_muts;

pub struct ApplyEnv<'db> {
    pub caller_env: CallerEnv,
    pub cf: Arc<BoundColumnFamily<'db>>,
    pub txn: Transaction<'db, TransactionDB<MultiThreaded>>,
    pub muts_final: Vec<consensus_muts::Mutation>,
    pub muts_final_rev: Vec<consensus_muts::Mutation>,
    pub muts: Vec<consensus_muts::Mutation>,
    pub muts_gas: Vec<consensus_muts::Mutation>,
    pub muts_rev: Vec<consensus_muts::Mutation>,
    pub muts_rev_gas: Vec<consensus_muts::Mutation>,
    pub result_log: Vec<HashMap<&'static str, &'static str>>,
}

pub struct CallerEnv {
    pub readonly: bool,
    pub seed: Vec<u8>,
    pub seedf64: f64,
    pub entry_signer: PublicKey,
    pub entry_prev_hash: Hash,
    pub entry_slot: u64,
    pub entry_prev_slot: u64,
    pub entry_height: u64,
    pub entry_epoch: u64,
    pub entry_vr: Vec<u8>,
    pub entry_vr_b3: Hash,
    pub entry_dr: Hash,
    pub tx_hash: Vec<u8>,
    pub tx_signer: PublicKey,
    pub account_origin: Vec<u8>,
    pub account_caller: Vec<u8>,
    pub account_current: Vec<u8>,
    pub attached_symbol: Vec<u8>,
    pub attached_amount: Vec<u8>,
    pub call_counter: u32,
    pub call_exec_points: u64,
    pub call_exec_points_remaining: u64,
}

pub fn make_caller_env(
    entry_signer: &PublicKey,
    entry_prev_hash: &Hash,
    entry_slot: u64,
    entry_prev_slot: u64,
    entry_height: u64,
    entry_epoch: u64,
    entry_vr: &Signature,
    entry_vr_b3: &Hash,
    entry_dr: &Hash,
) -> CallerEnv {
    CallerEnv {
        readonly: false,
        seed: entry_dr.to_vec(),
        seedf64: 0.5,
        entry_signer: *entry_signer,
        entry_prev_hash: *entry_prev_hash,
        entry_slot,
        entry_prev_slot,
        entry_height,
        entry_epoch,
        entry_vr: entry_vr.to_vec(),
        entry_vr_b3: *entry_vr_b3,
        entry_dr: *entry_dr,
        tx_hash: vec![],
        tx_signer: PublicKey::new([0u8; 48]),
        account_origin: vec![],
        account_caller: vec![],
        account_current: vec![],
        attached_symbol: vec![],
        attached_amount: vec![],
        call_counter: 0,
        call_exec_points: 10_000_000,
        call_exec_points_remaining: 10_000_000,
    }
}

pub fn make_apply_env<'db>(
    db: &'db RocksDb,
    cf_name: &str,
    entry_signer: &PublicKey,
    entry_prev_hash: &Hash,
    entry_slot: u64,
    entry_prev_slot: u64,
    entry_height: u64,
    entry_epoch: u64,
    entry_vr: &Signature,
    entry_vr_b3: &Hash,
    entry_dr: &Hash,
) -> Result<ApplyEnv<'db>> {
    Ok(ApplyEnv {
        caller_env: make_caller_env(
            entry_signer,
            entry_prev_hash,
            entry_slot,
            entry_prev_slot,
            entry_height,
            entry_epoch,
            entry_vr,
            entry_vr_b3,
            entry_dr,
        ),
        cf: db.inner.cf_handle(cf_name).ok_or("cf_handle_failed")?,
        txn: db.begin_transaction(),
        muts_final: Vec::new(),
        muts_final_rev: Vec::new(),
        muts: Vec::new(),
        muts_gas: Vec::new(),
        muts_rev: Vec::new(),
        muts_rev_gas: Vec::new(),
        result_log: Vec::new(),
    })
}

pub fn valid_bic_action(contract: Vec<u8>, function: Vec<u8>) -> bool {
    let c = contract.as_slice();
    let f = function.as_slice();

    (c == b"Epoch" || c == b"Coin" || c == b"Contract")
        && (f == b"submit_sol"
            || f == b"transfer"
            || f == b"set_emission_address"
            || f == b"slash_trainer"
            || f == b"deploy"
            || f == b"create_and_mint"
            || f == b"mint"
            || f == b"pause")
}