solana-svm 4.4.0

Solana SVM
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Transaction effects (output).

#[cfg(feature = "conformance")]
use {
    crate::conformance::{
        account_state::account_to_proto, err::serialized_error_code, fd_hash::fd_hash_or_zero,
    },
    agave_precompiles::is_precompile,
    protosol::protos::{FeeDetails as ProtoFeeDetails, TxnResult as ProtoTxnResult},
    solana_instruction_error::InstructionError,
    solana_message::SanitizedMessage,
};
use {
    solana_account::Account,
    solana_fee_structure::FeeDetails,
    solana_pubkey::Pubkey,
    solana_transaction_error::{TransactionError, TransactionResult},
};

/// Represents effects of a single transaction.
pub struct TxnEffects {
    pub executed: bool,
    pub status: TransactionResult<()>,
    pub resulting_accounts: Vec<(Pubkey, Account)>,
    pub rollback_accounts: Vec<(Pubkey, Account)>,
    pub return_data: Vec<u8>,
    pub executed_units: u64,
    pub fee_details: FeeDetails,
    pub loaded_accounts_data_size: u64,
    pub logs: Vec<String>,
    pub cu_avail: u64,
}

impl TxnEffects {
    pub fn from_unprocessed_error(err: TransactionError) -> Self {
        Self {
            executed: false,
            status: Err(err),
            resulting_accounts: vec![],
            rollback_accounts: vec![],
            return_data: vec![],
            executed_units: 0,
            fee_details: FeeDetails::new(0, 0),
            loaded_accounts_data_size: 0,
            logs: vec![],
            cu_avail: 0,
        }
    }

    /// Returns the resulting account for the given pubkey, if it exists.
    pub fn get_account(&self, pubkey: &Pubkey) -> Option<&Account> {
        self.resulting_accounts
            .iter()
            .find(|(pk, _)| pk == pubkey)
            .map(|(_, account)| account)
    }

    /// Zero the custom error code when the failing instruction is a
    /// precompile. Firedancer does not compare precompile custom codes.
    #[cfg(feature = "conformance")]
    pub fn zero_precompile_custom_error(&mut self, sanitized_message: &SanitizedMessage) {
        let index = match &self.status {
            Err(TransactionError::InstructionError(index, InstructionError::Custom(code)))
                if *code != 0 =>
            {
                *index
            }
            _ => return,
        };

        let failed_on_precompile = sanitized_message
            .program_instructions_iter()
            .nth(usize::from(index))
            .is_some_and(|(program_id, _)| is_precompile(program_id, |_| true));

        if failed_on_precompile {
            self.status = Err(TransactionError::InstructionError(
                index,
                InstructionError::Custom(0),
            ));
        }
    }
}

#[cfg(feature = "conformance")]
impl From<TxnEffects> for ProtoTxnResult {
    fn from(value: TxnEffects) -> Self {
        let (txn_error, instruction_error, custom_error, instruction_error_index) = value
            .status
            .as_ref()
            .err()
            .map(|transaction_error| {
                let (instruction_error, custom_error, instruction_error_index) =
                    match transaction_error {
                        TransactionError::InstructionError(
                            instruction_error_index,
                            instruction_error,
                        ) => {
                            let custom_error = match instruction_error {
                                InstructionError::Custom(custom_error) => *custom_error,
                                _ => 0,
                            };
                            (
                                serialized_error_code(instruction_error),
                                custom_error,
                                (*instruction_error_index).into(),
                            )
                        }
                        _ => (0, 0, 0),
                    };

                (
                    serialized_error_code(transaction_error),
                    instruction_error,
                    custom_error,
                    instruction_error_index,
                )
            })
            .unwrap_or((0, 0, 0, 0));

        let fee_details = Some(ProtoFeeDetails {
            transaction_fee: value.fee_details.transaction_fee(),
            prioritization_fee: value.fee_details.prioritization_fee(),
        });
        let modified_accounts = value
            .resulting_accounts
            .into_iter()
            .map(|(pubkey, account)| account_to_proto((pubkey, account)))
            .collect();
        let rollback_accounts = value
            .rollback_accounts
            .into_iter()
            .map(|(pubkey, account)| account_to_proto((pubkey, account)))
            .collect();

        Self {
            executed: value.executed,
            txn_error,
            instruction_error,
            instruction_error_index,
            custom_error,
            return_data_hash: fd_hash_or_zero(&value.return_data),
            executed_units: value.executed_units,
            fee_details,
            loaded_accounts_data_size: value.loaded_accounts_data_size,
            modified_accounts,
            rollback_accounts,
        }
    }
}