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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use core::fmt;

use super::{TransactionEventParsingError, TransactionTraceParsingError};

// CONSTANTS
// ================================================================================================

/// Value of the top 16 bits of a transaction kernel event ID.
pub const EVENT_ID_PREFIX: u32 = 2;

// TRANSACTION EVENT
// ================================================================================================

const ACCOUNT_VAULT_BEFORE_ADD_ASSET: u32 = 0x2_0000; // 131072
const ACCOUNT_VAULT_AFTER_ADD_ASSET: u32 = 0x2_0001; // 131073

const ACCOUNT_VAULT_BEFORE_REMOVE_ASSET: u32 = 0x2_0002; // 131074
const ACCOUNT_VAULT_AFTER_REMOVE_ASSET: u32 = 0x2_0003; // 131075

const ACCOUNT_STORAGE_BEFORE_SET_ITEM: u32 = 0x2_0004; // 131076
const ACCOUNT_STORAGE_AFTER_SET_ITEM: u32 = 0x2_0005; // 131077

const ACCOUNT_STORAGE_BEFORE_SET_MAP_ITEM: u32 = 0x2_0006; // 131078
const ACCOUNT_STORAGE_AFTER_SET_MAP_ITEM: u32 = 0x2_0007; // 131079

const ACCOUNT_BEFORE_INCREMENT_NONCE: u32 = 0x2_0008; // 131080
const ACCOUNT_AFTER_INCREMENT_NONCE: u32 = 0x2_0009; // 131081

const ACCOUNT_PUSH_PROCEDURE_INDEX: u32 = 0x2_000A; // 131082

const NOTE_BEFORE_CREATED: u32 = 0x2_000B; // 131083
const NOTE_AFTER_CREATED: u32 = 0x2_000C; // 131084

const NOTE_BEFORE_ADD_ASSET: u32 = 0x2_000D; // 131085
const NOTE_AFTER_ADD_ASSET: u32 = 0x2_000E; // 131086

/// Events which may be emitted by a transaction kernel.
///
/// The events are emitted via the `emit.<event_id>` instruction. The event ID is a 32-bit
/// unsigned integer which is used to identify the event type. For events emitted by the
/// transaction kernel, the event_id is structured as follows:
/// - The upper 16 bits of the event ID are set to 2.
/// - The lower 16 bits represent a unique event ID within the transaction kernel.
#[repr(u32)]
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum TransactionEvent {
    AccountVaultBeforeAddAsset = ACCOUNT_VAULT_BEFORE_ADD_ASSET,
    AccountVaultAfterAddAsset = ACCOUNT_VAULT_AFTER_ADD_ASSET,

    AccountVaultBeforeRemoveAsset = ACCOUNT_VAULT_BEFORE_REMOVE_ASSET,
    AccountVaultAfterRemoveAsset = ACCOUNT_VAULT_AFTER_REMOVE_ASSET,

    AccountStorageBeforeSetItem = ACCOUNT_STORAGE_BEFORE_SET_ITEM,
    AccountStorageAfterSetItem = ACCOUNT_STORAGE_AFTER_SET_ITEM,

    AccountStorageBeforeSetMapItem = ACCOUNT_STORAGE_BEFORE_SET_MAP_ITEM,
    AccountStorageAfterSetMapItem = ACCOUNT_STORAGE_AFTER_SET_MAP_ITEM,

    AccountBeforeIncrementNonce = ACCOUNT_BEFORE_INCREMENT_NONCE,
    AccountAfterIncrementNonce = ACCOUNT_AFTER_INCREMENT_NONCE,

    AccountPushProcedureIndex = ACCOUNT_PUSH_PROCEDURE_INDEX,

    NoteBeforeCreated = NOTE_BEFORE_CREATED,
    NoteAfterCreated = NOTE_AFTER_CREATED,

    NoteBeforeAddAsset = NOTE_BEFORE_ADD_ASSET,
    NoteAfterAddAsset = NOTE_AFTER_ADD_ASSET,
}

impl fmt::Display for TransactionEvent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{self:?}")
    }
}

impl TryFrom<u32> for TransactionEvent {
    type Error = TransactionEventParsingError;

