// Copyright 2015-2018 Parity Technologies (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see . //! VM Instructions list and utility functions pub type Instruction = u8; /// Returns true if given instruction is `PUSHN` instruction. pub fn is_push(i: Instruction) -> bool { i >= PUSH1 && i <= PUSH32 } #[test] fn test_is_push() { assert!(is_push(PUSH1)); assert!(is_push(PUSH32)); assert!(!is_push(DUP1)); } /// Returns number of bytes to read for `PUSHN` instruction /// PUSH1 -> 1 pub fn get_push_bytes(i: Instruction) -> usize { assert!(is_push(i), "Only for PUSH instructions."); (i - PUSH1 + 1) as usize } /// Returns number of bytes to read for `PUSHN` instruction or 0. pub fn push_bytes(i: Instruction) -> usize { if is_push(i) { get_push_bytes(i) } else { 0 } } #[test] fn test_get_push_bytes() { assert_eq!(get_push_bytes(PUSH1), 1); assert_eq!(get_push_bytes(PUSH3), 3); assert_eq!(get_push_bytes(PUSH32), 32); } /// Returns stack position of item to duplicate /// DUP1 -> 0 pub fn get_dup_position(i: Instruction) -> usize { assert!(i >= DUP1 && i <= DUP16); (i - DUP1) as usize } #[test] fn test_get_dup_position() { assert_eq!(get_dup_position(DUP1), 0); assert_eq!(get_dup_position(DUP5), 4); assert_eq!(get_dup_position(DUP10), 9); } /// Returns stack position of item to SWAP top with /// SWAP1 -> 1 pub fn get_swap_position(i: Instruction) -> usize { assert!(i >= SWAP1 && i <= SWAP16); (i - SWAP1 + 1) as usize } #[test] fn test_get_swap_position() { assert_eq!(get_swap_position(SWAP1), 1); assert_eq!(get_swap_position(SWAP5), 5); assert_eq!(get_swap_position(SWAP10), 10); } /// Returns number of topics to take from stack /// LOG0 -> 0 pub fn get_log_topics (i: Instruction) -> usize { assert!(i >= LOG0 && i <= LOG4); (i - LOG0) as usize } #[test] fn test_get_log_topics() { assert_eq!(get_log_topics(LOG0), 0); assert_eq!(get_log_topics(LOG2), 2); assert_eq!(get_log_topics(LOG4), 4); } #[derive(PartialEq, Clone, Copy)] pub enum GasPriceTier { /// 0 Zero Zero, /// 2 Quick Base, /// 3 Fastest VeryLow, /// 5 Fast Low, /// 8 Mid Mid, /// 10 Slow High, /// 20 Ext Ext, /// Multiparam or otherwise special Special, /// Invalid Invalid } impl Default for GasPriceTier { fn default() -> Self { GasPriceTier::Invalid } } /// Returns the index in schedule for specific `GasPriceTier` pub fn get_tier_idx (tier: GasPriceTier) -> usize { match tier { GasPriceTier::Zero => 0, GasPriceTier::Base => 1, GasPriceTier::VeryLow => 2, GasPriceTier::Low => 3, GasPriceTier::Mid => 4, GasPriceTier::High => 5, GasPriceTier::Ext => 6, GasPriceTier::Special => 7, GasPriceTier::Invalid => 8 } } /// EVM instruction information. #[derive(Copy, Clone, Default)] pub struct InstructionInfo { /// Mnemonic name. pub name: &'static str, /// Number of stack arguments. pub args: usize, /// Number of returned stack items. pub ret: usize, /// Gas price tier. pub tier: GasPriceTier } impl InstructionInfo { /// Create new instruction info. pub fn new(name: &'static str, args: usize, ret: usize, tier: GasPriceTier) -> Self { InstructionInfo { name: name, args: args, ret: ret, tier: tier } } } lazy_static! { /// Static instruction table. pub static ref INSTRUCTIONS: [InstructionInfo; 0x100] = { let mut arr = [InstructionInfo::default(); 0x100]; arr[STOP as usize] = InstructionInfo::new("STOP", 0, 0, GasPriceTier::Zero); arr[ADD as usize] = InstructionInfo::new("ADD", 2, 1, GasPriceTier::VeryLow); arr[SUB as usize] = InstructionInfo::new("SUB", 2, 1, GasPriceTier::VeryLow); arr[MUL as usize] = InstructionInfo::new("MUL", 2, 1, GasPriceTier::Low); arr[DIV as usize] = InstructionInfo::new("DIV", 2, 1, GasPriceTier::Low); arr[SDIV as usize] = InstructionInfo::new("SDIV", 2, 1, GasPriceTier::Low); arr[MOD as usize] = InstructionInfo::new("MOD", 2, 1, GasPriceTier::Low); arr[SMOD as usize] = InstructionInfo::new("SMOD", 2, 1, GasPriceTier::Low); arr[EXP as usize] = InstructionInfo::new("EXP", 2, 1, GasPriceTier::Special); arr[NOT as usize] = InstructionInfo::new("NOT", 1, 1, GasPriceTier::VeryLow); arr[LT as usize] = InstructionInfo::new("LT", 2, 1, GasPriceTier::VeryLow); arr[GT as usize] = InstructionInfo::new("GT", 2, 1, GasPriceTier::VeryLow); arr[SLT as usize] = InstructionInfo::new("SLT", 2, 1, GasPriceTier::VeryLow); arr[SGT as usize] = InstructionInfo::new("SGT", 2, 1, GasPriceTier::VeryLow); arr[EQ as usize] = InstructionInfo::new("EQ", 2, 1, GasPriceTier::VeryLow); arr[ISZERO as usize] = InstructionInfo::new("ISZERO", 1, 1, GasPriceTier::VeryLow); arr[AND as usize] = InstructionInfo::new("AND", 2, 1, GasPriceTier::VeryLow); arr[OR as usize] = InstructionInfo::new("OR", 2, 1, GasPriceTier::VeryLow); arr[XOR as usize] = InstructionInfo::new("XOR", 2, 1, GasPriceTier::VeryLow); arr[BYTE as usize] = InstructionInfo::new("BYTE", 2, 1, GasPriceTier::VeryLow); arr[SHL as usize] = InstructionInfo::new("SHL", 2, 1, GasPriceTier::VeryLow); arr[SHR as usize] = InstructionInfo::new("SHR", 2, 1, GasPriceTier::VeryLow); arr[SAR as usize] = InstructionInfo::new("SAR", 2, 1, GasPriceTier::VeryLow); arr[ADDMOD as usize] = InstructionInfo::new("ADDMOD", 3, 1, GasPriceTier::Mid); arr[MULMOD as usize] = InstructionInfo::new("MULMOD", 3, 1, GasPriceTier::Mid); arr[SIGNEXTEND as usize] = InstructionInfo::new("SIGNEXTEND", 2, 1, GasPriceTier::Low); arr[RETURNDATASIZE as usize] = InstructionInfo::new("RETURNDATASIZE", 0, 1, GasPriceTier::Base); arr[RETURNDATACOPY as usize] = InstructionInfo::new("RETURNDATACOPY", 3, 0, GasPriceTier::VeryLow); arr[SHA3 as usize] = InstructionInfo::new("SHA3", 2, 1, GasPriceTier::Special); arr[ADDRESS as usize] = InstructionInfo::new("ADDRESS", 0, 1, GasPriceTier::Base); arr[BALANCE as usize] = InstructionInfo::new("BALANCE", 1, 1, GasPriceTier::Special); arr[ORIGIN as usize] = InstructionInfo::new("ORIGIN", 0, 1, GasPriceTier::Base); arr[CALLER as usize] = InstructionInfo::new("CALLER", 0, 1, GasPriceTier::Base); arr[CALLVALUE as usize] = InstructionInfo::new("CALLVALUE", 0, 1, GasPriceTier::Base); arr[CALLDATALOAD as usize] = InstructionInfo::new("CALLDATALOAD", 1, 1, GasPriceTier::VeryLow); arr[CALLDATASIZE as usize] = InstructionInfo::new("CALLDATASIZE", 0, 1, GasPriceTier::Base); arr[CALLDATACOPY as usize] = InstructionInfo::new("CALLDATACOPY", 3, 0, GasPriceTier::VeryLow); arr[CODESIZE as usize] = InstructionInfo::new("CODESIZE", 0, 1, GasPriceTier::Base); arr[CODECOPY as usize] = InstructionInfo::new("CODECOPY", 3, 0, GasPriceTier::VeryLow); arr[GASPRICE as usize] = InstructionInfo::new("GASPRICE", 0, 1, GasPriceTier::Base); arr[EXTCODESIZE as usize] = InstructionInfo::new("EXTCODESIZE", 1, 1, GasPriceTier::Special); arr[EXTCODECOPY as usize] = InstructionInfo::new("EXTCODECOPY", 4, 0, GasPriceTier::Special); arr[BLOCKHASH as usize] = InstructionInfo::new("BLOCKHASH", 1, 1, GasPriceTier::Ext); arr[COINBASE as usize] = InstructionInfo::new("COINBASE", 0, 1, GasPriceTier::Base); arr[TIMESTAMP as usize] = InstructionInfo::new("TIMESTAMP", 0, 1, GasPriceTier::Base); arr[NUMBER as usize] = InstructionInfo::new("NUMBER", 0, 1, GasPriceTier::Base); arr[DIFFICULTY as usize] = InstructionInfo::new("DIFFICULTY", 0, 1, GasPriceTier::Base); arr[GASLIMIT as usize] = InstructionInfo::new("GASLIMIT", 0, 1, GasPriceTier::Base); arr[POP as usize] = InstructionInfo::new("POP", 1, 0, GasPriceTier::Base); arr[MLOAD as usize] = InstructionInfo::new("MLOAD", 1, 1, GasPriceTier::VeryLow); arr[MSTORE as usize] = InstructionInfo::new("MSTORE", 2, 0, GasPriceTier::VeryLow); arr[MSTORE8 as usize] = InstructionInfo::new("MSTORE8", 2, 0, GasPriceTier::VeryLow); arr[SLOAD as usize] = InstructionInfo::new("SLOAD", 1, 1, GasPriceTier::Special); arr[SSTORE as usize] = InstructionInfo::new("SSTORE", 2, 0, GasPriceTier::Special); arr[JUMP as usize] = InstructionInfo::new("JUMP", 1, 0, GasPriceTier::Mid); arr[JUMPI as usize] = InstructionInfo::new("JUMPI", 2, 0, GasPriceTier::High); arr[PC as usize] = InstructionInfo::new("PC", 0, 1, GasPriceTier::Base); arr[MSIZE as usize] = InstructionInfo::new("MSIZE", 0, 1, GasPriceTier::Base); arr[GAS as usize] = InstructionInfo::new("GAS", 0, 1, GasPriceTier::Base); arr[JUMPDEST as usize] = InstructionInfo::new("JUMPDEST", 0, 0, GasPriceTier::Special); arr[PUSH1 as usize] = InstructionInfo::new("PUSH1", 0, 1, GasPriceTier::VeryLow); arr[PUSH2 as usize] = InstructionInfo::new("PUSH2", 0, 1, GasPriceTier::VeryLow); arr[PUSH3 as usize] = InstructionInfo::new("PUSH3", 0, 1, GasPriceTier::VeryLow); arr[PUSH4 as usize] = InstructionInfo::new("PUSH4", 0, 1, GasPriceTier::VeryLow); arr[PUSH5 as usize] = InstructionInfo::new("PUSH5", 0, 1, GasPriceTier::VeryLow); arr[PUSH6 as usize] = InstructionInfo::new("PUSH6", 0, 1, GasPriceTier::VeryLow); arr[PUSH7 as usize] = InstructionInfo::new("PUSH7", 0, 1, GasPriceTier::VeryLow); arr[PUSH8 as usize] = InstructionInfo::new("PUSH8", 0, 1, GasPriceTier::VeryLow); arr[PUSH9 as usize] = InstructionInfo::new("PUSH9", 0, 1, GasPriceTier::VeryLow); arr[PUSH10 as usize] = InstructionInfo::new("PUSH10", 0, 1, GasPriceTier::VeryLow); arr[PUSH11 as usize] = InstructionInfo::new("PUSH11", 0, 1, GasPriceTier::VeryLow); arr[PUSH12 as usize] = InstructionInfo::new("PUSH12", 0, 1, GasPriceTier::VeryLow); arr[PUSH13 as usize] = InstructionInfo::new("PUSH13", 0, 1, GasPriceTier::VeryLow); arr[PUSH14 as usize] = InstructionInfo::new("PUSH14", 0, 1, GasPriceTier::VeryLow); arr[PUSH15 as usize] = InstructionInfo::new("PUSH15", 0, 1, GasPriceTier::VeryLow); arr[PUSH16 as usize] = InstructionInfo::new("PUSH16", 0, 1, GasPriceTier::VeryLow); arr[PUSH17 as usize] = InstructionInfo::new("PUSH17", 0, 1, GasPriceTier::VeryLow); arr[PUSH18 as usize] = InstructionInfo::new("PUSH18", 0, 1, GasPriceTier::VeryLow); arr[PUSH19 as usize] = InstructionInfo::new("PUSH19", 0, 1, GasPriceTier::VeryLow); arr[PUSH20 as usize] = InstructionInfo::new("PUSH20", 0, 1, GasPriceTier::VeryLow); arr[PUSH21 as usize] = InstructionInfo::new("PUSH21", 0, 1, GasPriceTier::VeryLow); arr[PUSH22 as usize] = InstructionInfo::new("PUSH22", 0, 1, GasPriceTier::VeryLow); arr[PUSH23 as usize] = InstructionInfo::new("PUSH23", 0, 1, GasPriceTier::VeryLow); arr[PUSH24 as usize] = InstructionInfo::new("PUSH24", 0, 1, GasPriceTier::VeryLow); arr[PUSH25 as usize] = InstructionInfo::new("PUSH25", 0, 1, GasPriceTier::VeryLow); arr[PUSH26 as usize] = InstructionInfo::new("PUSH26", 0, 1, GasPriceTier::VeryLow); arr[PUSH27 as usize] = InstructionInfo::new("PUSH27", 0, 1, GasPriceTier::VeryLow); arr[PUSH28 as usize] = InstructionInfo::new("PUSH28", 0, 1, GasPriceTier::VeryLow); arr[PUSH29 as usize] = InstructionInfo::new("PUSH29", 0, 1, GasPriceTier::VeryLow); arr[PUSH30 as usize] = InstructionInfo::new("PUSH30", 0, 1, GasPriceTier::VeryLow); arr[PUSH31 as usize] = InstructionInfo::new("PUSH31", 0, 1, GasPriceTier::VeryLow); arr[PUSH32 as usize] = InstructionInfo::new("PUSH32", 0, 1, GasPriceTier::VeryLow); arr[DUP1 as usize] = InstructionInfo::new("DUP1", 1, 2, GasPriceTier::VeryLow); arr[DUP2 as usize] = InstructionInfo::new("DUP2", 2, 3, GasPriceTier::VeryLow); arr[DUP3 as usize] = InstructionInfo::new("DUP3", 3, 4, GasPriceTier::VeryLow); arr[DUP4 as usize] = InstructionInfo::new("DUP4", 4, 5, GasPriceTier::VeryLow); arr[DUP5 as usize] = InstructionInfo::new("DUP5", 5, 6, GasPriceTier::VeryLow); arr[DUP6 as usize] = InstructionInfo::new("DUP6", 6, 7, GasPriceTier::VeryLow); arr[DUP7 as usize] = InstructionInfo::new("DUP7", 7, 8, GasPriceTier::VeryLow); arr[DUP8 as usize] = InstructionInfo::new("DUP8", 8, 9, GasPriceTier::VeryLow); arr[DUP9 as usize] = InstructionInfo::new("DUP9", 9, 10, GasPriceTier::VeryLow); arr[DUP10 as usize] = InstructionInfo::new("DUP10", 10, 11, GasPriceTier::VeryLow); arr[DUP11 as usize] = InstructionInfo::new("DUP11", 11, 12, GasPriceTier::VeryLow); arr[DUP12 as usize] = InstructionInfo::new("DUP12", 12, 13, GasPriceTier::VeryLow); arr[DUP13 as usize] = InstructionInfo::new("DUP13", 13, 14, GasPriceTier::VeryLow); arr[DUP14 as usize] = InstructionInfo::new("DUP14", 14, 15, GasPriceTier::VeryLow); arr[DUP15 as usize] = InstructionInfo::new("DUP15", 15, 16, GasPriceTier::VeryLow); arr[DUP16 as usize] = InstructionInfo::new("DUP16", 16, 17, GasPriceTier::VeryLow); arr[SWAP1 as usize] = InstructionInfo::new("SWAP1", 2, 2, GasPriceTier::VeryLow); arr[SWAP2 as usize] = InstructionInfo::new("SWAP2", 3, 3, GasPriceTier::VeryLow); arr[SWAP3 as usize] = InstructionInfo::new("SWAP3", 4, 4, GasPriceTier::VeryLow); arr[SWAP4 as usize] = InstructionInfo::new("SWAP4", 5, 5, GasPriceTier::VeryLow); arr[SWAP5 as usize] = InstructionInfo::new("SWAP5", 6, 6, GasPriceTier::VeryLow); arr[SWAP6 as usize] = InstructionInfo::new("SWAP6", 7, 7, GasPriceTier::VeryLow); arr[SWAP7 as usize] = InstructionInfo::new("SWAP7", 8, 8, GasPriceTier::VeryLow); arr[SWAP8 as usize] = InstructionInfo::new("SWAP8", 9, 9, GasPriceTier::VeryLow); arr[SWAP9 as usize] = InstructionInfo::new("SWAP9", 10, 10, GasPriceTier::VeryLow); arr[SWAP10 as usize] = InstructionInfo::new("SWAP10", 11, 11, GasPriceTier::VeryLow); arr[SWAP11 as usize] = InstructionInfo::new("SWAP11", 12, 12, GasPriceTier::VeryLow); arr[SWAP12 as usize] = InstructionInfo::new("SWAP12", 13, 13, GasPriceTier::VeryLow); arr[SWAP13 as usize] = InstructionInfo::new("SWAP13", 14, 14, GasPriceTier::VeryLow); arr[SWAP14 as usize] = InstructionInfo::new("SWAP14", 15, 15, GasPriceTier::VeryLow); arr[SWAP15 as usize] = InstructionInfo::new("SWAP15", 16, 16, GasPriceTier::VeryLow); arr[SWAP16 as usize] = InstructionInfo::new("SWAP16", 17, 17, GasPriceTier::VeryLow); arr[LOG0 as usize] = InstructionInfo::new("LOG0", 2, 0, GasPriceTier::Special); arr[LOG1 as usize] = InstructionInfo::new("LOG1", 3, 0, GasPriceTier::Special); arr[LOG2 as usize] = InstructionInfo::new("LOG2", 4, 0, GasPriceTier::Special); arr[LOG3 as usize] = InstructionInfo::new("LOG3", 5, 0, GasPriceTier::Special); arr[LOG4 as usize] = InstructionInfo::new("LOG4", 6, 0, GasPriceTier::Special); arr[CREATE as usize] = InstructionInfo::new("CREATE", 3, 1, GasPriceTier::Special); arr[CALL as usize] = InstructionInfo::new("CALL", 7, 1, GasPriceTier::Special); arr[CALLCODE as usize] = InstructionInfo::new("CALLCODE", 7, 1, GasPriceTier::Special); arr[RETURN as usize] = InstructionInfo::new("RETURN", 2, 0, GasPriceTier::Zero); arr[DELEGATECALL as usize] = InstructionInfo::new("DELEGATECALL", 6, 1, GasPriceTier::Special); arr[STATICCALL as usize] = InstructionInfo::new("STATICCALL", 6, 1, GasPriceTier::Special); arr[SUICIDE as usize] = InstructionInfo::new("SUICIDE", 1, 0, GasPriceTier::Special); arr[CREATE2 as usize] = InstructionInfo::new("CREATE2", 3, 1, GasPriceTier::Special); arr[REVERT as usize] = InstructionInfo::new("REVERT", 2, 0, GasPriceTier::Zero); arr }; } /// Virtual machine bytecode instruction. /// halts execution pub const STOP: Instruction = 0x00; /// addition operation pub const ADD: Instruction = 0x01; /// mulitplication operation pub const MUL: Instruction = 0x02; /// subtraction operation pub const SUB: Instruction = 0x03; /// integer division operation pub const DIV: Instruction = 0x04; /// signed integer division operation pub const SDIV: Instruction = 0x05; /// modulo remainder operation pub const MOD: Instruction = 0x06; /// signed modulo remainder operation pub const SMOD: Instruction = 0x07; /// unsigned modular addition pub const ADDMOD: Instruction = 0x08; /// unsigned modular multiplication pub const MULMOD: Instruction = 0x09; /// exponential operation pub const EXP: Instruction = 0x0a; /// extend length of signed integer pub const SIGNEXTEND: Instruction = 0x0b; /// less-than comparision pub const LT: Instruction = 0x10; /// greater-than comparision pub const GT: Instruction = 0x11; /// signed less-than comparision pub const SLT: Instruction = 0x12; /// signed greater-than comparision pub const SGT: Instruction = 0x13; /// equality comparision pub const EQ: Instruction = 0x14; /// simple not operator pub const ISZERO: Instruction = 0x15; /// bitwise AND operation pub const AND: Instruction = 0x16; /// bitwise OR operation pub const OR: Instruction = 0x17; /// bitwise XOR operation pub const XOR: Instruction = 0x18; /// bitwise NOT opertation pub const NOT: Instruction = 0x19; /// retrieve single byte from word pub const BYTE: Instruction = 0x1a; /// shift left operation pub const SHL: Instruction = 0x1b; /// logical shift right operation pub const SHR: Instruction = 0x1c; /// arithmetic shift right operation pub const SAR: Instruction = 0x1d; /// compute SHA3-256 hash pub const SHA3: Instruction = 0x20; /// get address of currently executing account pub const ADDRESS: Instruction = 0x30; /// get balance of the given account pub const BALANCE: Instruction = 0x31; /// get execution origination address pub const ORIGIN: Instruction = 0x32; /// get caller address pub const CALLER: Instruction = 0x33; /// get deposited value by the instruction/transaction responsible for this execution pub const CALLVALUE: Instruction = 0x34; /// get input data of current environment pub const CALLDATALOAD: Instruction = 0x35; /// get size of input data in current environment pub const CALLDATASIZE: Instruction = 0x36; /// copy input data in current environment to memory pub const CALLDATACOPY: Instruction = 0x37; /// get size of code running in current environment pub const CODESIZE: Instruction = 0x38; /// copy code running in current environment to memory pub const CODECOPY: Instruction = 0x39; /// get price of gas in current environment pub const GASPRICE: Instruction = 0x3a; /// get external code size (from another contract) pub const EXTCODESIZE: Instruction = 0x3b; /// copy external code (from another contract) pub const EXTCODECOPY: Instruction = 0x3c; /// get the size of the return data buffer for the last call pub const RETURNDATASIZE: Instruction = 0x3d; /// copy return data buffer to memory pub const RETURNDATACOPY: Instruction = 0x3e; /// get hash of most recent complete block pub const BLOCKHASH: Instruction = 0x40; /// get the block's coinbase address pub const COINBASE: Instruction = 0x41; /// get the block's timestamp pub const TIMESTAMP: Instruction = 0x42; /// get the block's number pub const NUMBER: Instruction = 0x43; /// get the block's difficulty pub const DIFFICULTY: Instruction = 0x44; /// get the block's gas limit pub const GASLIMIT: Instruction = 0x45; /// remove item from stack pub const POP: Instruction = 0x50; /// load word from memory pub const MLOAD: Instruction = 0x51; /// save word to memory pub const MSTORE: Instruction = 0x52; /// save byte to memory pub const MSTORE8: Instruction = 0x53; /// load word from storage pub const SLOAD: Instruction = 0x54; /// save word to storage pub const SSTORE: Instruction = 0x55; /// alter the program counter pub const JUMP: Instruction = 0x56; /// conditionally alter the program counter pub const JUMPI: Instruction = 0x57; /// get the program counter pub const PC: Instruction = 0x58; /// get the size of active memory pub const MSIZE: Instruction = 0x59; /// get the amount of available gas pub const GAS: Instruction = 0x5a; /// set a potential jump destination pub const JUMPDEST: Instruction = 0x5b; /// place 1 byte item on stack pub const PUSH1: Instruction = 0x60; /// place 2 byte item on stack pub const PUSH2: Instruction = 0x61; /// place 3 byte item on stack pub const PUSH3: Instruction = 0x62; /// place 4 byte item on stack pub const PUSH4: Instruction = 0x63; /// place 5 byte item on stack pub const PUSH5: Instruction = 0x64; /// place 6 byte item on stack pub const PUSH6: Instruction = 0x65; /// place 7 byte item on stack pub const PUSH7: Instruction = 0x66; /// place 8 byte item on stack pub const PUSH8: Instruction = 0x67; /// place 9 byte item on stack pub const PUSH9: Instruction = 0x68; /// place 10 byte item on stack pub const PUSH10: Instruction = 0x69; /// place 11 byte item on stack pub const PUSH11: Instruction = 0x6a; /// place 12 byte item on stack pub const PUSH12: Instruction = 0x6b; /// place 13 byte item on stack pub const PUSH13: Instruction = 0x6c; /// place 14 byte item on stack pub const PUSH14: Instruction = 0x6d; /// place 15 byte item on stack pub const PUSH15: Instruction = 0x6e; /// place 16 byte item on stack pub const PUSH16: Instruction = 0x6f; /// place 17 byte item on stack pub const PUSH17: Instruction = 0x70; /// place 18 byte item on stack pub const PUSH18: Instruction = 0x71; /// place 19 byte item on stack pub const PUSH19: Instruction = 0x72; /// place 20 byte item on stack pub const PUSH20: Instruction = 0x73; /// place 21 byte item on stack pub const PUSH21: Instruction = 0x74; /// place 22 byte item on stack pub const PUSH22: Instruction = 0x75; /// place 23 byte item on stack pub const PUSH23: Instruction = 0x76; /// place 24 byte item on stack pub const PUSH24: Instruction = 0x77; /// place 25 byte item on stack pub const PUSH25: Instruction = 0x78; /// place 26 byte item on stack pub const PUSH26: Instruction = 0x79; /// place 27 byte item on stack pub const PUSH27: Instruction = 0x7a; /// place 28 byte item on stack pub const PUSH28: Instruction = 0x7b; /// place 29 byte item on stack pub const PUSH29: Instruction = 0x7c; /// place 30 byte item on stack pub const PUSH30: Instruction = 0x7d; /// place 31 byte item on stack pub const PUSH31: Instruction = 0x7e; /// place 32 byte item on stack pub const PUSH32: Instruction = 0x7f; /// copies the highest item in the stack to the top of the stack pub const DUP1: Instruction = 0x80; /// copies the second highest item in the stack to the top of the stack pub const DUP2: Instruction = 0x81; /// copies the third highest item in the stack to the top of the stack pub const DUP3: Instruction = 0x82; /// copies the 4th highest item in the stack to the top of the stack pub const DUP4: Instruction = 0x83; /// copies the 5th highest item in the stack to the top of the stack pub const DUP5: Instruction = 0x84; /// copies the 6th highest item in the stack to the top of the stack pub const DUP6: Instruction = 0x85; /// copies the 7th highest item in the stack to the top of the stack pub const DUP7: Instruction = 0x86; /// copies the 8th highest item in the stack to the top of the stack pub const DUP8: Instruction = 0x87; /// copies the 9th highest item in the stack to the top of the stack pub const DUP9: Instruction = 0x88; /// copies the 10th highest item in the stack to the top of the stack pub const DUP10: Instruction = 0x89; /// copies the 11th highest item in the stack to the top of the stack pub const DUP11: Instruction = 0x8a; /// copies the 12th highest item in the stack to the top of the stack pub const DUP12: Instruction = 0x8b; /// copies the 13th highest item in the stack to the top of the stack pub const DUP13: Instruction = 0x8c; /// copies the 14th highest item in the stack to the top of the stack pub const DUP14: Instruction = 0x8d; /// copies the 15th highest item in the stack to the top of the stack pub const DUP15: Instruction = 0x8e; /// copies the 16th highest item in the stack to the top of the stack pub const DUP16: Instruction = 0x8f; /// swaps the highest and second highest value on the stack pub const SWAP1: Instruction = 0x90; /// swaps the highest and third highest value on the stack pub const SWAP2: Instruction = 0x91; /// swaps the highest and 4th highest value on the stack pub const SWAP3: Instruction = 0x92; /// swaps the highest and 5th highest value on the stack pub const SWAP4: Instruction = 0x93; /// swaps the highest and 6th highest value on the stack pub const SWAP5: Instruction = 0x94; /// swaps the highest and 7th highest value on the stack pub const SWAP6: Instruction = 0x95; /// swaps the highest and 8th highest value on the stack pub const SWAP7: Instruction = 0x96; /// swaps the highest and 9th highest value on the stack pub const SWAP8: Instruction = 0x97; /// swaps the highest and 10th highest value on the stack pub const SWAP9: Instruction = 0x98; /// swaps the highest and 11th highest value on the stack pub const SWAP10: Instruction = 0x99; /// swaps the highest and 12th highest value on the stack pub const SWAP11: Instruction = 0x9a; /// swaps the highest and 13th highest value on the stack pub const SWAP12: Instruction = 0x9b; /// swaps the highest and 14th highest value on the stack pub const SWAP13: Instruction = 0x9c; /// swaps the highest and 15th highest value on the stack pub const SWAP14: Instruction = 0x9d; /// swaps the highest and 16th highest value on the stack pub const SWAP15: Instruction = 0x9e; /// swaps the highest and 17th highest value on the stack pub const SWAP16: Instruction = 0x9f; /// Makes a log entry; no topics. pub const LOG0: Instruction = 0xa0; /// Makes a log entry; 1 topic. pub const LOG1: Instruction = 0xa1; /// Makes a log entry; 2 topics. pub const LOG2: Instruction = 0xa2; /// Makes a log entry; 3 topics. pub const LOG3: Instruction = 0xa3; /// Makes a log entry; 4 topics. pub const LOG4: Instruction = 0xa4; /// Maximal number of topics for log instructions pub const MAX_NO_OF_TOPICS : usize = 4; /// create a new account with associated code pub const CREATE: Instruction = 0xf0; /// message-call into an account pub const CALL: Instruction = 0xf1; /// message-call with another account's code only pub const CALLCODE: Instruction = 0xf2; /// halt execution returning output data pub const RETURN: Instruction = 0xf3; /// like CALLCODE but keeps caller's value and sender pub const DELEGATECALL: Instruction = 0xf4; /// create a new account and set creation address to sha3(sender + sha3(init code)) % 2**160 pub const CREATE2: Instruction = 0xfb; /// stop execution and revert state changes. Return output data. pub const REVERT: Instruction = 0xfd; /// like CALL but it does not take value, nor modify the state pub const STATICCALL: Instruction = 0xfa; /// halt execution and register account for later deletion pub const SUICIDE: Instruction = 0xff;