Códigos de operación para la EVM

This is an updated version of the EVM reference page at wolflo/evm-opcodes (se abre en una pestaña nueva). Also drawn from the Yellow Paper (se abre en una pestaña nueva), the Jello Paper (se abre en una pestaña nueva), and the geth (se abre en una pestaña nueva) implementation. This is intended to be an accessible reference, but it is not particularly rigorous. If you want to be certain of correctness and aware of every edge case, using the Jello Paper or a client implementation is advisable.

Looking for an interactive reference? Check out evm.codes (se abre en una pestaña nueva).

For operations with dynamic gas costs, see gas.md (se abre en una pestaña nueva).

💡 Quick tip: To view entire lines, use [shift] + scroll to scroll horizontally on desktop.

Pila	Nombre	Gas	Pila inicial	Pila resultante	Memoria / Almacenamiento	Notas
00	STOP	0				detener ejecución
01	ADD	3	`a, b`	`a + b`		suma de (u)int256 módulo 2**256
02	MUL	5	`a, b`	`a * b`		multiplicación de (u)int256 módulo 2**256
03	SUB	3	`a, b`	`a - b`		resta de (u)int256 módulo 2**256
04	DIV	5	`a, b`	`a // b`		división de uint256
05	SDIV	5	`a, b`	`a // b`		división de int256
06	MOD	5	`a, b`	`a % b`		módulo de uint256
07	SMOD	5	`a, b`	`a % b`		módulo de int256
08	ADDMOD	8	`a, b, N`	`(a + b) % N`		suma de (u)int256 módulo N
09	MULMOD	8	`a, b, N`	`(a * b) % N`		multiplicación de (u)int256 módulo N
0A	EXP	A1 (se abre en una pestaña nueva)	`a, b`	`a ** b`		exponenciación de uint256 módulo 2**256
0B	SIGNEXTEND	5	`b, x`	`SIGNEXTEND(x, b)`		extensión de signo (se abre en una pestaña nueva) de `x` de `(b+1)` bytes a 32 bytes
0C-0F	inválido
10	LT	3	`a, b`	`a < b`		menor que uint256
11	GT	3	`a, b`	`a > b`		mayor que uint256
12	SLT	3	`a, b`	`a < b`		menor que int256
13	SGT	3	`a, b`	`a > b`		mayor que int256
14	EQ	3	`a, b`	`a == b`		igualdad de (u)int256
15	ISZERO	3	`a`	`a == 0`		es cero (u)int256
16	AND	3	`a, b`	`a && b`		AND a nivel de bits
17	OR	3	`a, b`	`a \|\| b`		OR a nivel de bits
18	XOR	3	`a, b`	`a ^ b`		XOR a nivel de bits
19	NOT	3	`a`	`~a`		NOT a nivel de bits
1A	BYTE	3	`i, x`	`(x >> (248 - i * 8)) && 0xFF`		byte `i`-ésimo de (u)int256 `x`, desde la izquierda
1B	SHL	3	`shift, val`	`val << shift`		desplazamiento a la izquierda
1C	SHR	3	`shift, val`	`val >> shift`		desplazamiento lógico a la derecha
1D	SAR	3	`shift, val`	`val >> shift`		desplazamiento aritmético a la derecha
1E-1F	inválido
20	KECCAK256	A2 (se abre en una pestaña nueva)	`ost, len`	`keccak256(mem[ost:ost+len-1])`		keccak256
21-2F	inválido
30	ADDRESS	2	`.`	`address(this)`		dirección del contrato en ejecución
31	BALANCE	A5 (se abre en una pestaña nueva)	`addr`	`addr.balance`		saldo, en Wei
32	ORIGIN	2	`.`	`tx.origin`		dirección que originó la tx
33	CALLER	2	`.`	`msg.sender`		dirección del remitente del msg
34	CALLVALUE	2	`.`	`msg.value`		valor del msg, en Wei
35	CALLDATALOAD	3	`idx`	`msg.data[idx:idx+32]`		leer palabra de los datos del msg en el índice `idx`
36	CALLDATASIZE	2	`.`	`len(msg.data)`		longitud de los datos del msg, en bytes
37	CALLDATACOPY	A3 (se abre en una pestaña nueva)	`dstOst, ost, len`	`.`	mem[dstOst:dstOst+len-1] := msg.data[ost:ost+len-1]	copiar datos del msg
38	CODESIZE	2	`.`	`len(this.code)`		longitud del código del contrato en ejecución, en bytes
39	CODECOPY	A3 (se abre en una pestaña nueva)	`dstOst, ost, len`	`.`		mem[dstOst:dstOst+len-1] := this.code[ost:ost+len-1]
3A	GASPRICE	2	`.`	`tx.gasprice`		precio del gas de la tx, en Wei por unidad de gas ** (se abre en una pestaña nueva)
3B	EXTCODESIZE	A5 (se abre en una pestaña nueva)	`addr`	`len(addr.code)`		tamaño del código en la addr, en bytes
3C	EXTCODECOPY	A4 (se abre en una pestaña nueva)	`addr, dstOst, ost, len`	`.`	mem[dstOst:dstOst+len-1] := addr.code[ost:ost+len-1]	copiar código de `addr`
3D	RETURNDATASIZE	2	`.`	`size`		tamaño de los datos devueltos desde la última llamada externa, en bytes
3E	RETURNDATACOPY	A3 (se abre en una pestaña nueva)	`dstOst, ost, len`	`.`	mem[dstOst:dstOst+len-1] := returndata[ost:ost+len-1]	copiar datos devueltos desde la última llamada externa
3F	EXTCODEHASH	A5 (se abre en una pestaña nueva)	`addr`	`hash`		hash = addr.exists ? keccak256(addr.code) : 0
40	BLOCKHASH	20	`blockNum`	`blockHash(blockNum)`
41	COINBASE	2	`.`	`block.coinbase`		dirección del proponente del bloque actual
42	TIMESTAMP	2	`.`	`block.timestamp`		marca de tiempo del bloque actual
43	NUMBER	2	`.`	`block.number`		número del bloque actual
44	PREVRANDAO	2	`.`	`faro de aleatoriedad`		faro de aleatoriedad
45	GASLIMIT	2	`.`	`block.gaslimit`		límite de gas del bloque actual
46	CHAINID	2	`.`	`chain_id`		empujar el id de la cadena (se abre en una pestaña nueva) actual a la pila
47	SELFBALANCE	5	`.`	`address(this).balance`		saldo del contrato en ejecución, en Wei
48	BASEFEE	2	`.`	`block.basefee`		tarifa base del bloque actual
49	BLOBHASH	3	`idx`	`tx.blob_versioned_hashes[idx]`		EIP-4844 (se abre en una pestaña nueva)
4A	BLOBBASEFEE	2	`.`	`block.blobbasefee`		tarifa base del blob del bloque actual (EIP-7516 (se abre en una pestaña nueva))
4B-4F	inválido
50	POP	2	`_anon`	`.`		eliminar el elemento superior de la pila y descartarlo
51	MLOAD	3* (se abre en una pestaña nueva)	`ost`	`mem[ost:ost+32]`		leer palabra de la memoria en el desplazamiento `ost`
52	MSTORE	3* (se abre en una pestaña nueva)	`ost, val`	`.`	mem[ost:ost+32] := val	escribir una palabra en la memoria
53	MSTORE8	3* (se abre en una pestaña nueva)	`ost, val`	`.`	mem[ost] := val && 0xFF	escribir un solo byte en la memoria
54	SLOAD	A6 (se abre en una pestaña nueva)	`key`	`storage[key]`		leer palabra del almacenamiento
55	SSTORE	A7 (se abre en una pestaña nueva)	`key, val`	`.`	storage[key] := val	escribir palabra en el almacenamiento
56	JUMP	8	`dst`	`.`		`$pc := dst` marca que `pc` solo se asigna si `dst` es un jumpdest válido
57	JUMPI	10	`dst, condition`	`.`		`$pc := condition ? dst : $pc + 1`
58	PC	2	`.`	`$pc`		contador de programa
59	MSIZE	2	`.`	`len(mem)`		tamaño de la memoria en el contexto de ejecución actual, en bytes
5A	GAS	2	`.`	`gasRemaining`
5B	JUMPDEST	1			marcar destino de salto válido	un destino de salto válido, por ejemplo, un destino de salto que no esté dentro de los datos de empuje (push)
5C	TLOAD	100	`key`	`tstorage[key]`		leer palabra del almacenamiento transitorio (EIP-1153 (se abre en una pestaña nueva))
5D	TSTORE	100	`key, val`	`.`	tstorage[key] := val	escribir palabra en el almacenamiento transitorio (EIP-1153 (se abre en una pestaña nueva))
5E	MCOPY	3+3*words+A0 (se abre en una pestaña nueva)	`dstOst, ost, len`	`.`	mem[dstOst] := mem[ost:ost+len]	copiar memoria de un área a otra (EIP-5656 (se abre en una pestaña nueva))
5F	PUSH0	2	`.`	`uint8`		empujar el valor constante 0 a la pila
60	PUSH1	3	`.`	`uint8`		empujar valor de 1 byte a la pila
61	PUSH2	3	`.`	`uint16`		empujar valor de 2 bytes a la pila
62	PUSH3	3	`.`	`uint24`		empujar valor de 3 bytes a la pila
63	PUSH4	3	`.`	`uint32`		empujar valor de 4 bytes a la pila
64	PUSH5	3	`.`	`uint40`		empujar valor de 5 bytes a la pila
65	PUSH6	3	`.`	`uint48`		empujar valor de 6 bytes a la pila
66	PUSH7	3	`.`	`uint56`		empujar valor de 7 bytes a la pila
67	PUSH8	3	`.`	`uint64`		empujar valor de 8 bytes a la pila
68	PUSH9	3	`.`	`uint72`		empujar valor de 9 bytes a la pila
69	PUSH10	3	`.`	`uint80`		empujar valor de 10 bytes a la pila
6A	PUSH11	3	`.`	`uint88`		empujar valor de 11 bytes a la pila
6B	PUSH12	3	`.`	`uint96`		empujar valor de 12 bytes a la pila
6C	PUSH13	3	`.`	`uint104`		empujar valor de 13 bytes a la pila
6D	PUSH14	3	`.`	`uint112`		empujar valor de 14 bytes a la pila
6E	PUSH15	3	`.`	`uint120`		empujar valor de 15 bytes a la pila
6F	PUSH16	3	`.`	`uint128`		empujar valor de 16 bytes a la pila
70	PUSH17	3	`.`	`uint136`		empujar valor de 17 bytes a la pila
71	PUSH18	3	`.`	`uint144`		empujar valor de 18 bytes a la pila
72	PUSH19	3	`.`	`uint152`		empujar valor de 19 bytes a la pila
73	PUSH20	3	`.`	`uint160`		empujar valor de 20 bytes a la pila
74	PUSH21	3	`.`	`uint168`		empujar valor de 21 bytes a la pila
75	PUSH22	3	`.`	`uint176`		empujar valor de 22 bytes a la pila
76	PUSH23	3	`.`	`uint184`		empujar valor de 23 bytes a la pila
77	PUSH24	3	`.`	`uint192`		empujar valor de 24 bytes a la pila
78	PUSH25	3	`.`	`uint200`		empujar valor de 25 bytes a la pila
79	PUSH26	3	`.`	`uint208`		empujar valor de 26 bytes a la pila
7A	PUSH27	3	`.`	`uint216`		empujar valor de 27 bytes a la pila
7B	PUSH28	3	`.`	`uint224`		empujar valor de 28 bytes a la pila
7C	PUSH29	3	`.`	`uint232`		empujar valor de 29 bytes a la pila
7D	PUSH30	3	`.`	`uint240`		empujar valor de 30 bytes a la pila
7E	PUSH31	3	`.`	`uint248`		empujar valor de 31 bytes a la pila
7F	PUSH32	3	`.`	`uint256`		empujar valor de 32 bytes a la pila
80	DUP1	3	`a`	`a, a`		clonar el 1er valor en la pila
81	DUP2	3	`_, a`	`a, _, a`		clonar el 2do valor en la pila
82	DUP3	3	`_, _, a`	`a, _, _, a`		clonar el 3er valor en la pila
83	DUP4	3	`_, _, _, a`	`a, _, _, _, a`		clonar el 4to valor en la pila
84	DUP5	3	`..., a`	`a, ..., a`		clonar el 5to valor en la pila
85	DUP6	3	`..., a`	`a, ..., a`		clonar el 6to valor en la pila
86	DUP7	3	`..., a`	`a, ..., a`		clonar el 7mo valor en la pila
87	DUP8	3	`..., a`	`a, ..., a`		clonar el 8vo valor en la pila
88	DUP9	3	`..., a`	`a, ..., a`		clonar el 9no valor en la pila
89	DUP10	3	`..., a`	`a, ..., a`		clonar el 10mo valor en la pila
8A	DUP11	3	`..., a`	`a, ..., a`		clonar el 11vo valor en la pila
8B	DUP12	3	`..., a`	`a, ..., a`		clonar el 12vo valor en la pila
8C	DUP13	3	`..., a`	`a, ..., a`		clonar el 13vo valor en la pila
8D	DUP14	3	`..., a`	`a, ..., a`		clonar el 14vo valor en la pila
8E	DUP15	3	`..., a`	`a, ..., a`		clonar el 15vo valor en la pila
8F	DUP16	3	`..., a`	`a, ..., a`		clonar el 16vo valor en la pila
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 (se abre en una pestaña nueva)	`ost, len`	`.`		LOG0(memory[ost:ost+len-1])
A1	LOG1	A8 (se abre en una pestaña nueva)	`ost, len, topic0`	`.`		LOG1(memory[ost:ost+len-1], topic0)
A2	LOG2	A8 (se abre en una pestaña nueva)	`ost, len, topic0, topic1`	`.`		LOG2(memory[ost:ost+len-1], topic0, topic1)
A3	LOG3	A8 (se abre en una pestaña nueva)	`ost, len, topic0, topic1, topic2`	`.`		LOG3(memory[ost:ost+len-1], topic0, topic1, topic2)
A4	LOG4	A8 (se abre en una pestaña nueva)	`ost, len, topic0, topic1, topic2, topic3`	`.`		LOG4(memory[ost:ost+len-1], topic0, topic1, topic2, topic3)
A5-EF	inválido
F0	CREATE	A9 (se abre en una pestaña nueva)	`val, ost, len`	`addr`		addr = keccak256(rlp([address(this), this.nonce]))
F1	CALL	AA (se abre en una pestaña nueva)	`gas, addr, val, argOst, argLen, retOst, retLen`	`success`	mem[retOst:retOst+retLen-1] := returndata
F2	CALLCODE	AA (se abre en una pestaña nueva)	`gas, addr, val, argOst, argLen, retOst, retLen`	`success`	mem[retOst:retOst+retLen-1] = returndata	igual que DELEGATECALL, pero no propaga el msg.sender y msg.value originales
F3	RETURN	0* (se abre en una pestaña nueva)	`ost, len`	`.`		return mem[ost:ost+len-1]
F4	DELEGATECALL	AA (se abre en una pestaña nueva)	`gas, addr, argOst, argLen, retOst, retLen`	`success`	mem[retOst:retOst+retLen-1] := returndata
F5	CREATE2	A9 (se abre en una pestaña nueva)	`val, ost, len, salt`	`addr`		addr = keccak256(0xff ++ address(this) ++ salt ++ keccak256(mem[ost:ost+len-1]))[12:]
F6-F9	inválido
FA	STATICCALL	AA (se abre en una pestaña nueva)	`gas, addr, argOst, argLen, retOst, retLen`	`success`	mem[retOst:retOst+retLen-1] := returndata
FB-FC	inválido
FD	REVERT	0* (se abre en una pestaña nueva)	`ost, len`	`.`		revert(mem[ost:ost+len-1])
FE	INVALID	AF (se abre en una pestaña nueva)			código de operación inválido designado - EIP-141 (se abre en una pestaña nueva)
FF	SELFDESTRUCT	AB (se abre en una pestaña nueva)	`addr`	`.`		envía todo el ETH a `addr`; si se ejecuta en la misma transacción en la que se creó un contrato, destruye el contrato