    fn try_from(value: u32) -> Result<Self, Self::Error> {
        if value >> 16 != EVENT_ID_PREFIX {
            return Err(TransactionEventParsingError::NotTransactionEvent(value));
        }

        match value {
            ACCOUNT_VAULT_BEFORE_ADD_ASSET => Ok(TransactionEvent::AccountVaultBeforeAddAsset),
            ACCOUNT_VAULT_AFTER_ADD_ASSET => Ok(TransactionEvent::AccountVaultAfterAddAsset),

            ACCOUNT_VAULT_BEFORE_REMOVE_ASSET => {
                Ok(TransactionEvent::AccountVaultBeforeRemoveAsset)
            },
            ACCOUNT_VAULT_AFTER_REMOVE_ASSET => Ok(TransactionEvent::AccountVaultAfterRemoveAsset),

            ACCOUNT_STORAGE_BEFORE_SET_ITEM => Ok(TransactionEvent::AccountStorageBeforeSetItem),
            ACCOUNT_STORAGE_AFTER_SET_ITEM => Ok(TransactionEvent::AccountStorageAfterSetItem),

            ACCOUNT_STORAGE_BEFORE_SET_MAP_ITEM => {
                Ok(TransactionEvent::AccountStorageBeforeSetMapItem)
            },
            ACCOUNT_STORAGE_AFTER_SET_MAP_ITEM => {
                Ok(TransactionEvent::AccountStorageAfterSetMapItem)
            },

            ACCOUNT_BEFORE_INCREMENT_NONCE => Ok(TransactionEvent::AccountBeforeIncrementNonce),
            ACCOUNT_AFTER_INCREMENT_NONCE => Ok(TransactionEvent::AccountAfterIncrementNonce),

            ACCOUNT_PUSH_PROCEDURE_INDEX => Ok(TransactionEvent::AccountPushProcedureIndex),

            NOTE_BEFORE_CREATED => Ok(TransactionEvent::NoteBeforeCreated),
            NOTE_AFTER_CREATED => Ok(TransactionEvent::NoteAfterCreated),

            NOTE_BEFORE_ADD_ASSET => Ok(TransactionEvent::NoteBeforeAddAsset),
            NOTE_AFTER_ADD_ASSET => Ok(TransactionEvent::NoteAfterAddAsset),

            _ => Err(TransactionEventParsingError::InvalidTransactionEvent(value)),
        }
    }
}

// TRANSACTION TRACE
// ================================================================================================

#[repr(u32)]
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum TransactionTrace {
    PrologueStart = 0x2_0000,           // 131072
    PrologueEnd = 0x2_0001,             // 131073
    NotesProcessingStart = 0x2_0002,    // 131074
    NotesProcessingEnd = 0x2_0003,      // 131075
    NoteExecutionStart = 0x2_0004,      // 131076
    NoteExecutionEnd = 0x2_0005,        // 131077
    TxScriptProcessingStart = 0x2_0006, // 131078
    TxScriptProcessingEnd = 0x2_0007,   // 131079
    EpilogueStart = 0x2_0008,           // 131080
    EpilogueEnd = 0x2_0009,             // 131081
}

impl fmt::Display for TransactionTrace {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{self:?}")
    }
}

impl TryFrom<u32> for TransactionTrace {
    type Error = TransactionTraceParsingError;

    fn try_from(value: u32) -> Result<Self, Self::Error> {
        if value >> 16 != EVENT_ID_PREFIX {
            return Err(TransactionTraceParsingError::NotTransactionTrace(value));
        }

        match value {
            0x2_0000 => Ok(TransactionTrace::PrologueStart),
            0x2_0001 => Ok(TransactionTrace::PrologueEnd),
            0x2_0002 => Ok(TransactionTrace::NotesProcessingStart),
            0x2_0003 => Ok(TransactionTrace::NotesProcessingEnd),
            0x2_0004 => Ok(TransactionTrace::NoteExecutionStart),
            0x2_0005 => Ok(TransactionTrace::NoteExecutionEnd),
            0x2_0006 => Ok(TransactionTrace::TxScriptProcessingStart),
            0x2_0007 => Ok(TransactionTrace::TxScriptProcessingEnd),
            0x2_0008 => Ok(TransactionTrace::EpilogueStart),
            0x2_0009 => Ok(TransactionTrace::EpilogueEnd),
            _ => Err(TransactionTraceParsingError::InvalidTransactionTrace(value)),
        }
    }
}