mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2024-12-22 11:41:19 +00:00
974 lines
30 KiB
Go
974 lines
30 KiB
Go
// Copyright 2015 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library 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 Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package vm
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/holiman/uint256"
|
|
libcommon "github.com/ledgerwatch/erigon-lib/common"
|
|
"golang.org/x/crypto/sha3"
|
|
|
|
"github.com/ledgerwatch/log/v3"
|
|
|
|
"github.com/ledgerwatch/erigon/common"
|
|
"github.com/ledgerwatch/erigon/core/types"
|
|
"github.com/ledgerwatch/erigon/params"
|
|
)
|
|
|
|
func opAdd(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
y.Add(&x, y)
|
|
return nil, nil
|
|
}
|
|
|
|
func opSub(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
y.Sub(&x, y)
|
|
return nil, nil
|
|
}
|
|
|
|
func opMul(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
y.Mul(&x, y)
|
|
return nil, nil
|
|
}
|
|
|
|
func opDiv(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
y.Div(&x, y)
|
|
return nil, nil
|
|
}
|
|
|
|
func opSdiv(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
y.SDiv(&x, y)
|
|
return nil, nil
|
|
}
|
|
|
|
func opMod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
y.Mod(&x, y)
|
|
return nil, nil
|
|
}
|
|
|
|
func opSmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
y.SMod(&x, y)
|
|
return nil, nil
|
|
}
|
|
|
|
func opExp(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
base, exponent := scope.Stack.Pop(), scope.Stack.Peek()
|
|
switch {
|
|
case exponent.IsZero():
|
|
// x ^ 0 == 1
|
|
exponent.SetOne()
|
|
case base.IsZero():
|
|
// 0 ^ y, if y != 0, == 0
|
|
exponent.Clear()
|
|
case exponent.LtUint64(2): // exponent == 1
|
|
// x ^ 1 == x
|
|
exponent.Set(&base)
|
|
case base.LtUint64(2): // base == 1
|
|
// 1 ^ y == 1
|
|
exponent.SetOne()
|
|
case base.LtUint64(3): // base == 2
|
|
if exponent.LtUint64(256) {
|
|
n := uint(exponent.Uint64())
|
|
exponent.SetOne()
|
|
exponent.Lsh(exponent, n)
|
|
} else {
|
|
exponent.Clear()
|
|
}
|
|
default:
|
|
exponent.Exp(&base, exponent)
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opSignExtend(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
back, num := scope.Stack.Pop(), scope.Stack.Peek()
|
|
num.ExtendSign(num, &back)
|
|
return nil, nil
|
|
}
|
|
|
|
func opNot(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x := scope.Stack.Peek()
|
|
x.Not(x)
|
|
return nil, nil
|
|
}
|
|
|
|
func opLt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
if x.Lt(y) {
|
|
y.SetOne()
|
|
} else {
|
|
y.Clear()
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opGt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
if x.Gt(y) {
|
|
y.SetOne()
|
|
} else {
|
|
y.Clear()
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opSlt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
if x.Slt(y) {
|
|
y.SetOne()
|
|
} else {
|
|
y.Clear()
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opSgt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
if x.Sgt(y) {
|
|
y.SetOne()
|
|
} else {
|
|
y.Clear()
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opEq(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
if x.Eq(y) {
|
|
y.SetOne()
|
|
} else {
|
|
y.Clear()
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opIszero(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x := scope.Stack.Peek()
|
|
if x.IsZero() {
|
|
x.SetOne()
|
|
} else {
|
|
x.Clear()
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opAnd(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
y.And(&x, y)
|
|
return nil, nil
|
|
}
|
|
|
|
func opOr(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
y.Or(&x, y)
|
|
return nil, nil
|
|
}
|
|
|
|
func opXor(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y := scope.Stack.Pop(), scope.Stack.Peek()
|
|
y.Xor(&x, y)
|
|
return nil, nil
|
|
}
|
|
|
|
func opByte(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
th, val := scope.Stack.Pop(), scope.Stack.Peek()
|
|
val.Byte(&th)
|
|
return nil, nil
|
|
}
|
|
|
|
func opAddmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y, z := scope.Stack.Pop(), scope.Stack.Pop(), scope.Stack.Peek()
|
|
if z.IsZero() {
|
|
z.Clear()
|
|
} else {
|
|
z.AddMod(&x, &y, z)
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opMulmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x, y, z := scope.Stack.Pop(), scope.Stack.Pop(), scope.Stack.Peek()
|
|
if z.IsZero() {
|
|
z.Clear()
|
|
} else {
|
|
z.MulMod(&x, &y, z)
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
// opSHL implements Shift Left
|
|
// The SHL instruction (shift left) pops 2 values from the stack, first arg1 and then arg2,
|
|
// and pushes on the stack arg2 shifted to the left by arg1 number of bits.
|
|
func opSHL(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
// Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards
|
|
shift, value := scope.Stack.Pop(), scope.Stack.Peek()
|
|
if shift.LtUint64(256) {
|
|
value.Lsh(value, uint(shift.Uint64()))
|
|
} else {
|
|
value.Clear()
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
// opSHR implements Logical Shift Right
|
|
// The SHR instruction (logical shift right) pops 2 values from the stack, first arg1 and then arg2,
|
|
// and pushes on the stack arg2 shifted to the right by arg1 number of bits with zero fill.
|
|
func opSHR(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
// Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards
|
|
shift, value := scope.Stack.Pop(), scope.Stack.Peek()
|
|
if shift.LtUint64(256) {
|
|
value.Rsh(value, uint(shift.Uint64()))
|
|
} else {
|
|
value.Clear()
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
// opSAR implements Arithmetic Shift Right
|
|
// The SAR instruction (arithmetic shift right) pops 2 values from the stack, first arg1 and then arg2,
|
|
// and pushes on the stack arg2 shifted to the right by arg1 number of bits with sign extension.
|
|
func opSAR(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
shift, value := scope.Stack.Pop(), scope.Stack.Peek()
|
|
if shift.GtUint64(255) {
|
|
if value.Sign() >= 0 {
|
|
value.Clear()
|
|
} else {
|
|
// Max negative shift: all bits set
|
|
value.SetAllOne()
|
|
}
|
|
return nil, nil
|
|
}
|
|
n := uint(shift.Uint64())
|
|
value.SRsh(value, n)
|
|
return nil, nil
|
|
}
|
|
|
|
func opKeccak256(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
offset, size := scope.Stack.Pop(), scope.Stack.Peek()
|
|
data := scope.Memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))
|
|
|
|
if interpreter.hasher == nil {
|
|
interpreter.hasher = sha3.NewLegacyKeccak256().(keccakState)
|
|
} else {
|
|
interpreter.hasher.Reset()
|
|
}
|
|
interpreter.hasher.Write(data)
|
|
if _, err := interpreter.hasher.Read(interpreter.hasherBuf[:]); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
size.SetBytes(interpreter.hasherBuf[:])
|
|
return nil, nil
|
|
}
|
|
func opAddress(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(new(uint256.Int).SetBytes(scope.Contract.Address().Bytes()))
|
|
return nil, nil
|
|
}
|
|
|
|
func opBalance(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
slot := scope.Stack.Peek()
|
|
address := libcommon.Address(slot.Bytes20())
|
|
slot.Set(interpreter.evm.IntraBlockState().GetBalance(address))
|
|
return nil, nil
|
|
}
|
|
|
|
func opOrigin(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(new(uint256.Int).SetBytes(interpreter.evm.TxContext().Origin.Bytes()))
|
|
return nil, nil
|
|
}
|
|
func opCaller(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(new(uint256.Int).SetBytes(scope.Contract.Caller().Bytes()))
|
|
return nil, nil
|
|
}
|
|
|
|
func opCallValue(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(scope.Contract.value)
|
|
return nil, nil
|
|
}
|
|
|
|
func opCallDataLoad(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
x := scope.Stack.Peek()
|
|
if offset, overflow := x.Uint64WithOverflow(); !overflow {
|
|
data := getData(scope.Contract.Input, offset, 32)
|
|
x.SetBytes(data)
|
|
} else {
|
|
x.Clear()
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opCallDataSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(new(uint256.Int).SetUint64(uint64(len(scope.Contract.Input))))
|
|
return nil, nil
|
|
}
|
|
|
|
func opCallDataCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
var (
|
|
memOffset = scope.Stack.Pop()
|
|
dataOffset = scope.Stack.Pop()
|
|
length = scope.Stack.Pop()
|
|
)
|
|
dataOffset64, overflow := dataOffset.Uint64WithOverflow()
|
|
if overflow {
|
|
dataOffset64 = 0xffffffffffffffff
|
|
}
|
|
// These values are checked for overflow during gas cost calculation
|
|
memOffset64 := memOffset.Uint64()
|
|
length64 := length.Uint64()
|
|
scope.Memory.Set(memOffset64, length64, getData(scope.Contract.Input, dataOffset64, length64))
|
|
return nil, nil
|
|
}
|
|
|
|
func opReturnDataSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(new(uint256.Int).SetUint64(uint64(len(interpreter.returnData))))
|
|
return nil, nil
|
|
}
|
|
|
|
func opReturnDataCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
var (
|
|
memOffset = scope.Stack.Pop()
|
|
dataOffset = scope.Stack.Pop()
|
|
length = scope.Stack.Pop()
|
|
)
|
|
|
|
offset64, overflow := dataOffset.Uint64WithOverflow()
|
|
if overflow {
|
|
return nil, ErrReturnDataOutOfBounds
|
|
}
|
|
// we can reuse dataOffset now (aliasing it for clarity)
|
|
end := dataOffset
|
|
_, overflow = end.AddOverflow(&dataOffset, &length)
|
|
if overflow {
|
|
return nil, ErrReturnDataOutOfBounds
|
|
}
|
|
|
|
end64, overflow := end.Uint64WithOverflow()
|
|
if overflow || uint64(len(interpreter.returnData)) < end64 {
|
|
return nil, ErrReturnDataOutOfBounds
|
|
}
|
|
scope.Memory.Set(memOffset.Uint64(), length.Uint64(), interpreter.returnData[offset64:end64])
|
|
return nil, nil
|
|
}
|
|
|
|
func opExtCodeSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
slot := scope.Stack.Peek()
|
|
slot.SetUint64(uint64(interpreter.evm.IntraBlockState().GetCodeSize(slot.Bytes20())))
|
|
return nil, nil
|
|
}
|
|
|
|
func opCodeSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
l := new(uint256.Int)
|
|
l.SetUint64(uint64(len(scope.Contract.Code)))
|
|
scope.Stack.Push(l)
|
|
return nil, nil
|
|
}
|
|
|
|
func opCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
var (
|
|
memOffset = scope.Stack.Pop()
|
|
codeOffset = scope.Stack.Pop()
|
|
length = scope.Stack.Pop()
|
|
)
|
|
uint64CodeOffset, overflow := codeOffset.Uint64WithOverflow()
|
|
if overflow {
|
|
uint64CodeOffset = 0xffffffffffffffff
|
|
}
|
|
codeCopy := getData(scope.Contract.Code, uint64CodeOffset, length.Uint64())
|
|
scope.Memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)
|
|
return nil, nil
|
|
}
|
|
|
|
func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
var (
|
|
stack = scope.Stack
|
|
a = stack.Pop()
|
|
memOffset = stack.Pop()
|
|
codeOffset = stack.Pop()
|
|
length = stack.Pop()
|
|
)
|
|
addr := libcommon.Address(a.Bytes20())
|
|
len64 := length.Uint64()
|
|
codeCopy := getDataBig(interpreter.evm.IntraBlockState().GetCode(addr), &codeOffset, len64)
|
|
scope.Memory.Set(memOffset.Uint64(), len64, codeCopy)
|
|
return nil, nil
|
|
}
|
|
|
|
// opExtCodeHash returns the code hash of a specified account.
|
|
// There are several cases when the function is called, while we can relay everything
|
|
// to `state.GetCodeHash` function to ensure the correctness.
|
|
//
|
|
// (1) Caller tries to get the code hash of a normal contract account, state
|
|
//
|
|
// should return the relative code hash and set it as the result.
|
|
//
|
|
// (2) Caller tries to get the code hash of a non-existent account, state should
|
|
//
|
|
// return libcommon.Hash{} and zero will be set as the result.
|
|
//
|
|
// (3) Caller tries to get the code hash for an account without contract code,
|
|
//
|
|
// state should return emptyCodeHash(0xc5d246...) as the result.
|
|
//
|
|
// (4) Caller tries to get the code hash of a precompiled account, the result
|
|
//
|
|
// should be zero or emptyCodeHash.
|
|
//
|
|
// It is worth noting that in order to avoid unnecessary create and clean,
|
|
// all precompile accounts on mainnet have been transferred 1 wei, so the return
|
|
// here should be emptyCodeHash.
|
|
// If the precompile account is not transferred any amount on a private or
|
|
// customized chain, the return value will be zero.
|
|
//
|
|
// (5) Caller tries to get the code hash for an account which is marked as suicided
|
|
//
|
|
// in the current transaction, the code hash of this account should be returned.
|
|
//
|
|
// (6) Caller tries to get the code hash for an account which is marked as deleted,
|
|
//
|
|
// this account should be regarded as a non-existent account and zero should be returned.
|
|
func opExtCodeHash(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
slot := scope.Stack.Peek()
|
|
address := libcommon.Address(slot.Bytes20())
|
|
if interpreter.evm.IntraBlockState().Empty(address) {
|
|
slot.Clear()
|
|
} else {
|
|
slot.SetBytes(interpreter.evm.IntraBlockState().GetCodeHash(address).Bytes())
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opGasprice(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(interpreter.evm.TxContext().GasPrice)
|
|
return nil, nil
|
|
}
|
|
|
|
func opBlockhash(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
num := scope.Stack.Peek()
|
|
num64, overflow := num.Uint64WithOverflow()
|
|
if overflow {
|
|
num.Clear()
|
|
return nil, nil
|
|
}
|
|
var upper, lower uint64
|
|
upper = interpreter.evm.Context().BlockNumber
|
|
if upper < 257 {
|
|
lower = 0
|
|
} else {
|
|
lower = upper - 256
|
|
}
|
|
if num64 >= lower && num64 < upper {
|
|
num.SetBytes(interpreter.evm.Context().GetHash(num64).Bytes())
|
|
} else {
|
|
num.Clear()
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opCoinbase(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(new(uint256.Int).SetBytes(interpreter.evm.Context().Coinbase.Bytes()))
|
|
return nil, nil
|
|
}
|
|
|
|
func opTimestamp(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
v := new(uint256.Int).SetUint64(interpreter.evm.Context().Time)
|
|
scope.Stack.Push(v)
|
|
return nil, nil
|
|
}
|
|
|
|
func opNumber(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
v := new(uint256.Int).SetUint64(interpreter.evm.Context().BlockNumber)
|
|
scope.Stack.Push(v)
|
|
return nil, nil
|
|
}
|
|
|
|
func opDifficulty(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
var v *uint256.Int
|
|
if interpreter.evm.Context().PrevRanDao != nil {
|
|
// EIP-4399: Supplant DIFFICULTY opcode with PREVRANDAO
|
|
v = new(uint256.Int).SetBytes(interpreter.evm.Context().PrevRanDao.Bytes())
|
|
} else {
|
|
var overflow bool
|
|
v, overflow = uint256.FromBig(interpreter.evm.Context().Difficulty)
|
|
if overflow {
|
|
return nil, fmt.Errorf("interpreter.evm.Context.Difficulty higher than 2^256-1")
|
|
}
|
|
}
|
|
scope.Stack.Push(v)
|
|
return nil, nil
|
|
}
|
|
|
|
func opGasLimit(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
if interpreter.evm.Context().MaxGasLimit {
|
|
scope.Stack.Push(new(uint256.Int).SetAllOne())
|
|
} else {
|
|
scope.Stack.Push(new(uint256.Int).SetUint64(interpreter.evm.Context().GasLimit))
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opPop(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Pop()
|
|
return nil, nil
|
|
}
|
|
|
|
func opMload(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
v := scope.Stack.Peek()
|
|
offset := v.Uint64()
|
|
v.SetBytes(scope.Memory.GetPtr(int64(offset), 32))
|
|
return nil, nil
|
|
}
|
|
|
|
func opMstore(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
mStart, val := scope.Stack.Pop(), scope.Stack.Pop()
|
|
scope.Memory.Set32(mStart.Uint64(), &val)
|
|
return nil, nil
|
|
}
|
|
|
|
func opMstore8(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
off, val := scope.Stack.Pop(), scope.Stack.Pop()
|
|
scope.Memory.store[off.Uint64()] = byte(val.Uint64())
|
|
return nil, nil
|
|
}
|
|
|
|
func opSload(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
loc := scope.Stack.Peek()
|
|
interpreter.hasherBuf = loc.Bytes32()
|
|
interpreter.evm.IntraBlockState().GetState(scope.Contract.Address(), &interpreter.hasherBuf, loc)
|
|
return nil, nil
|
|
}
|
|
|
|
func opSstore(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
if interpreter.readOnly {
|
|
return nil, ErrWriteProtection
|
|
}
|
|
loc := scope.Stack.Pop()
|
|
val := scope.Stack.Pop()
|
|
interpreter.hasherBuf = loc.Bytes32()
|
|
interpreter.evm.IntraBlockState().SetState(scope.Contract.Address(), &interpreter.hasherBuf, val)
|
|
return nil, nil
|
|
}
|
|
|
|
func opJump(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
pos := scope.Stack.Pop()
|
|
if valid, usedBitmap := scope.Contract.validJumpdest(&pos); !valid {
|
|
if usedBitmap {
|
|
if interpreter.cfg.TraceJumpDest {
|
|
log.Warn("Code Bitmap used for detecting invalid jump",
|
|
"tx", fmt.Sprintf("0x%x", interpreter.evm.TxContext().TxHash),
|
|
"block_num", interpreter.evm.Context().BlockNumber,
|
|
)
|
|
} else {
|
|
// This is "cheaper" version because it does not require calculation of txHash for each transaction
|
|
log.Warn("Code Bitmap used for detecting invalid jump",
|
|
"block_num", interpreter.evm.Context().BlockNumber,
|
|
)
|
|
}
|
|
}
|
|
return nil, ErrInvalidJump
|
|
}
|
|
*pc = pos.Uint64() - 1 // pc will be increased by the interpreter loop
|
|
return nil, nil
|
|
}
|
|
|
|
func opJumpi(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
pos, cond := scope.Stack.Pop(), scope.Stack.Pop()
|
|
if !cond.IsZero() {
|
|
if valid, usedBitmap := scope.Contract.validJumpdest(&pos); !valid {
|
|
if usedBitmap {
|
|
if interpreter.cfg.TraceJumpDest {
|
|
log.Warn("Code Bitmap used for detecting invalid jump",
|
|
"tx", fmt.Sprintf("0x%x", interpreter.evm.TxContext().TxHash),
|
|
"block_num", interpreter.evm.Context().BlockNumber,
|
|
)
|
|
} else {
|
|
// This is "cheaper" version because it does not require calculation of txHash for each transaction
|
|
log.Warn("Code Bitmap used for detecting invalid jump",
|
|
"block_num", interpreter.evm.Context().BlockNumber,
|
|
)
|
|
}
|
|
}
|
|
return nil, ErrInvalidJump
|
|
}
|
|
*pc = pos.Uint64() - 1 // pc will be increased by the interpreter loop
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func opJumpdest(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func opPc(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(new(uint256.Int).SetUint64(*pc))
|
|
return nil, nil
|
|
}
|
|
|
|
func opMsize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(new(uint256.Int).SetUint64(uint64(scope.Memory.Len())))
|
|
return nil, nil
|
|
}
|
|
|
|
func opGas(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Push(new(uint256.Int).SetUint64(scope.Contract.Gas))
|
|
return nil, nil
|
|
}
|
|
|
|
func opCreate(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
if interpreter.readOnly {
|
|
return nil, ErrWriteProtection
|
|
}
|
|
var (
|
|
value = scope.Stack.Pop()
|
|
offset = scope.Stack.Pop()
|
|
size = scope.Stack.Peek()
|
|
input = scope.Memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
|
|
gas = scope.Contract.Gas
|
|
)
|
|
if interpreter.evm.ChainRules().IsTangerineWhistle {
|
|
gas -= gas / 64
|
|
}
|
|
// reuse size int for stackvalue
|
|
stackvalue := size
|
|
|
|
scope.Contract.UseGas(gas)
|
|
|
|
res, addr, returnGas, suberr := interpreter.evm.Create(scope.Contract, input, gas, &value)
|
|
|
|
// Push item on the stack based on the returned error. If the ruleset is
|
|
// homestead we must check for CodeStoreOutOfGasError (homestead only
|
|
// rule) and treat as an error, if the ruleset is frontier we must
|
|
// ignore this error and pretend the operation was successful.
|
|
if interpreter.evm.ChainRules().IsHomestead && suberr == ErrCodeStoreOutOfGas {
|
|
stackvalue.Clear()
|
|
} else if suberr != nil && suberr != ErrCodeStoreOutOfGas {
|
|
stackvalue.Clear()
|
|
} else {
|
|
stackvalue.SetBytes(addr.Bytes())
|
|
}
|
|
scope.Contract.Gas += returnGas
|
|
|
|
if suberr == ErrExecutionReverted {
|
|
interpreter.returnData = res // set REVERT data to return data buffer
|
|
return res, nil
|
|
}
|
|
interpreter.returnData = nil // clear dirty return data buffer
|
|
return nil, nil
|
|
}
|
|
|
|
func opCreate2(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
if interpreter.readOnly {
|
|
return nil, ErrWriteProtection
|
|
}
|
|
var (
|
|
endowment = scope.Stack.Pop()
|
|
offset, size = scope.Stack.Pop(), scope.Stack.Pop()
|
|
salt = scope.Stack.Pop()
|
|
input = scope.Memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
|
|
gas = scope.Contract.Gas
|
|
)
|
|
|
|
// Apply EIP150
|
|
gas -= gas / 64
|
|
scope.Contract.UseGas(gas)
|
|
// reuse size int for stackvalue
|
|
stackValue := size
|
|
res, addr, returnGas, suberr := interpreter.evm.Create2(scope.Contract, input, gas, &endowment, &salt)
|
|
|
|
// Push item on the stack based on the returned error.
|
|
if suberr != nil {
|
|
stackValue.Clear()
|
|
} else {
|
|
stackValue.SetBytes(addr.Bytes())
|
|
}
|
|
|
|
scope.Stack.Push(&stackValue)
|
|
scope.Contract.Gas += returnGas
|
|
|
|
if suberr == ErrExecutionReverted {
|
|
interpreter.returnData = res // set REVERT data to return data buffer
|
|
return res, nil
|
|
}
|
|
interpreter.returnData = nil // clear dirty return data buffer
|
|
return nil, nil
|
|
}
|
|
|
|
func opCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
stack := scope.Stack
|
|
// Pop gas. The actual gas in interpreter.evm.callGasTemp.
|
|
// We can use this as a temporary value
|
|
temp := stack.Pop()
|
|
gas := interpreter.evm.CallGasTemp()
|
|
// Pop other call parameters.
|
|
addr, value, inOffset, inSize, retOffset, retSize := stack.Pop(), stack.Pop(), stack.Pop(), stack.Pop(), stack.Pop(), stack.Pop()
|
|
toAddr := libcommon.Address(addr.Bytes20())
|
|
// Get the arguments from the memory.
|
|
args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
|
|
|
|
if !value.IsZero() {
|
|
if interpreter.readOnly {
|
|
return nil, ErrWriteProtection
|
|
}
|
|
gas += params.CallStipend
|
|
}
|
|
|
|
ret, returnGas, err := interpreter.evm.Call(scope.Contract, toAddr, args, gas, &value, false /* bailout */)
|
|
|
|
if err != nil {
|
|
temp.Clear()
|
|
} else {
|
|
temp.SetOne()
|
|
}
|
|
stack.Push(&temp)
|
|
if err == nil || err == ErrExecutionReverted {
|
|
ret = common.CopyBytes(ret)
|
|
scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
|
|
}
|
|
|
|
scope.Contract.Gas += returnGas
|
|
|
|
interpreter.returnData = ret
|
|
return ret, nil
|
|
}
|
|
|
|
func opCallCode(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
|
|
stack := scope.Stack
|
|
// We use it as a temporary value
|
|
temp := stack.Pop()
|
|
gas := interpreter.evm.CallGasTemp()
|
|
// Pop other call parameters.
|
|
addr, value, inOffset, inSize, retOffset, retSize := stack.Pop(), stack.Pop(), stack.Pop(), stack.Pop(), stack.Pop(), stack.Pop()
|
|
toAddr := libcommon.Address(addr.Bytes20())
|
|
// Get arguments from the memory.
|
|
args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
|
|
|
|
if !value.IsZero() {
|
|
gas += params.CallStipend
|
|
}
|
|
|
|
ret, returnGas, err := interpreter.evm.CallCode(scope.Contract, toAddr, args, gas, &value)
|
|
if err != nil {
|
|
temp.Clear()
|
|
} else {
|
|
temp.SetOne()
|
|
}
|
|
stack.Push(&temp)
|
|
if err == nil || err == ErrExecutionReverted {
|
|
ret = common.CopyBytes(ret)
|
|
scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
|
|
}
|
|
|
|
scope.Contract.Gas += returnGas
|
|
|
|
interpreter.returnData = ret
|
|
return ret, nil
|
|
}
|
|
|
|
func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
stack := scope.Stack
|
|
// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
|
|
// We use it as a temporary value
|
|
temp := stack.Pop()
|
|
gas := interpreter.evm.CallGasTemp()
|
|
// Pop other call parameters.
|
|
addr, inOffset, inSize, retOffset, retSize := stack.Pop(), stack.Pop(), stack.Pop(), stack.Pop(), stack.Pop()
|
|
toAddr := libcommon.Address(addr.Bytes20())
|
|
// Get arguments from the memory.
|
|
args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
|
|
|
|
ret, returnGas, err := interpreter.evm.DelegateCall(scope.Contract, toAddr, args, gas)
|
|
if err != nil {
|
|
temp.Clear()
|
|
} else {
|
|
temp.SetOne()
|
|
}
|
|
stack.Push(&temp)
|
|
if err == nil || err == ErrExecutionReverted {
|
|
ret = common.CopyBytes(ret)
|
|
scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
|
|
}
|
|
|
|
scope.Contract.Gas += returnGas
|
|
|
|
interpreter.returnData = ret
|
|
return ret, nil
|
|
}
|
|
|
|
func opStaticCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
|
|
stack := scope.Stack
|
|
// We use it as a temporary value
|
|
temp := stack.Pop()
|
|
gas := interpreter.evm.CallGasTemp()
|
|
// Pop other call parameters.
|
|
addr, inOffset, inSize, retOffset, retSize := stack.Pop(), stack.Pop(), stack.Pop(), stack.Pop(), stack.Pop()
|
|
toAddr := libcommon.Address(addr.Bytes20())
|
|
// Get arguments from the memory.
|
|
args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
|
|
|
|
ret, returnGas, err := interpreter.evm.StaticCall(scope.Contract, toAddr, args, gas)
|
|
if err != nil {
|
|
temp.Clear()
|
|
} else {
|
|
temp.SetOne()
|
|
}
|
|
stack.Push(&temp)
|
|
if err == nil || err == ErrExecutionReverted {
|
|
ret = common.CopyBytes(ret)
|
|
scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
|
|
}
|
|
|
|
scope.Contract.Gas += returnGas
|
|
|
|
interpreter.returnData = ret
|
|
return ret, nil
|
|
}
|
|
|
|
func opReturn(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
offset, size := scope.Stack.Pop(), scope.Stack.Pop()
|
|
ret := scope.Memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))
|
|
return ret, errStopToken
|
|
}
|
|
|
|
func opRevert(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
offset, size := scope.Stack.Pop(), scope.Stack.Pop()
|
|
ret := scope.Memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))
|
|
interpreter.returnData = ret
|
|
return ret, ErrExecutionReverted
|
|
}
|
|
|
|
func opUndefined(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
return nil, &ErrInvalidOpCode{opcode: OpCode(scope.Contract.Code[*pc])}
|
|
}
|
|
|
|
func opStop(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
return nil, errStopToken
|
|
}
|
|
|
|
func opSelfdestruct(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
if interpreter.readOnly {
|
|
return nil, ErrWriteProtection
|
|
}
|
|
beneficiary := scope.Stack.Pop()
|
|
callerAddr := scope.Contract.Address()
|
|
beneficiaryAddr := libcommon.Address(beneficiary.Bytes20())
|
|
balance := interpreter.evm.IntraBlockState().GetBalance(callerAddr)
|
|
if interpreter.evm.Config().Debug {
|
|
if interpreter.cfg.Debug {
|
|
interpreter.cfg.Tracer.CaptureEnter(SELFDESTRUCT, callerAddr, beneficiaryAddr, false /* precompile */, false /* create */, []byte{}, 0, balance, nil /* code */)
|
|
interpreter.cfg.Tracer.CaptureExit([]byte{}, 0, nil)
|
|
}
|
|
}
|
|
interpreter.evm.IntraBlockState().AddBalance(beneficiaryAddr, balance)
|
|
interpreter.evm.IntraBlockState().Selfdestruct(callerAddr)
|
|
return nil, errStopToken
|
|
}
|
|
|
|
// following functions are used by the instruction jump table
|
|
|
|
// make log instruction function
|
|
func makeLog(size int) executionFunc {
|
|
return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
if interpreter.readOnly {
|
|
return nil, ErrWriteProtection
|
|
}
|
|
topics := make([]libcommon.Hash, size)
|
|
stack := scope.Stack
|
|
mStart, mSize := stack.Pop(), stack.Pop()
|
|
for i := 0; i < size; i++ {
|
|
addr := stack.Pop()
|
|
topics[i] = addr.Bytes32()
|
|
}
|
|
|
|
d := scope.Memory.GetCopy(int64(mStart.Uint64()), int64(mSize.Uint64()))
|
|
interpreter.evm.IntraBlockState().AddLog(&types.Log{
|
|
Address: scope.Contract.Address(),
|
|
Topics: topics,
|
|
Data: d,
|
|
// This is a non-consensus field, but assigned here because
|
|
// core/state doesn't know the current block number.
|
|
BlockNumber: interpreter.evm.Context().BlockNumber,
|
|
})
|
|
|
|
return nil, nil
|
|
}
|
|
}
|
|
|
|
// opPush1 is a specialized version of pushN
|
|
func opPush1(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
var (
|
|
codeLen = uint64(len(scope.Contract.Code))
|
|
integer = new(uint256.Int)
|
|
)
|
|
*pc++
|
|
if *pc < codeLen {
|
|
scope.Stack.Push(integer.SetUint64(uint64(scope.Contract.Code[*pc])))
|
|
} else {
|
|
scope.Stack.Push(integer.Clear())
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
// make push instruction function
|
|
func makePush(size uint64, pushByteSize int) executionFunc {
|
|
return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
codeLen := len(scope.Contract.Code)
|
|
|
|
startMin := int(*pc + 1)
|
|
if startMin >= codeLen {
|
|
startMin = codeLen
|
|
}
|
|
endMin := startMin + pushByteSize
|
|
if startMin+pushByteSize >= codeLen {
|
|
endMin = codeLen
|
|
}
|
|
|
|
integer := new(uint256.Int)
|
|
scope.Stack.Push(integer.SetBytes(common.RightPadBytes(
|
|
// So it doesn't matter what we push onto the stack.
|
|
scope.Contract.Code[startMin:endMin], pushByteSize)))
|
|
|
|
*pc += size
|
|
return nil, nil
|
|
}
|
|
}
|
|
|
|
// make dup instruction function
|
|
func makeDup(size int64) executionFunc {
|
|
return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Dup(int(size))
|
|
return nil, nil
|
|
}
|
|
}
|
|
|
|
// make swap instruction function
|
|
func makeSwap(size int64) executionFunc {
|
|
// switch n + 1 otherwise n would be swapped with n
|
|
size++
|
|
return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
|
|
scope.Stack.Swap(int(size))
|
|
return nil, nil
|
|
}
|
|
}
|