EVM Instruction Encoding (Opcodes)

Table of Contents

Introduction
Package Contents
- Classes
- Attributes
Package Details
- Ops
- op_implementation

Introduction

Machine readable representations of EVM instructions, and a mapping to their implementations.

Submodules

Package Contents

Classes

Ops

Enum for EVM Opcodes

Attributes

op_implementation

Package Details

Ops

Enum for EVM Opcodes

class Ops

Bases: enum.Enum

ADD = 1

MUL = 2

SUB = 3

DIV = 4

SDIV = 5

MOD = 6

SMOD = 7

ADDMOD = 8

MULMOD = 9

EXP = 10

SIGNEXTEND = 11

LT = 16

GT = 17

SLT = 18

SGT = 19

EQ = 20

ISZERO = 21

AND = 22

OR = 23

XOR = 24

NOT = 25

BYTE = 26

SHL = 27

SHR = 28

SAR = 29

KECCAK = 32

ADDRESS = 48

BALANCE = 49

ORIGIN = 50

CALLER = 51

CALLVALUE = 52

CALLDATALOAD = 53

CALLDATASIZE = 54

CALLDATACOPY = 55

CODESIZE = 56

CODECOPY = 57

GASPRICE = 58

EXTCODESIZE = 59

EXTCODECOPY = 60

RETURNDATASIZE = 61

RETURNDATACOPY = 62

EXTCODEHASH = 63

BLOCKHASH = 64

COINBASE = 65

TIMESTAMP = 66

NUMBER = 67

DIFFICULTY = 68

GASLIMIT = 69

CHAINID = 70

SELFBALANCE = 71

BASEFEE = 72

STOP = 0

JUMP = 86

JUMPI = 87

PC = 88

GAS = 90

JUMPDEST = 91

SLOAD = 84

SSTORE = 85

POP = 80

PUSH1 = 96

PUSH2 = 97

PUSH3 = 98

PUSH4 = 99

PUSH5 = 100

PUSH6 = 101

PUSH7 = 102

PUSH8 = 103

PUSH9 = 104

PUSH10 = 105

PUSH11 = 106

PUSH12 = 107

PUSH13 = 108

PUSH14 = 109

PUSH15 = 110

PUSH16 = 111

PUSH17 = 112

PUSH18 = 113

PUSH19 = 114

PUSH20 = 115

PUSH21 = 116

PUSH22 = 117

PUSH23 = 118

PUSH24 = 119

PUSH25 = 120

PUSH26 = 121

PUSH27 = 122

PUSH28 = 123

PUSH29 = 124

PUSH30 = 125

PUSH31 = 126

PUSH32 = 127

DUP1 = 128

DUP2 = 129

DUP3 = 130

DUP4 = 131

DUP5 = 132

DUP6 = 133

DUP7 = 134

DUP8 = 135

DUP9 = 136

DUP10 = 137

DUP11 = 138

DUP12 = 139

DUP13 = 140

DUP14 = 141

DUP15 = 142

DUP16 = 143

SWAP1 = 144

SWAP2 = 145

SWAP3 = 146

SWAP4 = 147

SWAP5 = 148

SWAP6 = 149

SWAP7 = 150

SWAP8 = 151

SWAP9 = 152

SWAP10 = 153

SWAP11 = 154

SWAP12 = 155

SWAP13 = 156

SWAP14 = 157

SWAP15 = 158

SWAP16 = 159

MLOAD = 81

MSTORE = 82

MSTORE8 = 83

MSIZE = 89

LOG0 = 160

LOG1 = 161

LOG2 = 162

LOG3 = 163

LOG4 = 164

CREATE = 240

RETURN = 243

CALL = 241

CALLCODE = 242

DELEGATECALL = 244

STATICCALL = 250

REVERT = 253

SELFDESTRUCT = 255

CREATE2 = 245

op_implementation

op_implementation

