Opcodes für die EVM
Dies ist eine aktualisierte Version der EVM-Referenzseite unter wolflo/evm-opcodes (öffnet in einem neuen Tab). Sie stützt sich auch auf das Yellow Paper (öffnet in einem neuen Tab), das Jello Paper (öffnet in einem neuen Tab) und die geth (öffnet in einem neuen Tab)-Implementierung. Dies soll eine zugängliche Referenz sein, ist aber nicht besonders streng. Wenn Sie sich der Richtigkeit sicher sein und jeden Randfall kennen möchten, ist die Verwendung des Jello Papers oder einer Client-Implementierung ratsam.
Suchen Sie nach einer interaktiven Referenz? Schauen Sie sich evm.codes (öffnet in einem neuen Tab) an.
Für Operationen mit dynamischen Gaskosten siehe gas.md (öffnet in einem neuen Tab).
💡 Kurzer Tipp: Um ganze Zeilen anzuzeigen, verwenden Sie auf dem Desktop [Shift] + Scrollen, um horizontal zu scrollen.
| Stack | Name | Gas | Anfänglicher Stack | Resultierender Stack | Mem / Storage | Hinweise |
|---|---|---|---|---|---|---|
| 00 | STOP | 0 | Ausführung anhalten | |||
| 01 | ADD | 3 | a, b | a + b | (u)int256-Addition modulo 2**256 | |
| 02 | MUL | 5 | a, b | a * b | (u)int256-Multiplikation modulo 2**256 | |
| 03 | SUB | 3 | a, b | a - b | (u)int256-Subtraktion modulo 2**256 | |
| 04 | DIV | 5 | a, b | a // b | uint256-Division | |
| 05 | SDIV | 5 | a, b | a // b | int256-Division | |
| 06 | MOD | 5 | a, b | a % b | uint256-Modulo | |
| 07 | SMOD | 5 | a, b | a % b | int256-Modulo | |
| 08 | ADDMOD | 8 | a, b, N | (a + b) % N | (u)int256-Addition modulo N | |
| 09 | MULMOD | 8 | a, b, N | (a * b) % N | (u)int256-Multiplikation modulo N | |
| 0A | EXP | A1 (öffnet in einem neuen Tab) | a, b | a ** b | uint256-Potenzierung modulo 2**256 | |
| 0B | SIGNEXTEND | 5 | b, x | SIGNEXTEND(x, b) | Vorzeichenerweiterung (öffnet in einem neuen Tab) von x von (b+1) Bytes auf 32 Bytes | |
| 0C-0F | ungültig | |||||
| 10 | LT | 3 | a, b | a < b | uint256 kleiner als | |
| 11 | GT | 3 | a, b | a > b | uint256 größer als | |
| 12 | SLT | 3 | a, b | a < b | int256 kleiner als | |
| 13 | SGT | 3 | a, b | a > b | int256 größer als | |
| 14 | EQ | 3 | a, b | a == b | (u)int256-Gleichheit | |
| 15 | ISZERO | 3 | a | a == 0 | (u)int256 ist null | |
| 16 | AND | 3 | a, b | a && b | bitweises UND | |
| 17 | OR | 3 | a, b | a || b | bitweises ODER | |
| 18 | XOR | 3 | a, b | a ^ b | bitweises XOR | |
| 19 | NOT | 3 | a | ~a | bitweises NICHT | |
| 1A | BYTE | 3 | i, x | (x >> (248 - i * 8)) && 0xFF | i-tes Byte von (u)int256 x, von links | |
| 1B | SHL | 3 | shift, val | val << shift | Linksverschiebung | |
| 1C | SHR | 3 | shift, val | val >> shift | logische Rechtsverschiebung | |
| 1D | SAR | 3 | shift, val | val >> shift | arithmetische Rechtsverschiebung | |
| 1E-1F | ungültig | |||||
| 20 | KECCAK256 | A2 (öffnet in einem neuen Tab) | ost, len | keccak256(mem[ost:ost+len-1]) | keccak256 | |
| 21-2F | ungültig | |||||
| 30 | ADDRESS | 2 | . | address(this) | Adresse des ausführenden Vertrags | |
| 31 | BALANCE | A5 (öffnet in einem neuen Tab) | addr | addr.balance | Kontostand, in Wei | |
| 32 | ORIGIN | 2 | . | tx.origin | Adresse, von der die Transaktion ausging | |
| 33 | CALLER | 2 | . | msg.sender | Adresse des msg-Absenders | |
| 34 | CALLVALUE | 2 | . | msg.value | msg-Wert, in Wei | |
| 35 | CALLDATALOAD | 3 | idx | msg.data[idx:idx+32] | Wort aus msg-Daten bei Index idx lesen | |
| 36 | CALLDATASIZE | 2 | . | len(msg.data) | Länge der msg-Daten, in Bytes | |
| 37 | CALLDATACOPY | A3 (öffnet in einem neuen Tab) | dstOst, ost, len | . | mem[dstOst:dstOst+len-1] := msg.data[ost:ost+len-1] | msg-Daten kopieren |
| 38 | CODESIZE | 2 | . | len(this.code) | Länge des Codes des ausführenden Vertrags, in Bytes | |
| 39 | CODECOPY | A3 (öffnet in einem neuen Tab) | dstOst, ost, len | . | mem[dstOst:dstOst+len-1] := this.code[ost:ost+len-1] | |
| 3A | GASPRICE | 2 | . | tx.gasprice | Gaspreis der Transaktion, in Wei pro Einheit Gas ** (öffnet in einem neuen Tab) | |
| 3B | EXTCODESIZE | A5 (öffnet in einem neuen Tab) | addr | len(addr.code) | Größe des Codes an der Adresse, in Bytes | |
| 3C | EXTCODECOPY | A4 (öffnet in einem neuen Tab) | addr, dstOst, ost, len | . | mem[dstOst:dstOst+len-1] := addr.code[ost:ost+len-1] | Code von addr kopieren |
| 3D | RETURNDATASIZE | 2 | . | size | Größe der zurückgegebenen Daten vom letzten externen Aufruf, in Bytes | |
| 3E | RETURNDATACOPY | A3 (öffnet in einem neuen Tab) | dstOst, ost, len | . | mem[dstOst:dstOst+len-1] := returndata[ost:ost+len-1] | zurückgegebene Daten vom letzten externen Aufruf kopieren |
| 3F | EXTCODEHASH | A5 (öffnet in einem neuen Tab) | addr | hash | hash = addr.exists ? keccak256(addr.code) : 0 | |
| 40 | BLOCKHASH | 20 | blockNum | blockHash(blockNum) | ||
| 41 | COINBASE | 2 | . | block.coinbase | Adresse des Proposers des aktuellen Blocks | |
| 42 | TIMESTAMP | 2 | . | block.timestamp | Zeitstempel des aktuellen Blocks | |
| 43 | NUMBER | 2 | . | block.number | Nummer des aktuellen Blocks | |
| 44 | PREVRANDAO | 2 | . | randomness beacon | Zufälligkeits-Beacon | |
| 45 | GASLIMIT | 2 | . | block.gaslimit | Gaslimit des aktuellen Blocks | |
| 46 | CHAINID | 2 | . | chain_id | aktuelle Chain-ID (öffnet in einem neuen Tab) auf den Stack legen | |
| 47 | SELFBALANCE | 5 | . | address(this).balance | Kontostand des ausführenden Vertrags, in Wei | |
| 48 | BASEFEE | 2 | . | block.basefee | Grundgebühr des aktuellen Blocks | |
| 49 | BLOBHASH | 3 | idx | tx.blob_versioned_hashes[idx] | EIP-4844 (öffnet in einem neuen Tab) | |
| 4A | BLOBBASEFEE | 2 | . | block.blobbasefee | Blob-Grundgebühr des aktuellen Blocks (EIP-7516 (öffnet in einem neuen Tab)) | |
| 4B-4F | ungültig | |||||
| 50 | POP | 2 | _anon | . | Element von der Spitze des Stacks entfernen und verwerfen | |
| 51 | MLOAD | 3* (öffnet in einem neuen Tab) | ost | mem[ost:ost+32] | Wort aus dem Speicher bei Offset ost lesen | |
| 52 | MSTORE | 3* (öffnet in einem neuen Tab) | ost, val | . | mem[ost:ost+32] := val | ein Wort in den Speicher schreiben |
| 53 | MSTORE8 | 3* (öffnet in einem neuen Tab) | ost, val | . | mem[ost] := val && 0xFF | ein einzelnes Byte in den Speicher schreiben |
| 54 | SLOAD | A6 (öffnet in einem neuen Tab) | key | storage[key] | Wort aus dem Storage lesen | |
| 55 | SSTORE | A7 (öffnet in einem neuen Tab) | key, val | . | storage[key] := val | Wort in den Storage schreiben |
| 56 | JUMP | 8 | dst | . | $pc := dst markiert, dass pc nur zugewiesen wird, wenn dst ein gültiges jumpdest ist | |
| 57 | JUMPI | 10 | dst, condition | . | $pc := condition ? dst : $pc + 1 | |
| 58 | PC | 2 | . | $pc | Programmzähler | |
| 59 | MSIZE | 2 | . | len(mem) | Größe des Speichers im aktuellen Ausführungskontext, in Bytes | |
| 5A | GAS | 2 | . | gasRemaining | ||
| 5B | JUMPDEST | 1 | gültiges Sprungziel markieren | ein gültiges Sprungziel, zum Beispiel ein Sprungziel, das nicht innerhalb der Push-Daten liegt | ||
| 5C | TLOAD | 100 | key | tstorage[key] | Wort aus dem transienten Storage lesen (EIP-1153 (öffnet in einem neuen Tab)) | |
| 5D | TSTORE | 100 | key, val | . | tstorage[key] := val | Wort in den transienten Storage schreiben (EIP-1153 (öffnet in einem neuen Tab)) |
| 5E | MCOPY | 3+3*words+A0 (öffnet in einem neuen Tab) | dstOst, ost, len | . | mem[dstOst] := mem[ost:ost+len] | Speicher von einem Bereich in einen anderen kopieren (EIP-5656 (öffnet in einem neuen Tab)) |
| 5F | PUSH0 | 2 | . | uint8 | den konstanten Wert 0 auf den Stack legen | |
| 60 | PUSH1 | 3 | . | uint8 | 1-Byte-Wert auf den Stack legen | |
| 61 | PUSH2 | 3 | . | uint16 | 2-Byte-Wert auf den Stack legen | |
| 62 | PUSH3 | 3 | . | uint24 | 3-Byte-Wert auf den Stack legen | |
| 63 | PUSH4 | 3 | . | uint32 | 4-Byte-Wert auf den Stack legen | |
| 64 | PUSH5 | 3 | . | uint40 | 5-Byte-Wert auf den Stack legen | |
| 65 | PUSH6 | 3 | . | uint48 | 6-Byte-Wert auf den Stack legen | |
| 66 | PUSH7 | 3 | . | uint56 | 7-Byte-Wert auf den Stack legen | |
| 67 | PUSH8 | 3 | . | uint64 | 8-Byte-Wert auf den Stack legen | |
| 68 | PUSH9 | 3 | . | uint72 | 9-Byte-Wert auf den Stack legen | |
| 69 | PUSH10 | 3 | . | uint80 | 10-Byte-Wert auf den Stack legen | |
| 6A | PUSH11 | 3 | . | uint88 | 11-Byte-Wert auf den Stack legen | |
| 6B | PUSH12 | 3 | . | uint96 | 12-Byte-Wert auf den Stack legen | |
| 6C | PUSH13 | 3 | . | uint104 | 13-Byte-Wert auf den Stack legen | |
| 6D | PUSH14 | 3 | . | uint112 | 14-Byte-Wert auf den Stack legen | |
| 6E | PUSH15 | 3 | . | uint120 | 15-Byte-Wert auf den Stack legen | |
| 6F | PUSH16 | 3 | . | uint128 | 16-Byte-Wert auf den Stack legen | |
| 70 | PUSH17 | 3 | . | uint136 | 17-Byte-Wert auf den Stack legen | |
| 71 | PUSH18 | 3 | . | uint144 | 18-Byte-Wert auf den Stack legen | |
| 72 | PUSH19 | 3 | . | uint152 | 19-Byte-Wert auf den Stack legen | |
| 73 | PUSH20 | 3 | . | uint160 | 20-Byte-Wert auf den Stack legen | |
| 74 | PUSH21 | 3 | . | uint168 | 21-Byte-Wert auf den Stack legen | |
| 75 | PUSH22 | 3 | . | uint176 | 22-Byte-Wert auf den Stack legen | |
| 76 | PUSH23 | 3 | . | uint184 | 23-Byte-Wert auf den Stack legen | |
| 77 | PUSH24 | 3 | . | uint192 | 24-Byte-Wert auf den Stack legen | |
| 78 | PUSH25 | 3 | . | uint200 | 25-Byte-Wert auf den Stack legen | |
| 79 | PUSH26 | 3 | . | uint208 | 26-Byte-Wert auf den Stack legen | |
| 7A | PUSH27 | 3 | . | uint216 | 27-Byte-Wert auf den Stack legen | |
| 7B | PUSH28 | 3 | . | uint224 | 28-Byte-Wert auf den Stack legen | |
| 7C | PUSH29 | 3 | . | uint232 | 29-Byte-Wert auf den Stack legen | |
| 7D | PUSH30 | 3 | . | uint240 | 30-Byte-Wert auf den Stack legen | |
| 7E | PUSH31 | 3 | . | uint248 | 31-Byte-Wert auf den Stack legen | |
| 7F | PUSH32 | 3 | . | uint256 | 32-Byte-Wert auf den Stack legen | |
| 80 | DUP1 | 3 | a | a, a | 1. Wert auf dem Stack klonen | |
| 81 | DUP2 | 3 | _, a | a, _, a | 2. Wert auf dem Stack klonen | |
| 82 | DUP3 | 3 | _, _, a | a, _, _, a | 3. Wert auf dem Stack klonen | |
| 83 | DUP4 | 3 | _, _, _, a | a, _, _, _, a | 4. Wert auf dem Stack klonen | |
| 84 | DUP5 | 3 | ..., a | a, ..., a | 5. Wert auf dem Stack klonen | |
| 85 | DUP6 | 3 | ..., a | a, ..., a | 6. Wert auf dem Stack klonen | |
| 86 | DUP7 | 3 | ..., a | a, ..., a | 7. Wert auf dem Stack klonen | |
| 87 | DUP8 | 3 | ..., a | a, ..., a | 8. Wert auf dem Stack klonen | |
| 88 | DUP9 | 3 | ..., a | a, ..., a | 9. Wert auf dem Stack klonen | |
| 89 | DUP10 | 3 | ..., a | a, ..., a | 10. Wert auf dem Stack klonen | |
| 8A | DUP11 | 3 | ..., a | a, ..., a | 11. Wert auf dem Stack klonen | |
| 8B | DUP12 | 3 | ..., a | a, ..., a | 12. Wert auf dem Stack klonen | |
| 8C | DUP13 | 3 | ..., a | a, ..., a | 13. Wert auf dem Stack klonen | |
| 8D | DUP14 | 3 | ..., a | a, ..., a | 14. Wert auf dem Stack klonen | |
| 8E | DUP15 | 3 | ..., a | a, ..., a | 15. Wert auf dem Stack klonen | |
| 8F | DUP16 | 3 | ..., a | a, ..., a | 16. Wert auf dem Stack klonen | |
| 90 | SWAP1 | 3 | a, b | b, a | ||
| 91 | SWAP2 | 3 | a, _, b | b, _, a | ||
| 92 | SWAP3 | 3 | a, _, _, b | b, _, _, a | ||
| 93 | SWAP4 | 3 | a, _, _, _, b | b, _, _, _, a | ||
| 94 | SWAP5 | 3 | a, ..., b | b, ..., a | ||
| 95 | SWAP6 | 3 | a, ..., b | b, ..., a | ||
| 96 | SWAP7 | 3 | a, ..., b | b, ..., a | ||
| 97 | SWAP8 | 3 | a, ..., b | b, ..., a | ||
| 98 | SWAP9 | 3 | a, ..., b | b, ..., a | ||
| 99 | SWAP10 | 3 | a, ..., b | b, ..., a | ||
| 9A | SWAP11 | 3 | a, ..., b | b, ..., a | ||
| 9B | SWAP12 | 3 | a, ..., b | b, ..., a | ||
| 9C | SWAP13 | 3 | a, ..., b | b, ..., a | ||
| 9D | SWAP14 | 3 | a, ..., b | b, ..., a | ||
| 9E | SWAP15 | 3 | a, ..., b | b, ..., a | ||
| 9F | SWAP16 | 3 | a, ..., b | b, ..., a | ||
| A0 | LOG0 | A8 (öffnet in einem neuen Tab) | ost, len | . | LOG0(memory[ost:ost+len-1]) | |
| A1 | LOG1 | A8 (öffnet in einem neuen Tab) | ost, len, topic0 | . | LOG1(memory[ost:ost+len-1], topic0) | |
| A2 | LOG2 | A8 (öffnet in einem neuen Tab) | ost, len, topic0, topic1 | . | LOG2(memory[ost:ost+len-1], topic0, topic1) | |
| A3 | LOG3 | A8 (öffnet in einem neuen Tab) | ost, len, topic0, topic1, topic2 | . | LOG3(memory[ost:ost+len-1], topic0, topic1, topic2) | |
| A4 | LOG4 | A8 (öffnet in einem neuen Tab) | ost, len, topic0, topic1, topic2, topic3 | . | LOG4(memory[ost:ost+len-1], topic0, topic1, topic2, topic3) | |
| A5-EF | ungültig | |||||
| F0 | CREATE | A9 (öffnet in einem neuen Tab) | val, ost, len | addr | addr = keccak256(rlp([address(this), this.nonce])) | |
| F1 | CALL | AA (öffnet in einem neuen Tab) | gas, addr, val, argOst, argLen, retOst, retLen | success | mem[retOst:retOst+retLen-1] := returndata | |
| F2 | CALLCODE | AA (öffnet in einem neuen Tab) | gas, addr, val, argOst, argLen, retOst, retLen | success | mem[retOst:retOst+retLen-1] = returndata | wie DELEGATECALL, gibt aber nicht den ursprünglichen msg.sender und msg.value weiter |
| F3 | RETURN | 0* (öffnet in einem neuen Tab) | ost, len | . | return mem[ost:ost+len-1] | |
| F4 | DELEGATECALL | AA (öffnet in einem neuen Tab) | gas, addr, argOst, argLen, retOst, retLen | success | mem[retOst:retOst+retLen-1] := returndata | |
| F5 | CREATE2 | A9 (öffnet in einem neuen Tab) | val, ost, len, salt | addr | addr = keccak256(0xff ++ address(this) ++ salt ++ keccak256(mem[ost:ost+len-1]))[12:] | |
| F6-F9 | ungültig | |||||
| FA | STATICCALL | AA (öffnet in einem neuen Tab) | gas, addr, argOst, argLen, retOst, retLen | success | mem[retOst:retOst+retLen-1] := returndata | |
| FB-FC | ungültig | |||||
| FD | REVERT | 0* (öffnet in einem neuen Tab) | ost, len | . | revert(mem[ost:ost+len-1]) | |
| FE | INVALID | AF (öffnet in einem neuen Tab) | als ungültig deklarierter Opcode - EIP-141 (öffnet in einem neuen Tab) | |||
| FF | SELFDESTRUCT | AB (öffnet in einem neuen Tab) | addr | . | sendet alle ETH an addr; wenn in derselben Transaktion ausgeführt, in der ein Vertrag erstellt wurde, wird der Vertrag zerstört |