mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-07-27 23:26:44 +00:00
consensus, core/*: metropolis features
This commit is contained in:
Jeffrey Wilcke
parent
78c04c920d
commit
1f7e091b09
12 changed files with 700 additions and 140 deletions
|
|
@ -289,6 +289,8 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *
|
|||
func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int {
|
||||
next := new(big.Int).Add(parent.Number, common.Big1)
|
||||
switch {
|
||||
case config.IsMetropolis(next):
|
||||
return calcDifficultyMetropolis(time, parent)
|
||||
case config.IsHomestead(next):
|
||||
return calcDifficultyHomestead(time, parent)
|
||||
default:
|
||||
|
|
@ -299,10 +301,56 @@ func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Heade
|
|||
// Some weird constants to avoid constant memory allocs for them.
|
||||
var (
|
||||
expDiffPeriod = big.NewInt(100000)
|
||||
big9 = big.NewInt(9)
|
||||
big10 = big.NewInt(10)
|
||||
bigMinus99 = big.NewInt(-99)
|
||||
)
|
||||
|
||||
func calcDifficultyMetropolis(time uint64, parent *types.Header) *big.Int {
|
||||
bigTime := new(big.Int).SetUint64(time)
|
||||
bigParentTime := new(big.Int).Set(parent.Time)
|
||||
|
||||
// adj_factor = max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99)
|
||||
var x *big.Int
|
||||
if parent.UncleHash == types.EmptyUncleHash {
|
||||
x = big.NewInt(1)
|
||||
} else {
|
||||
x = big.NewInt(2)
|
||||
}
|
||||
z := new(big.Int).Sub(bigTime, bigParentTime)
|
||||
z.Div(z, big9)
|
||||
x.Sub(x, z)
|
||||
|
||||
// max(1 - (block_timestamp - parent_timestamp) // 10, -99)))
|
||||
if x.Cmp(bigMinus99) < 0 {
|
||||
x.Set(bigMinus99)
|
||||
}
|
||||
|
||||
// (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
|
||||
y := new(big.Int).Div(parent.Difficulty, params.DifficultyBoundDivisor)
|
||||
x.Mul(y, x)
|
||||
x.Add(parent.Difficulty, x)
|
||||
|
||||
// minimum difficulty can ever be (before exponential factor)
|
||||
if x.Cmp(params.MinimumDifficulty) < 0 {
|
||||
x.Set(params.MinimumDifficulty)
|
||||
}
|
||||
|
||||
// for the exponential factor
|
||||
periodCount := new(big.Int).Add(parent.Number, common.Big1)
|
||||
periodCount.Div(periodCount, expDiffPeriod)
|
||||
|
||||
// the exponential factor, commonly referred to as "the bomb"
|
||||
// diff = diff + 2^(periodCount - 2)
|
||||
if periodCount.Cmp(common.Big1) > 0 {
|
||||
y.Sub(periodCount, common.Big2)
|
||||
y.Exp(common.Big2, y, nil)
|
||||
x.Add(x, y)
|
||||
}
|
||||
|
||||
return x
|
||||
}
|
||||
|
||||
// calcDifficultyHomestead is the difficulty adjustment algorithm. It returns
|
||||
// the difficulty that a new block should have when created at time given the
|
||||
// parent block's time and difficulty. The calculation uses the Homestead rules.
|
||||
|
|
|
|||
|
|
@ -105,9 +105,14 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common
|
|||
|
||||
// Update the state with pending changes
|
||||
usedGas.Add(usedGas, gas)
|
||||
var root common.Hash
|
||||
if config.IsMetropolis(header.Number) {
|
||||
statedb.Finalise()
|
||||
} else {
|
||||
root = statedb.IntermediateRoot(config.IsEIP158(header.Number))
|
||||
}
|
||||
// Create a new receipt for the transaction, storing the intermediate root and gas used by the tx
|
||||
// based on the eip phase, we're passing wether the root touch-delete accounts.
|
||||
root := statedb.IntermediateRoot(config.IsEIP158(header.Number))
|
||||
receipt := types.NewReceipt(root.Bytes(), usedGas)
|
||||
receipt.TxHash = tx.Hash()
|
||||
receipt.GasUsed = new(big.Int).Set(gas)
|
||||
|
|
|
|||
|
|
@ -45,6 +45,8 @@ type sigCache struct {
|
|||
func MakeSigner(config *params.ChainConfig, blockNumber *big.Int) Signer {
|
||||
var signer Signer
|
||||
switch {
|
||||
case config.IsMetropolis(blockNumber):
|
||||
signer = NewEIP86Signer(config.ChainId)
|
||||
case config.IsEIP155(blockNumber):
|
||||
signer = NewEIP155Signer(config.ChainId)
|
||||
case config.IsHomestead(blockNumber):
|
||||
|
|
@ -88,6 +90,10 @@ func Sender(signer Signer, tx *Transaction) (common.Address, error) {
|
|||
|
||||
pubkey, err := signer.PublicKey(tx)
|
||||
if err != nil {
|
||||
if err == errAbstractSigner {
|
||||
return abstractSignerAddress, nil
|
||||
}
|
||||
|
||||
return common.Address{}, err
|
||||
}
|
||||
var addr common.Address
|
||||
|
|
@ -108,6 +114,37 @@ type Signer interface {
|
|||
Equal(Signer) bool
|
||||
}
|
||||
|
||||
// EIP86Signer implements the the abstract signing feature
|
||||
type EIP86Signer struct {
|
||||
EIP155Signer
|
||||
}
|
||||
|
||||
func NewEIP86Signer(chainId *big.Int) EIP86Signer {
|
||||
return EIP86Signer{
|
||||
EIP155Signer: NewEIP155Signer(chainId),
|
||||
}
|
||||
}
|
||||
|
||||
func (s EIP86Signer) Equal(s2 Signer) bool {
|
||||
_, ok := s2.(EIP86Signer)
|
||||
return ok && s.EIP155Signer.Equal(s2)
|
||||
}
|
||||
|
||||
// isAbstractSigner checks whether the transaction signature is that of
|
||||
// the abstract signer. The abstract signer is determined by V being equal
|
||||
// to the chain identifier and r and s being 0.
|
||||
func isAbstractSigner(tx *Transaction, chainId *big.Int) bool {
|
||||
v, r, s := tx.RawSignatureValues()
|
||||
return v.Cmp(chainId) == 0 && r.BitLen() == 0 && s.BitLen() == 0
|
||||
}
|
||||
|
||||
func (s EIP86Signer) PublicKey(tx *Transaction) ([]byte, error) {
|
||||
if isAbstractSigner(tx, s.chainId) {
|
||||
return nil, errAbstractSigner
|
||||
}
|
||||
return s.EIP155Signer.PublicKey(tx)
|
||||
}
|
||||
|
||||
// EIP155Transaction implements TransactionInterface using the
|
||||
// EIP155 rules
|
||||
type EIP155Signer struct {
|
||||
|
|
|
|||
|
|
@ -22,7 +22,9 @@ import (
|
|||
"math/big"
|
||||
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/common/math"
|
||||
"github.com/ethereum/go-ethereum/crypto"
|
||||
"github.com/ethereum/go-ethereum/crypto/bn256"
|
||||
"github.com/ethereum/go-ethereum/log"
|
||||
"github.com/ethereum/go-ethereum/params"
|
||||
"golang.org/x/crypto/ripemd160"
|
||||
|
|
@ -46,6 +48,19 @@ var PrecompiledContracts = map[common.Address]PrecompiledContract{
|
|||
common.BytesToAddress([]byte{4}): &dataCopy{},
|
||||
}
|
||||
|
||||
// PrecompiledContractsMetropolis contains the default set of ethereum contracts
|
||||
// for metropolis hardfork
|
||||
var PrecompiledContractsMetropolis = map[common.Address]PrecompiledContract{
|
||||
common.BytesToAddress([]byte{1}): &ecrecover{},
|
||||
common.BytesToAddress([]byte{2}): &sha256hash{},
|
||||
common.BytesToAddress([]byte{3}): &ripemd160hash{},
|
||||
common.BytesToAddress([]byte{4}): &dataCopy{},
|
||||
common.BytesToAddress([]byte{5}): &bigModexp{},
|
||||
common.BytesToAddress([]byte{6}): &bn256Add{},
|
||||
common.BytesToAddress([]byte{6}): &bn256ScalarMul{},
|
||||
common.BytesToAddress([]byte{8}): &pairing{},
|
||||
}
|
||||
|
||||
// RunPrecompile runs and evaluate the output of a precompiled contract defined in contracts.go
|
||||
func RunPrecompiledContract(p PrecompiledContract, input []byte, contract *Contract) (ret []byte, err error) {
|
||||
gas := p.RequiredGas(input)
|
||||
|
|
@ -135,3 +150,191 @@ func (c *dataCopy) RequiredGas(input []byte) uint64 {
|
|||
func (c *dataCopy) Run(in []byte) ([]byte, error) {
|
||||
return in, nil
|
||||
}
|
||||
|
||||
// bigModexp implements a native big integer exponential modular operation.
|
||||
type bigModexp struct{}
|
||||
|
||||
// RequiredGas returns the gas required to execute the pre-compiled contract.
|
||||
//
|
||||
// This method does not require any overflow checking as the input size gas costs
|
||||
// required for anything significant is so high it's impossible to pay for.
|
||||
func (c *bigModexp) RequiredGas(input []byte) uint64 {
|
||||
// TODO reword required gas to have error reporting and convert arithmetic
|
||||
// to uint64.
|
||||
if len(input) < 3*32 {
|
||||
input = append(input, make([]byte, 3*32-len(input))...)
|
||||
}
|
||||
var (
|
||||
baseLen = new(big.Int).SetBytes(input[:31])
|
||||
expLen = math.BigMax(new(big.Int).SetBytes(input[32:64]), big.NewInt(1))
|
||||
modLen = new(big.Int).SetBytes(input[65:97])
|
||||
)
|
||||
x := new(big.Int).Set(math.BigMax(baseLen, modLen))
|
||||
x.Mul(x, x)
|
||||
x.Mul(x, expLen)
|
||||
x.Div(x, new(big.Int).SetUint64(params.QuadCoeffDiv))
|
||||
|
||||
return x.Uint64()
|
||||
}
|
||||
|
||||
func (c *bigModexp) Run(input []byte) ([]byte, error) {
|
||||
if len(input) < 3*32 {
|
||||
input = append(input, make([]byte, 3*32-len(input))...)
|
||||
}
|
||||
// why 32-byte? These values won't fit anyway
|
||||
var (
|
||||
baseLen = new(big.Int).SetBytes(input[:32]).Uint64()
|
||||
expLen = new(big.Int).SetBytes(input[32:64]).Uint64()
|
||||
modLen = new(big.Int).SetBytes(input[64:96]).Uint64()
|
||||
)
|
||||
|
||||
input = input[96:]
|
||||
if uint64(len(input)) < baseLen {
|
||||
input = append(input, make([]byte, baseLen-uint64(len(input)))...)
|
||||
}
|
||||
base := new(big.Int).SetBytes(input[:baseLen])
|
||||
|
||||
input = input[baseLen:]
|
||||
if uint64(len(input)) < expLen {
|
||||
input = append(input, make([]byte, expLen-uint64(len(input)))...)
|
||||
}
|
||||
exp := new(big.Int).SetBytes(input[:expLen])
|
||||
|
||||
input = input[expLen:]
|
||||
if uint64(len(input)) < modLen {
|
||||
input = append(input, make([]byte, modLen-uint64(len(input)))...)
|
||||
}
|
||||
mod := new(big.Int).SetBytes(input[:modLen])
|
||||
|
||||
return base.Exp(base, exp, mod).Bytes(), nil
|
||||
}
|
||||
|
||||
type bn256Add struct{}
|
||||
|
||||
// RequiredGas returns the gas required to execute the pre-compiled contract.
|
||||
//
|
||||
// This method does not require any overflow checking as the input size gas costs
|
||||
// required for anything significant is so high it's impossible to pay for.
|
||||
func (c *bn256Add) RequiredGas(input []byte) uint64 {
|
||||
return 0 // TODO
|
||||
}
|
||||
|
||||
func (c *bn256Add) Run(in []byte) ([]byte, error) {
|
||||
if len(in) != 96 {
|
||||
return nil, errBadPrecompileInput
|
||||
}
|
||||
|
||||
g1, onCurve := new(bn256.G1).Unmarshal(in[:64])
|
||||
if !onCurve {
|
||||
return nil, errNotOnCurve
|
||||
}
|
||||
x, y, _, _ := g1.CurvePoints()
|
||||
if x.Cmp(bn256.P) >= 0 || y.Cmp(bn256.P) >= 0 {
|
||||
return nil, errInvalidCurvePoint
|
||||
}
|
||||
g1.ScalarMult(g1, new(big.Int).SetBytes(in[64:]))
|
||||
|
||||
return g1.Marshal(), nil
|
||||
}
|
||||
|
||||
type bn256ScalarMul struct{}
|
||||
|
||||
// RequiredGas returns the gas required to execute the pre-compiled contract.
|
||||
//
|
||||
// This method does not require any overflow checking as the input size gas costs
|
||||
// required for anything significant is so high it's impossible to pay for.
|
||||
func (c *bn256ScalarMul) RequiredGas(input []byte) uint64 {
|
||||
return 0 // TODO
|
||||
}
|
||||
|
||||
func (c *bn256ScalarMul) Run(in []byte) ([]byte, error) {
|
||||
if len(in) != 128 {
|
||||
return nil, errBadPrecompileInput
|
||||
}
|
||||
|
||||
x, onCurve := new(bn256.G1).Unmarshal(in[:64])
|
||||
if !onCurve {
|
||||
return nil, errNotOnCurve
|
||||
}
|
||||
gx, gy, _, _ := x.CurvePoints()
|
||||
if gx.Cmp(bn256.P) >= 0 || gy.Cmp(bn256.P) >= 0 {
|
||||
return nil, errInvalidCurvePoint
|
||||
}
|
||||
|
||||
y, onCurve := new(bn256.G1).Unmarshal(in[:64])
|
||||
if !onCurve {
|
||||
return nil, errNotOnCurve
|
||||
}
|
||||
gx, gy, _, _ = x.CurvePoints()
|
||||
if gx.Cmp(bn256.P) >= 0 || gy.Cmp(bn256.P) >= 0 {
|
||||
return nil, errInvalidCurvePoint
|
||||
}
|
||||
|
||||
return x.Add(x, y).Marshal(), nil
|
||||
}
|
||||
|
||||
// pairing implements a pairing pre-compile for the bn256 curve
|
||||
type pairing struct{}
|
||||
|
||||
// RequiredGas returns the gas required to execute the pre-compiled contract.
|
||||
//
|
||||
// This method does not require any overflow checking as the input size gas costs
|
||||
// required for anything significant is so high it's impossible to pay for.
|
||||
func (c *pairing) RequiredGas(input []byte) uint64 {
|
||||
return 0 // TODO
|
||||
}
|
||||
|
||||
const pairSize = 192
|
||||
|
||||
var (
|
||||
true32Byte = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
|
||||
fals32Byte = make([]byte, 32)
|
||||
errNotOnCurve = errors.New("point not on elliptic curve")
|
||||
errInvalidCurvePoint = errors.New("invalid elliptic curve point")
|
||||
)
|
||||
|
||||
func (c *pairing) Run(in []byte) ([]byte, error) {
|
||||
if len(in) == 0 {
|
||||
return true32Byte, nil
|
||||
}
|
||||
|
||||
if len(in)%pairSize > 0 {
|
||||
return nil, errBadPrecompileInput
|
||||
}
|
||||
|
||||
var (
|
||||
g1s []*bn256.G1
|
||||
g2s []*bn256.G2
|
||||
)
|
||||
for i := 0; i < len(in); i += pairSize {
|
||||
g1, onCurve := new(bn256.G1).Unmarshal(in[i : i+64])
|
||||
if !onCurve {
|
||||
return nil, errNotOnCurve
|
||||
}
|
||||
|
||||
x, y, _, _ := g1.CurvePoints()
|
||||
if x.Cmp(bn256.P) >= 0 || y.Cmp(bn256.P) >= 0 {
|
||||
return nil, errInvalidCurvePoint
|
||||
}
|
||||
|
||||
g2, onCurve := new(bn256.G2).Unmarshal(in[i+64 : i+192])
|
||||
if !onCurve {
|
||||
return nil, errNotOnCurve
|
||||
}
|
||||
x2, y2, _, _ := g2.CurvePoints()
|
||||
if x2.Real().Cmp(bn256.P) >= 0 || x2.Imag().Cmp(bn256.P) >= 0 ||
|
||||
y2.Real().Cmp(bn256.P) >= 0 || y2.Imag().Cmp(bn256.P) >= 0 {
|
||||
return nil, errInvalidCurvePoint
|
||||
}
|
||||
|
||||
g1s = append(g1s, g1)
|
||||
g2s = append(g2s, g2)
|
||||
}
|
||||
|
||||
isOne := bn256.PairingCheck(g1s, g2s)
|
||||
if isOne {
|
||||
return true32Byte, nil
|
||||
}
|
||||
|
||||
return fals32Byte, nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1 +1,35 @@
|
|||
package vm
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
)
|
||||
|
||||
const input = ""
|
||||
|
||||
func TestPairing(t *testing.T) {
|
||||
pairing := &pairing{}
|
||||
|
||||
for i, test := range []struct {
|
||||
input string
|
||||
valid int
|
||||
}{
|
||||
{"1c76476f4def4bb94541d57ebba1193381ffa7aa76ada664dd31c16024c43f593034dd2920f673e204fee2811c678745fc819b55d3e9d294e45c9b03a76aef41209dd15ebff5d46c4bd888e51a93cf99a7329636c63514396b4a452003a35bf704bf11ca01483bfa8b34b43561848d28905960114c8ac04049af4b6315a416782bb8324af6cfc93537a2ad1a445cfd0ca2a71acd7ac41fadbf933c2a51be344d120a2a4cf30c1bf9845f20c6fe39e07ea2cce61f0c9bb048165fe5e4de877550111e129f1cf1097710d41c4ac70fcdfa5ba2023c6ff1cbeac322de49d1b6df7c2032c61a830e3c17286de9462bf242fca2883585b93870a73853face6a6bf411198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa", 1},
|
||||
{"2eca0c7238bf16e83e7a1e6c5d49540685ff51380f309842a98561558019fc0203d3260361bb8451de5ff5ecd17f010ff22f5c31cdf184e9020b06fa5997db841213d2149b006137fcfb23036606f848d638d576a120ca981b5b1a5f9300b3ee2276cf730cf493cd95d64677bbb75fc42db72513a4c1e387b476d056f80aa75f21ee6226d31426322afcda621464d0611d226783262e21bb3bc86b537e986237096df1f82dff337dd5972e32a8ad43e28a78a96a823ef1cd4debe12b6552ea5f06967a1237ebfeca9aaae0d6d0bab8e28c198c5a339ef8a2407e31cdac516db922160fa257a5fd5b280642ff47b65eca77e626cb685c84fa6d3b6882a283ddd1198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa", 1},
|
||||
{"0f25929bcb43d5a57391564615c9e70a992b10eafa4db109709649cf48c50dd216da2f5cb6be7a0aa72c440c53c9bbdfec6c36c7d515536431b3a865468acbba2e89718ad33c8bed92e210e81d1853435399a271913a6520736a4729cf0d51eb01a9e2ffa2e92599b68e44de5bcf354fa2642bd4f26b259daa6f7ce3ed57aeb314a9a87b789a58af499b314e13c3d65bede56c07ea2d418d6874857b70763713178fb49a2d6cd347dc58973ff49613a20757d0fcc22079f9abd10c3baee245901b9e027bd5cfc2cb5db82d4dc9677ac795ec500ecd47deee3b5da006d6d049b811d7511c78158de484232fc68daf8a45cf217d1c2fae693ff5871e8752d73b21198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa", 1},
|
||||
{"2f2ea0b3da1e8ef11914acf8b2e1b32d99df51f5f4f206fc6b947eae860eddb6068134ddb33dc888ef446b648d72338684d678d2eb2371c61a50734d78da4b7225f83c8b6ab9de74e7da488ef02645c5a16a6652c3c71a15dc37fe3a5dcb7cb122acdedd6308e3bb230d226d16a105295f523a8a02bfc5e8bd2da135ac4c245d065bbad92e7c4e31bf3757f1fe7362a63fbfee50e7dc68da116e67d600d9bf6806d302580dc0661002994e7cd3a7f224e7ddc27802777486bf80f40e4ca3cfdb186bac5188a98c45e6016873d107f5cd131f3a3e339d0375e58bd6219347b008122ae2b09e539e152ec5364e7e2204b03d11d3caa038bfc7cd499f8176aacbee1f39e4e4afc4bc74790a4a028aff2c3d2538731fb755edefd8cb48d6ea589b5e283f150794b6736f670d6a1033f9b46c6f5204f50813eb85c8dc4b59db1c5d39140d97ee4d2b36d99bc49974d18ecca3e7ad51011956051b464d9e27d46cc25e0764bb98575bd466d32db7b15f582b2d5c452b36aa394b789366e5e3ca5aabd415794ab061441e51d01e94640b7e3084a07e02c78cf3103c542bc5b298669f211b88da1679b0b64a63b7e0e7bfe52aae524f73a55be7fe70c7e9bfc94b4cf0da1213d2149b006137fcfb23036606f848d638d576a120ca981b5b1a5f9300b3ee2276cf730cf493cd95d64677bbb75fc42db72513a4c1e387b476d056f80aa75f21ee6226d31426322afcda621464d0611d226783262e21bb3bc86b537e986237096df1f82dff337dd5972e32a8ad43e28a78a96a823ef1cd4debe12b6552ea5f", 1},
|
||||
{"20a754d2071d4d53903e3b31a7e98ad6882d58aec240ef981fdf0a9d22c5926a29c853fcea789887315916bbeb89ca37edb355b4f980c9a12a94f30deeed30211213d2149b006137fcfb23036606f848d638d576a120ca981b5b1a5f9300b3ee2276cf730cf493cd95d64677bbb75fc42db72513a4c1e387b476d056f80aa75f21ee6226d31426322afcda621464d0611d226783262e21bb3bc86b537e986237096df1f82dff337dd5972e32a8ad43e28a78a96a823ef1cd4debe12b6552ea5f1abb4a25eb9379ae96c84fff9f0540abcfc0a0d11aeda02d4f37e4baf74cb0c11073b3ff2cdbb38755f8691ea59e9606696b3ff278acfc098fa8226470d03869217cee0a9ad79a4493b5253e2e4e3a39fc2df38419f230d341f60cb064a0ac290a3d76f140db8418ba512272381446eb73958670f00cf46f1d9e64cba057b53c26f64a8ec70387a13e41430ed3ee4a7db2059cc5fc13c067194bcc0cb49a98552fd72bd9edb657346127da132e5b82ab908f5816c826acb499e22f2412d1a2d70f25929bcb43d5a57391564615c9e70a992b10eafa4db109709649cf48c50dd2198a1f162a73261f112401aa2db79c7dab1533c9935c77290a6ce3b191f2318d198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa", 1},
|
||||
{"1c76476f4def4bb94541d57ebba1193381ffa7aa76ada664dd31c16024c43f593034dd2920f673e204fee2811c678745fc819b55d3e9d294e45c9b03a76aef41209dd15ebff5d46c4bd888e51a93cf99a7329636c63514396b4a452003a35bf704bf11ca01483bfa8b34b43561848d28905960114c8ac04049af4b6315a416782bb8324af6cfc93537a2ad1a445cfd0ca2a71acd7ac41fadbf933c2a51be344d120a2a4cf30c1bf9845f20c6fe39e07ea2cce61f0c9bb048165fe5e4de877550111e129f1cf1097710d41c4ac70fcdfa5ba2023c6ff1cbeac322de49d1b6df7c103188585e2364128fe25c70558f1560f4f9350baf3959e603cc91486e110936198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa", 0},
|
||||
} {
|
||||
r, err := pairing.Run(common.FromHex(test.input))
|
||||
if err != nil {
|
||||
t.Error(i, ":", err)
|
||||
}
|
||||
|
||||
if int(r[31]) != test.valid {
|
||||
t.Error(i, "expected", test.valid, "but was", r[31])
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,6 +37,10 @@ type (
|
|||
func run(evm *EVM, snapshot int, contract *Contract, input []byte) ([]byte, error) {
|
||||
if contract.CodeAddr != nil {
|
||||
precompiledContracts := PrecompiledContracts
|
||||
if evm.ChainConfig().IsMetropolis(evm.BlockNumber) {
|
||||
precompiledContracts = PrecompiledContractsMetropolis
|
||||
}
|
||||
|
||||
if p := precompiledContracts[*contract.CodeAddr]; p != nil {
|
||||
return RunPrecompiledContract(p, input, contract)
|
||||
}
|
||||
|
|
@ -121,6 +125,51 @@ func (evm *EVM) Cancel() {
|
|||
atomic.StoreInt32(&evm.abort, 1)
|
||||
}
|
||||
|
||||
func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error) {
|
||||
if evm.vmConfig.NoRecursion && evm.depth > 0 {
|
||||
return nil, gas, nil
|
||||
}
|
||||
|
||||
// Depth check execution. Fail if we're trying to execute above the
|
||||
// limit.
|
||||
if evm.depth > int(params.CallCreateDepth) {
|
||||
return nil, gas, ErrDepth
|
||||
}
|
||||
|
||||
// make sure the readonly is only set if we aren't in readonly yet
|
||||
// this makes also sure that the readonly flag isn't removed for
|
||||
// child calls.
|
||||
if !evm.interpreter.readonly {
|
||||
evm.interpreter.readonly = true
|
||||
defer func() { evm.interpreter.readonly = false }()
|
||||
}
|
||||
|
||||
var (
|
||||
to = AccountRef(addr)
|
||||
snapshot = evm.StateDB.Snapshot()
|
||||
)
|
||||
if !evm.StateDB.Exist(addr) {
|
||||
return nil, gas, nil
|
||||
}
|
||||
|
||||
// initialise a new contract and set the code that is to be used by the
|
||||
// E The contract is a scoped evmironment for this execution context
|
||||
// only.
|
||||
contract := NewContract(caller, to, new(big.Int), gas)
|
||||
contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
|
||||
|
||||
ret, err = evm.interpreter.Run(snapshot, contract, input)
|
||||
// When an error was returned by the EVM or when setting the creation code
|
||||
// above we revert to the snapshot and consume any gas remaining. Additionally
|
||||
// when we're in homestead this also counts for code storage gas errors.
|
||||
if err != nil {
|
||||
contract.UseGas(contract.Gas)
|
||||
|
||||
evm.StateDB.RevertToSnapshot(snapshot)
|
||||
}
|
||||
return ret, contract.Gas, err
|
||||
}
|
||||
|
||||
// Call executes the contract associated with the addr with the given input as parameters. It also handles any
|
||||
// necessary value transfer required and takes the necessary steps to create accounts and reverses the state in
|
||||
// case of an execution error or failed value transfer.
|
||||
|
|
|
|||
|
|
@ -87,6 +87,32 @@ func gasCalldataCopy(gt params.GasTable, evm *EVM, contract *Contract, stack *St
|
|||
return gas, nil
|
||||
}
|
||||
|
||||
func gasReturnDataCopy(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
|
||||
gas, err := memoryGasCost(mem, memorySize)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
var overflow bool
|
||||
if gas, overflow = math.SafeAdd(gas, GasFastestStep); overflow {
|
||||
return 0, errGasUintOverflow
|
||||
}
|
||||
|
||||
words, overflow := bigUint64(stack.Back(2))
|
||||
if overflow {
|
||||
return 0, errGasUintOverflow
|
||||
}
|
||||
|
||||
if words, overflow = math.SafeMul(toWordSize(words), params.CopyGas); overflow {
|
||||
return 0, errGasUintOverflow
|
||||
}
|
||||
|
||||
if gas, overflow = math.SafeAdd(gas, words); overflow {
|
||||
return 0, errGasUintOverflow
|
||||
}
|
||||
return gas, nil
|
||||
}
|
||||
|
||||
func gasSStore(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
|
||||
var (
|
||||
y, x = stack.Back(1), stack.Back(0)
|
||||
|
|
@ -419,6 +445,35 @@ func gasDelegateCall(gt params.GasTable, evm *EVM, contract *Contract, stack *St
|
|||
return gas, nil
|
||||
}
|
||||
|
||||
func gasStaticCall(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
|
||||
panic("verify this one")
|
||||
|
||||
gas, err := memoryGasCost(mem, memorySize)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
var overflow bool
|
||||
if gas, overflow = math.SafeAdd(gas, gt.Calls); overflow {
|
||||
return 0, errGasUintOverflow
|
||||
}
|
||||
|
||||
cg, err := callGas(gt, contract.Gas, gas, stack.Back(0))
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
// Replace the stack item with the new gas calculation. This means that
|
||||
// either the original item is left on the stack or the item is replaced by:
|
||||
// (availableGas - gas) * 63 / 64
|
||||
// We replace the stack item so that it's available when the opCall instruction is
|
||||
// called.
|
||||
stack.data[stack.len()-1] = new(big.Int).SetUint64(cg)
|
||||
|
||||
if gas, overflow = math.SafeAdd(gas, cg); overflow {
|
||||
return 0, errGasUintOverflow
|
||||
}
|
||||
return gas, nil
|
||||
}
|
||||
|
||||
func gasPush(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
|
||||
return GasFastestStep, nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@
|
|||
package vm
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"math/big"
|
||||
|
||||
|
|
@ -28,7 +29,8 @@ import (
|
|||
)
|
||||
|
||||
var (
|
||||
bigZero = new(big.Int)
|
||||
bigZero = new(big.Int)
|
||||
errWriteProtection = errors.New("evm write protection")
|
||||
)
|
||||
|
||||
func opAdd(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
|
||||
|
|
@ -570,6 +572,35 @@ func opCreate(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *S
|
|||
return nil, nil
|
||||
}
|
||||
|
||||
func opStaticCall(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
|
||||
// pop gas
|
||||
gas := stack.pop().Uint64()
|
||||
// pop address
|
||||
addr := stack.pop()
|
||||
// pop input size and offset
|
||||
inOffset, inSize := stack.pop(), stack.pop()
|
||||
// pop return size and offset
|
||||
retOffset, retSize := stack.pop(), stack.pop()
|
||||
|
||||
address := common.BigToAddress(addr)
|
||||
|
||||
// Get the arguments from the memory
|
||||
args := memory.Get(inOffset.Int64(), inSize.Int64())
|
||||
|
||||
ret, returnGas, err := evm.StaticCall(contract, address, args, gas)
|
||||
if err != nil {
|
||||
stack.push(new(big.Int))
|
||||
} else {
|
||||
stack.push(big.NewInt(1))
|
||||
|
||||
memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
|
||||
}
|
||||
contract.Gas += returnGas
|
||||
|
||||
evm.interpreter.intPool.put(addr, inOffset, inSize, retOffset, retSize)
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
func opCall(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
|
||||
gas := stack.pop().Uint64()
|
||||
// pop gas and value of the stack.
|
||||
|
|
@ -665,6 +696,14 @@ func opReturn(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *S
|
|||
return ret, nil
|
||||
}
|
||||
|
||||
func opRevert(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
|
||||
offset, size := stack.pop(), stack.pop()
|
||||
ret := memory.GetPtr(offset.Int64(), size.Int64())
|
||||
|
||||
evm.interpreter.intPool.put(offset, size)
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
func opStop(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
|
@ -678,6 +717,23 @@ func opSuicide(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *
|
|||
return nil, nil
|
||||
}
|
||||
|
||||
func opReturnDataSize(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
|
||||
stack.push(evm.interpreter.intPool.get().SetUint64(uint64(len(memory.lastReturn))))
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func opReturnDataCopy(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
|
||||
var (
|
||||
mOff = stack.pop()
|
||||
cOff = stack.pop()
|
||||
l = stack.pop()
|
||||
)
|
||||
memory.Set(mOff.Uint64(), l.Uint64(), getData(memory.lastReturn, cOff, l))
|
||||
|
||||
evm.interpreter.intPool.put(mOff, cOff, l)
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// following functions are used by the instruction jump table
|
||||
|
||||
// make log instruction function
|
||||
|
|
|
|||
|
|
@ -51,10 +51,9 @@ type Config struct {
|
|||
JumpTable [256]operation
|
||||
}
|
||||
|
||||
// Interpreter is used to run Ethereum based contracts and will utilise the
|
||||
// passed evmironment to query external sources for state information.
|
||||
// The Interpreter will run the byte code VM or JIT VM based on the passed
|
||||
// configuration.
|
||||
// Interpreter is capable of interpreting Ethereum Byte code and uses the passed
|
||||
// Ethereum Virtual Machine to query for auxiliary data such as state, block and
|
||||
// caller information.
|
||||
type Interpreter struct {
|
||||
evm *EVM
|
||||
cfg Config
|
||||
|
|
@ -71,6 +70,8 @@ func NewInterpreter(evm *EVM, cfg Config) *Interpreter {
|
|||
// we'll set the default jump table.
|
||||
if !cfg.JumpTable[STOP].valid {
|
||||
switch {
|
||||
case evm.ChainConfig().IsMetropolis(evm.BlockNumber):
|
||||
cfg.JumpTable = metropolisInstructionSet
|
||||
case evm.ChainConfig().IsHomestead(evm.BlockNumber):
|
||||
cfg.JumpTable = homesteadInstructionSet
|
||||
default:
|
||||
|
|
@ -87,6 +88,16 @@ func NewInterpreter(evm *EVM, cfg Config) *Interpreter {
|
|||
}
|
||||
|
||||
func (in *Interpreter) enforceRestrictions(op OpCode, operation operation, stack *Stack) error {
|
||||
if in.evm.chainRules.IsMetropolis {
|
||||
if in.readonly {
|
||||
// if the interpreter is operating in readonly mode, make sure no
|
||||
// state-modifying operation is performed.
|
||||
if operation.writes ||
|
||||
((op == CALL || op == CALLCODE) && stack.Back(3).BitLen() > 0) {
|
||||
return errWriteProtection
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
@ -201,6 +212,11 @@ func (in *Interpreter) Run(snapshot int, contract *Contract, input []byte) (ret
|
|||
verifyIntegerPool(in.intPool)
|
||||
}
|
||||
|
||||
// checks whether the operation should revert state.
|
||||
if operation.reverts {
|
||||
in.evm.StateDB.RevertToSnapshot(snapshot)
|
||||
}
|
||||
|
||||
switch {
|
||||
case err != nil:
|
||||
return nil, err
|
||||
|
|
|
|||
|
|
@ -56,12 +56,43 @@ type operation struct {
|
|||
}
|
||||
|
||||
var (
|
||||
frontierInstructionSet = NewFrontierInstructionSet()
|
||||
homesteadInstructionSet = NewHomesteadInstructionSet()
|
||||
frontierInstructionSet = NewFrontierInstructionSet()
|
||||
homesteadInstructionSet = NewHomesteadInstructionSet()
|
||||
metropolisInstructionSet = NewMetropolisInstructionSet()
|
||||
)
|
||||
|
||||
// NewHomesteadInstructionSet returns the frontier and homestead
|
||||
// instructions that can be executed during the homestead phase.
|
||||
func NewMetropolisInstructionSet() [256]operation {
|
||||
instructionSet := NewHomesteadInstructionSet()
|
||||
instructionSet[STATIC_CALL] = operation{
|
||||
execute: opStaticCall,
|
||||
gasCost: gasStaticCall,
|
||||
validateStack: makeStackFunc(6, 1),
|
||||
memorySize: memoryStaticCall,
|
||||
valid: true,
|
||||
}
|
||||
instructionSet[REVERT] = operation{
|
||||
execute: opRevert,
|
||||
gasCost: constGasFunc(GasFastestStep),
|
||||
validateStack: makeStackFunc(2, 0),
|
||||
valid: true,
|
||||
reverts: true,
|
||||
}
|
||||
instructionSet[RETURNDATASIZE] = operation{
|
||||
execute: opReturnDataSize,
|
||||
gasCost: constGasFunc(0), // TODO
|
||||
validateStack: makeStackFunc(0, 1),
|
||||
valid: true,
|
||||
}
|
||||
instructionSet[RETURNDATACOPY] = operation{
|
||||
execute: opReturnDataCopy,
|
||||
gasCost: gasReturnDataCopy,
|
||||
validateStack: makeStackFunc(3, 0),
|
||||
memorySize: memoryReturnDataCopy,
|
||||
valid: true,
|
||||
}
|
||||
return instructionSet
|
||||
}
|
||||
|
||||
func NewHomesteadInstructionSet() [256]operation {
|
||||
instructionSet := NewFrontierInstructionSet()
|
||||
instructionSet[DELEGATECALL] = operation{
|
||||
|
|
|
|||
|
|
@ -30,6 +30,10 @@ func memoryCalldataCopy(stack *Stack) *big.Int {
|
|||
return calcMemSize(stack.Back(0), stack.Back(2))
|
||||
}
|
||||
|
||||
func memoryReturnDataCopy(stack *Stack) *big.Int {
|
||||
return calcMemSize(stack.Back(0), stack.Back(2))
|
||||
}
|
||||
|
||||
func memoryCodeCopy(stack *Stack) *big.Int {
|
||||
return calcMemSize(stack.Back(0), stack.Back(2))
|
||||
}
|
||||
|
|
@ -74,6 +78,13 @@ func memoryDelegateCall(stack *Stack) *big.Int {
|
|||
return math.BigMax(x, y)
|
||||
}
|
||||
|
||||
func memoryStaticCall(stack *Stack) *big.Int {
|
||||
x := calcMemSize(stack.Back(4), stack.Back(5))
|
||||
y := calcMemSize(stack.Back(2), stack.Back(3))
|
||||
|
||||
return math.BigMax(x, y)
|
||||
}
|
||||
|
||||
func memoryReturn(stack *Stack) *big.Int {
|
||||
return calcMemSize(stack.Back(0), stack.Back(1))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -194,6 +194,11 @@ const (
|
|||
SWAP
|
||||
)
|
||||
|
||||
const (
|
||||
RETURNDATASIZE OpCode = 0xd0 + iota
|
||||
RETURNDATACOPY
|
||||
)
|
||||
|
||||
const (
|
||||
// 0xf0 range - closures
|
||||
CREATE OpCode = 0xf0 + iota
|
||||
|
|
@ -201,7 +206,9 @@ const (
|
|||
CALLCODE
|
||||
RETURN
|
||||
DELEGATECALL
|
||||
STATIC_CALL
|
||||
|
||||
REVERT = 0xfd
|
||||
SELFDESTRUCT = 0xff
|
||||
)
|
||||
|
||||
|
|
@ -349,13 +356,17 @@ var opCodeToString = map[OpCode]string{
|
|||
LOG3: "LOG3",
|
||||
LOG4: "LOG4",
|
||||
|
||||
RETURNDATASIZE: "RETURNDATASIZE",
|
||||
RETURNDATACOPY: "RETURNDATACOPY",
|
||||
// 0xf0 range
|
||||
CREATE: "CREATE",
|
||||
CALL: "CALL",
|
||||
RETURN: "RETURN",
|
||||
REVERT: "REVERT",
|
||||
CALLCODE: "CALLCODE",
|
||||
DELEGATECALL: "DELEGATECALL",
|
||||
SELFDESTRUCT: "SELFDESTRUCT",
|
||||
STATIC_CALL: "STATIC_CALL",
|
||||
|
||||
PUSH: "PUSH",
|
||||
DUP: "DUP",
|
||||
|
|
@ -372,136 +383,140 @@ func (o OpCode) String() string {
|
|||
}
|
||||
|
||||
var stringToOp = map[string]OpCode{
|
||||
"STOP": STOP,
|
||||
"ADD": ADD,
|
||||
"MUL": MUL,
|
||||
"SUB": SUB,
|
||||
"DIV": DIV,
|
||||
"SDIV": SDIV,
|
||||
"MOD": MOD,
|
||||
"SMOD": SMOD,
|
||||
"EXP": EXP,
|
||||
"NOT": NOT,
|
||||
"LT": LT,
|
||||
"GT": GT,
|
||||
"SLT": SLT,
|
||||
"SGT": SGT,
|
||||
"EQ": EQ,
|
||||
"ISZERO": ISZERO,
|
||||
"SIGNEXTEND": SIGNEXTEND,
|
||||
"AND": AND,
|
||||
"OR": OR,
|
||||
"XOR": XOR,
|
||||
"BYTE": BYTE,
|
||||
"ADDMOD": ADDMOD,
|
||||
"MULMOD": MULMOD,
|
||||
"SHA3": SHA3,
|
||||
"ADDRESS": ADDRESS,
|
||||
"BALANCE": BALANCE,
|
||||
"ORIGIN": ORIGIN,
|
||||
"CALLER": CALLER,
|
||||
"CALLVALUE": CALLVALUE,
|
||||
"CALLDATALOAD": CALLDATALOAD,
|
||||
"CALLDATASIZE": CALLDATASIZE,
|
||||
"CALLDATACOPY": CALLDATACOPY,
|
||||
"DELEGATECALL": DELEGATECALL,
|
||||
"CODESIZE": CODESIZE,
|
||||
"CODECOPY": CODECOPY,
|
||||
"GASPRICE": GASPRICE,
|
||||
"BLOCKHASH": BLOCKHASH,
|
||||
"COINBASE": COINBASE,
|
||||
"TIMESTAMP": TIMESTAMP,
|
||||
"NUMBER": NUMBER,
|
||||
"DIFFICULTY": DIFFICULTY,
|
||||
"GASLIMIT": GASLIMIT,
|
||||
"EXTCODESIZE": EXTCODESIZE,
|
||||
"EXTCODECOPY": EXTCODECOPY,
|
||||
"POP": POP,
|
||||
"MLOAD": MLOAD,
|
||||
"MSTORE": MSTORE,
|
||||
"MSTORE8": MSTORE8,
|
||||
"SLOAD": SLOAD,
|
||||
"SSTORE": SSTORE,
|
||||
"JUMP": JUMP,
|
||||
"JUMPI": JUMPI,
|
||||
"PC": PC,
|
||||
"MSIZE": MSIZE,
|
||||
"GAS": GAS,
|
||||
"JUMPDEST": JUMPDEST,
|
||||
"PUSH1": PUSH1,
|
||||
"PUSH2": PUSH2,
|
||||
"PUSH3": PUSH3,
|
||||
"PUSH4": PUSH4,
|
||||
"PUSH5": PUSH5,
|
||||
"PUSH6": PUSH6,
|
||||
"PUSH7": PUSH7,
|
||||
"PUSH8": PUSH8,
|
||||
"PUSH9": PUSH9,
|
||||
"PUSH10": PUSH10,
|
||||
"PUSH11": PUSH11,
|
||||
"PUSH12": PUSH12,
|
||||
"PUSH13": PUSH13,
|
||||
"PUSH14": PUSH14,
|
||||
"PUSH15": PUSH15,
|
||||
"PUSH16": PUSH16,
|
||||
"PUSH17": PUSH17,
|
||||
"PUSH18": PUSH18,
|
||||
"PUSH19": PUSH19,
|
||||
"PUSH20": PUSH20,
|
||||
"PUSH21": PUSH21,
|
||||
"PUSH22": PUSH22,
|
||||
"PUSH23": PUSH23,
|
||||
"PUSH24": PUSH24,
|
||||
"PUSH25": PUSH25,
|
||||
"PUSH26": PUSH26,
|
||||
"PUSH27": PUSH27,
|
||||
"PUSH28": PUSH28,
|
||||
"PUSH29": PUSH29,
|
||||
"PUSH30": PUSH30,
|
||||
"PUSH31": PUSH31,
|
||||
"PUSH32": PUSH32,
|
||||
"DUP1": DUP1,
|
||||
"DUP2": DUP2,
|
||||
"DUP3": DUP3,
|
||||
"DUP4": DUP4,
|
||||
"DUP5": DUP5,
|
||||
"DUP6": DUP6,
|
||||
"DUP7": DUP7,
|
||||
"DUP8": DUP8,
|
||||
"DUP9": DUP9,
|
||||
"DUP10": DUP10,
|
||||
"DUP11": DUP11,
|
||||
"DUP12": DUP12,
|
||||
"DUP13": DUP13,
|
||||
"DUP14": DUP14,
|
||||
"DUP15": DUP15,
|
||||
"DUP16": DUP16,
|
||||
"SWAP1": SWAP1,
|
||||
"SWAP2": SWAP2,
|
||||
"SWAP3": SWAP3,
|
||||
"SWAP4": SWAP4,
|
||||
"SWAP5": SWAP5,
|
||||
"SWAP6": SWAP6,
|
||||
"SWAP7": SWAP7,
|
||||
"SWAP8": SWAP8,
|
||||
"SWAP9": SWAP9,
|
||||
"SWAP10": SWAP10,
|
||||
"SWAP11": SWAP11,
|
||||
"SWAP12": SWAP12,
|
||||
"SWAP13": SWAP13,
|
||||
"SWAP14": SWAP14,
|
||||
"SWAP15": SWAP15,
|
||||
"SWAP16": SWAP16,
|
||||
"LOG0": LOG0,
|
||||
"LOG1": LOG1,
|
||||
"LOG2": LOG2,
|
||||
"LOG3": LOG3,
|
||||
"LOG4": LOG4,
|
||||
"CREATE": CREATE,
|
||||
"CALL": CALL,
|
||||
"RETURN": RETURN,
|
||||
"CALLCODE": CALLCODE,
|
||||
"SELFDESTRUCT": SELFDESTRUCT,
|
||||
"STOP": STOP,
|
||||
"ADD": ADD,
|
||||
"MUL": MUL,
|
||||
"SUB": SUB,
|
||||
"DIV": DIV,
|
||||
"SDIV": SDIV,
|
||||
"MOD": MOD,
|
||||
"SMOD": SMOD,
|
||||
"EXP": EXP,
|
||||
"NOT": NOT,
|
||||
"LT": LT,
|
||||
"GT": GT,
|
||||
"SLT": SLT,
|
||||
"SGT": SGT,
|
||||
"EQ": EQ,
|
||||
"ISZERO": ISZERO,
|
||||
"SIGNEXTEND": SIGNEXTEND,
|
||||
"AND": AND,
|
||||
"OR": OR,
|
||||
"XOR": XOR,
|
||||
"BYTE": BYTE,
|
||||
"ADDMOD": ADDMOD,
|
||||
"MULMOD": MULMOD,
|
||||
"SHA3": SHA3,
|
||||
"ADDRESS": ADDRESS,
|
||||
"BALANCE": BALANCE,
|
||||
"ORIGIN": ORIGIN,
|
||||
"CALLER": CALLER,
|
||||
"CALLVALUE": CALLVALUE,
|
||||
"CALLDATALOAD": CALLDATALOAD,
|
||||
"CALLDATASIZE": CALLDATASIZE,
|
||||
"CALLDATACOPY": CALLDATACOPY,
|
||||
"DELEGATECALL": DELEGATECALL,
|
||||
"STATIC_CALL": STATIC_CALL,
|
||||
"CODESIZE": CODESIZE,
|
||||
"CODECOPY": CODECOPY,
|
||||
"GASPRICE": GASPRICE,
|
||||
"BLOCKHASH": BLOCKHASH,
|
||||
"COINBASE": COINBASE,
|
||||
"TIMESTAMP": TIMESTAMP,
|
||||
"NUMBER": NUMBER,
|
||||
"DIFFICULTY": DIFFICULTY,
|
||||
"GASLIMIT": GASLIMIT,
|
||||
"EXTCODESIZE": EXTCODESIZE,
|
||||
"EXTCODECOPY": EXTCODECOPY,
|
||||
"POP": POP,
|
||||
"MLOAD": MLOAD,
|
||||
"MSTORE": MSTORE,
|
||||
"MSTORE8": MSTORE8,
|
||||
"SLOAD": SLOAD,
|
||||
"SSTORE": SSTORE,
|
||||
"JUMP": JUMP,
|
||||
"JUMPI": JUMPI,
|
||||
"PC": PC,
|
||||
"MSIZE": MSIZE,
|
||||
"GAS": GAS,
|
||||
"JUMPDEST": JUMPDEST,
|
||||
"PUSH1": PUSH1,
|
||||
"PUSH2": PUSH2,
|
||||
"PUSH3": PUSH3,
|
||||
"PUSH4": PUSH4,
|
||||
"PUSH5": PUSH5,
|
||||
"PUSH6": PUSH6,
|
||||
"PUSH7": PUSH7,
|
||||
"PUSH8": PUSH8,
|
||||
"PUSH9": PUSH9,
|
||||
"PUSH10": PUSH10,
|
||||
"PUSH11": PUSH11,
|
||||
"PUSH12": PUSH12,
|
||||
"PUSH13": PUSH13,
|
||||
"PUSH14": PUSH14,
|
||||
"PUSH15": PUSH15,
|
||||
"PUSH16": PUSH16,
|
||||
"PUSH17": PUSH17,
|
||||
"PUSH18": PUSH18,
|
||||
"PUSH19": PUSH19,
|
||||
"PUSH20": PUSH20,
|
||||
"PUSH21": PUSH21,
|
||||
"PUSH22": PUSH22,
|
||||
"PUSH23": PUSH23,
|
||||
"PUSH24": PUSH24,
|
||||
"PUSH25": PUSH25,
|
||||
"PUSH26": PUSH26,
|
||||
"PUSH27": PUSH27,
|
||||
"PUSH28": PUSH28,
|
||||
"PUSH29": PUSH29,
|
||||
"PUSH30": PUSH30,
|
||||
"PUSH31": PUSH31,
|
||||
"PUSH32": PUSH32,
|
||||
"DUP1": DUP1,
|
||||
"DUP2": DUP2,
|
||||
"DUP3": DUP3,
|
||||
"DUP4": DUP4,
|
||||
"DUP5": DUP5,
|
||||
"DUP6": DUP6,
|
||||
"DUP7": DUP7,
|
||||
"DUP8": DUP8,
|
||||
"DUP9": DUP9,
|
||||
"DUP10": DUP10,
|
||||
"DUP11": DUP11,
|
||||
"DUP12": DUP12,
|
||||
"DUP13": DUP13,
|
||||
"DUP14": DUP14,
|
||||
"DUP15": DUP15,
|
||||
"DUP16": DUP16,
|
||||
"SWAP1": SWAP1,
|
||||
"SWAP2": SWAP2,
|
||||
"SWAP3": SWAP3,
|
||||
"SWAP4": SWAP4,
|
||||
"SWAP5": SWAP5,
|
||||
"SWAP6": SWAP6,
|
||||
"SWAP7": SWAP7,
|
||||
"SWAP8": SWAP8,
|
||||
"SWAP9": SWAP9,
|
||||
"SWAP10": SWAP10,
|
||||
"SWAP11": SWAP11,
|
||||
"SWAP12": SWAP12,
|
||||
"SWAP13": SWAP13,
|
||||
"SWAP14": SWAP14,
|
||||
"SWAP15": SWAP15,
|
||||
"SWAP16": SWAP16,
|
||||
"LOG0": LOG0,
|
||||
"LOG1": LOG1,
|
||||
"LOG2": LOG2,
|
||||
"LOG3": LOG3,
|
||||
"LOG4": LOG4,
|
||||
"CREATE": CREATE,
|
||||
"CALL": CALL,
|
||||
"RETURN": RETURN,
|
||||
"REVERT": REVERT,
|
||||
"CALLCODE": CALLCODE,
|
||||
"SELFDESTRUCT": SELFDESTRUCT,
|
||||
"RETURNDATASIZE": RETURNDATASIZE,
|
||||
"RETURNDATACOPY": RETURNDATACOPY,
|
||||
}
|
||||
|
||||
func StringToOp(str string) OpCode {
|
||||
|
|
|
|||
Loading…
Reference in a new issue