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
147
148
149
150

//! Stop and Arithmetic Operations.

use derive_more::Display;

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

/// Halts execution.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Stop;

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

/// Addition operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Add;

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

/// Multiplication operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Mul;

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

/// Subtraction operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Sub;

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

/// Integer division operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Div;

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

/// Signed integer division operation (truncated).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct SDiv;

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

/// Modulo remainder operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Mod;

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

/// Signed modulo remainder operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct SMod;

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

/// Modulo addition operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct AddMod;

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

/// Modulo multiplication operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct MulMod;

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

/// Exponential operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct Exp;

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

/// Extend length of two’s complement signed integer.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display)]
#[display("{}", self.opcode())]
pub struct SignExtend;

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

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn stop_fmt() {
        assert_eq!(format!("{Stop}"), String::from("STOP"));
    }
}