op_implementation: Dict[Ops, Callable] = {
    Ops.STOP: control_flow_instructions.stop,
    Ops.ADD: arithmetic_instructions.add,
    Ops.MUL: arithmetic_instructions.mul,
    Ops.SUB: arithmetic_instructions.sub,
    Ops.DIV: arithmetic_instructions.div,
    Ops.SDIV: arithmetic_instructions.sdiv,
    Ops.MOD: arithmetic_instructions.mod,
    Ops.SMOD: arithmetic_instructions.smod,
    Ops.ADDMOD: arithmetic_instructions.addmod,
    Ops.MULMOD: arithmetic_instructions.mulmod,
    Ops.EXP: arithmetic_instructions.exp,
    Ops.SIGNEXTEND: arithmetic_instructions.signextend,
    Ops.LT: comparison_instructions.less_than,
    Ops.GT: comparison_instructions.greater_than,
    Ops.SLT: comparison_instructions.signed_less_than,
    Ops.SGT: comparison_instructions.signed_greater_than,
    Ops.EQ: comparison_instructions.equal,
    Ops.ISZERO: comparison_instructions.is_zero,
    Ops.AND: bitwise_instructions.bitwise_and,
    Ops.OR: bitwise_instructions.bitwise_or,
    Ops.XOR: bitwise_instructions.bitwise_xor,
    Ops.NOT: bitwise_instructions.bitwise_not,
    Ops.BYTE: bitwise_instructions.get_byte,
    Ops.SHL: bitwise_instructions.bitwise_shl,
    Ops.SHR: bitwise_instructions.bitwise_shr,
    Ops.SAR: bitwise_instructions.bitwise_sar,
    Ops.KECCAK: keccak_instructions.keccak,
    Ops.SLOAD: storage_instructions.sload,
    Ops.BLOCKHASH: block_instructions.block_hash,
    Ops.COINBASE: block_instructions.coinbase,
    Ops.TIMESTAMP: block_instructions.timestamp,
    Ops.NUMBER: block_instructions.number,
    Ops.DIFFICULTY: block_instructions.difficulty,
    Ops.GASLIMIT: block_instructions.gas_limit,
    Ops.CHAINID: block_instructions.chain_id,
    Ops.MLOAD: memory_instructions.mload,
    Ops.MSTORE: memory_instructions.mstore,
    Ops.MSTORE8: memory_instructions.mstore8,
    Ops.MSIZE: memory_instructions.msize,
    Ops.ADDRESS: environment_instructions.address,
    Ops.BALANCE: environment_instructions.balance,
    Ops.ORIGIN: environment_instructions.origin,
    Ops.CALLER: environment_instructions.caller,
    Ops.CALLVALUE: environment_instructions.callvalue,
    Ops.CALLDATALOAD: environment_instructions.calldataload,
    Ops.CALLDATASIZE: environment_instructions.calldatasize,
    Ops.CALLDATACOPY: environment_instructions.calldatacopy,
    Ops.CODESIZE: environment_instructions.codesize,
    Ops.CODECOPY: environment_instructions.codecopy,
    Ops.GASPRICE: environment_instructions.gasprice,
    Ops.EXTCODESIZE: environment_instructions.extcodesize,
    Ops.EXTCODECOPY: environment_instructions.extcodecopy,
    Ops.RETURNDATASIZE: environment_instructions.returndatasize,
    Ops.RETURNDATACOPY: environment_instructions.returndatacopy,
    Ops.EXTCODEHASH: environment_instructions.extcodehash,
    Ops.SELFBALANCE: environment_instructions.self_balance,
    Ops.BASEFEE: environment_instructions.base_fee,
    Ops.SSTORE: storage_instructions.sstore,
    Ops.JUMP: control_flow_instructions.jump,
    Ops.JUMPI: control_flow_instructions.jumpi,
    Ops.PC: control_flow_instructions.pc,
    Ops.GAS: control_flow_instructions.gas_left,
    Ops.JUMPDEST: control_flow_instructions.jumpdest,
    Ops.POP: stack_instructions.pop,
    Ops.PUSH1: stack_instructions.push1,
    Ops.PUSH2: stack_instructions.push2,
    Ops.PUSH3: stack_instructions.push3,
    Ops.PUSH4: stack_instructions.push4,
    Ops.PUSH5: stack_instructions.push5,
    Ops.PUSH6: stack_instructions.push6,
    Ops.PUSH7: stack_instructions.push7,
    Ops.PUSH8: stack_instructions.push8,
    Ops.PUSH9: stack_instructions.push9,
    Ops.PUSH10: stack_instructions.push10,
    Ops.PUSH11: stack_instructions.push11,
    Ops.PUSH12: stack_instructions.push12,
    Ops.PUSH13: stack_instructions.push13,
    Ops.PUSH14: stack_instructions.push14,
    Ops.PUSH15: stack_instructions.push15,
    Ops.PUSH16: stack_instructions.push16,
    Ops.PUSH17: stack_instructions.push17,
    Ops.PUSH18: stack_instructions.push18,
    Ops.PUSH19: stack_instructions.push19,
    Ops.PUSH20: stack_instructions.push20,
    Ops.PUSH21: stack_instructions.push21,
    Ops.PUSH22: stack_instructions.push22,
    Ops.PUSH23: stack_instructions.push23,
    Ops.PUSH24: stack_instructions.push24,
    Ops.PUSH25: stack_instructions.push25,
    Ops.PUSH26: stack_instructions.push26,
    Ops.PUSH27: stack_instructions.push27,
    Ops.PUSH28: stack_instructions.push28,
    Ops.PUSH29: stack_instructions.push29,
    Ops.PUSH30: stack_instructions.push30,
    Ops.PUSH31: stack_instructions.push31,
    Ops.PUSH32: stack_instructions.push32,
    Ops.DUP1: stack_instructions.dup1,
    Ops.DUP2: stack_instructions.dup2,
    Ops.DUP3: stack_instructions.dup3,
    Ops.DUP4: stack_instructions.dup4,
    Ops.DUP5: stack_instructions.dup5,
    Ops.DUP6: stack_instructions.dup6,
    Ops.DUP7: stack_instructions.dup7,
    Ops.DUP8: stack_instructions.dup8,
    Ops.DUP9: stack_instructions.dup9,
    Ops.DUP10: stack_instructions.dup10,
    Ops.DUP11: stack_instructions.dup11,
    Ops.DUP12: stack_instructions.dup12,
    Ops.DUP13: stack_instructions.dup13,
    Ops.DUP14: stack_instructions.dup14,
    Ops.DUP15: stack_instructions.dup15,
    Ops.DUP16: stack_instructions.dup16,
    Ops.SWAP1: stack_instructions.swap1,
    Ops.SWAP2: stack_instructions.swap2,
    Ops.SWAP3: stack_instructions.swap3,
    Ops.SWAP4: stack_instructions.swap4,
    Ops.SWAP5: stack_instructions.swap5,
    Ops.SWAP6: stack_instructions.swap6,
    Ops.SWAP7: stack_instructions.swap7,
    Ops.SWAP8: stack_instructions.swap8,
    Ops.SWAP9: stack_instructions.swap9,
    Ops.SWAP10: stack_instructions.swap10,
    Ops.SWAP11: stack_instructions.swap11,
    Ops.SWAP12: stack_instructions.swap12,
    Ops.SWAP13: stack_instructions.swap13,
    Ops.SWAP14: stack_instructions.swap14,
    Ops.SWAP15: stack_instructions.swap15,
    Ops.SWAP16: stack_instructions.swap16,
    Ops.LOG0: log_instructions.log0,
    Ops.LOG1: log_instructions.log1,
    Ops.LOG2: log_instructions.log2,
    Ops.LOG3: log_instructions.log3,
    Ops.LOG4: log_instructions.log4,
    Ops.CREATE: system_instructions.create,
    Ops.RETURN: system_instructions.return_,
    Ops.CALL: system_instructions.call,
    Ops.CALLCODE: system_instructions.callcode,
    Ops.DELEGATECALL: system_instructions.delegatecall,
    Ops.SELFDESTRUCT: system_instructions.selfdestruct,
    Ops.STATICCALL: system_instructions.staticcall,
    Ops.REVERT: system_instructions.revert,
    Ops.CREATE2: system_instructions.create2,
}