eva-asm 0.2.0

EVM assembly instructions, opcodes and mnemonics
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

//! System and SHA3 operations.

use derive_more::Display;

use crate::{
    instruction::InstructionMeta,
    opcode::{Mnemonic, OpCode},
};

/// Compute Keccak-256 hash.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Keccak256;

impl InstructionMeta for Keccak256 {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::KECCAK256)
    }
}

/// Create a new account with associated code.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Create;

impl InstructionMeta for Create {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::CREATE)
    }
}

/// Message-call into an account.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Call;

impl InstructionMeta for Call {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::CALL)
    }
}

/// Message-call into this account with alternative account’s code.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct CallCode;

impl InstructionMeta for CallCode {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::CALLCODE)
    }
}

/// Halt execution returning output data.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Return;

impl InstructionMeta for Return {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::RETURN)
    }
}

/// Message-call into this account with an alternative account’s code, but persisting the current values for sender and value.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct DelegateCall;

impl InstructionMeta for DelegateCall {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::DELEGATECALL)
    }
}

/// Create a new account with associated code at a predictable address.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Create2;

impl InstructionMeta for Create2 {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::CREATE2)
    }
}

/// Static message-call into an account.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct StaticCall;

impl InstructionMeta for StaticCall {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::STATICCALL)
    }
}

/// Halt execution reverting state changes but returning data and remaining gas.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Revert;

impl InstructionMeta for Revert {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::REVERT)
    }
}

/// Designated invalid instruction.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Invalid;

impl InstructionMeta for Invalid {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::INVALID)
    }
}

/// Halt execution and register account for later deletion or send all Ether to address (post-Cancun).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct SelfDestruct;

impl InstructionMeta for SelfDestruct {
    fn opcode(&self) -> OpCode {
        OpCode::Known(Mnemonic::SELFDESTRUCT)
    }
}

/// An identified instruction.
/// The difference between this instruction and [`Invalid`] is that the [`Invalid`] instruction is explicitly
/// defined in the specification and this instruction is a catch-all instruction for any operation
/// code not defined in the specification. Otherwise they behave the exact same way.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Unknown(
    /// The unidentified operation code.
    pub u8,
);

impl InstructionMeta for Unknown {
    fn opcode(&self) -> OpCode {
        OpCode::Unknown(self.0)
    }
}