21 files changed, 1652 insertions, 1205 deletions
diff --git a/core/vm/common.go b/core/vm/common.go
index ead30fc..90ba4a4 100644
--- a/core/vm/common.go
+++ b/core/vm/common.go
@@ -17,15 +17,14 @@
 package vm
 
 import (
- "math/big"
-
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/math"
+ "github.com/holiman/uint256"
 )
 
 // calcMemSize64 calculates the required memory size, and returns
 // the size and whether the result overflowed uint64
-func calcMemSize64(off, l *big.Int) (uint64, bool) {
+func calcMemSize64(off, l *uint256.Int) (uint64, bool) {
 if !l.IsUint64() {
 return 0, true
 }
@@ -35,16 +34,16 @@ func calcMemSize64(off, l *big.Int) (uint64, bool) {
 // calcMemSize64WithUint calculates the required memory size, and returns
 // the size and whether the result overflowed uint64
 // Identical to calcMemSize64, but length is a uint64
-func calcMemSize64WithUint(off *big.Int, length64 uint64) (uint64, bool) {
+func calcMemSize64WithUint(off *uint256.Int, length64 uint64) (uint64, bool) {
 // if length is zero, memsize is always zero, regardless of offset
 if length64 == 0 {
 return 0, false
 }
 // Check that offset doesn't overflow
- if !off.IsUint64() {
+ offset64, overflow := off.Uint64WithOverflow()
+ if overflow {
 return 0, true
 }
- offset64 := off.Uint64()
 val := offset64 + length64
 // if value < either of it's parts, then it overflowed
 return val, val < offset64
@@ -64,22 +63,6 @@ func getData(data []byte, start uint64, size uint64) []byte {
 return common.RightPadBytes(data[start:end], int(size))
 }
 
-// getDataBig returns a slice from the data based on the start and size and pads
-// up to size with zero's. This function is overflow safe.
-func getDataBig(data []byte, start *big.Int, size *big.Int) []byte {
- dlen := big.NewInt(int64(len(data)))
-
- s := math.BigMin(start, dlen)
- e := math.BigMin(new(big.Int).Add(s, size), dlen)
- return common.RightPadBytes(data[s.Uint64():e.Uint64()], int(size.Uint64()))
-}
-
-// bigUint64 returns the integer casted to a uint64 and returns whether it
-// overflowed in the process.
-func bigUint64(v *big.Int) (uint64, bool) {
- return v.Uint64(), !v.IsUint64()
-}
-
 // toWordSize returns the ceiled word size required for memory expansion.
 func toWordSize(size uint64) uint64 {
 if size > math.MaxUint64-31 {
diff --git a/core/vm/contract.go b/core/vm/contract.go
index ed17402..915193d 100644
--- a/core/vm/contract.go
+++ b/core/vm/contract.go
@@ -19,7 +19,8 @@ package vm
 import (
 "math/big"
 
- "github.com/ava-labs/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/holiman/uint256"
 )
 
 // ContractRef is a reference to the contract's backing object
@@ -81,18 +82,43 @@ func NewContract(caller ContractRef, object ContractRef, value *big.Int, gas uin
 return c
 }
 
-func (c *Contract) validJumpdest(dest *big.Int) bool {
- udest := dest.Uint64()
+func (c *Contract) validJumpdest(dest *uint256.Int) bool {
+ udest, overflow := dest.Uint64WithOverflow()
 // PC cannot go beyond len(code) and certainly can't be bigger than 63bits.
 // Don't bother checking for JUMPDEST in that case.
- if dest.BitLen() >= 63 || udest >= uint64(len(c.Code)) {
+ if overflow || udest >= uint64(len(c.Code)) {
 return false
 }
 // Only JUMPDESTs allowed for destinations
 if OpCode(c.Code[udest]) != JUMPDEST {
 return false
 }
+ return c.isCode(udest)
+}
+
+func (c *Contract) validJumpSubdest(udest uint64) bool {
+ // PC cannot go beyond len(code) and certainly can't be bigger than 63 bits.
+ // Don't bother checking for BEGINSUB in that case.
+ if int64(udest) < 0 || udest >= uint64(len(c.Code)) {
+ return false
+ }
+ // Only BEGINSUBs allowed for destinations
+ if OpCode(c.Code[udest]) != BEGINSUB {
+ return false
+ }
+ return c.isCode(udest)
+}
+
+// isCode returns true if the provided PC location is an actual opcode, as
+// opposed to a data-segment following a PUSHN operation.
+func (c *Contract) isCode(udest uint64) bool {
+ // Do we already have an analysis laying around?
+ if c.analysis != nil {
+ return c.analysis.codeSegment(udest)
+ }
 // Do we have a contract hash already?
+ // If we do have a hash, that means it's a 'regular' contract. For regular
+ // contracts ( not temporary initcode), we store the analysis in a map
 if c.CodeHash != (common.Hash{}) {
 // Does parent context have the analysis?
 analysis, exist := c.jumpdests[c.CodeHash]
@@ -102,6 +128,8 @@ func (c *Contract) validJumpdest(dest *big.Int) bool {
 analysis = codeBitmap(c.Code)
 c.jumpdests[c.CodeHash] = analysis
 }
+ // Also stash it in current contract for faster access
+ c.analysis = analysis
 return analysis.codeSegment(udest)
 }
 // We don't have the code hash, most likely a piece of initcode not already
diff --git a/core/vm/contracts.go b/core/vm/contracts.go
index 54eab4e..9827bac 100644
--- a/core/vm/contracts.go
+++ b/core/vm/contracts.go
@@ -23,11 +23,14 @@ import (
 "math/big"
 
 "github.com/ava-labs/coreth/params"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/math"
- "github.com/ava-labs/go-ethereum/crypto"
- "github.com/ava-labs/go-ethereum/crypto/blake2b"
- "github.com/ava-labs/go-ethereum/crypto/bn256"
+ "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/blake2b"
+ "github.com/ethereum/go-ethereum/crypto/bls12381"
+ "github.com/ethereum/go-ethereum/crypto/bn256"
+
+ //lint:ignore SA1019 Needed for precompile
 "golang.org/x/crypto/ripemd160"
 )
 
@@ -75,13 +78,42 @@ var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract{
 common.BytesToAddress([]byte{9}): &blake2F{},
 }
 
+// PrecompiledContractsYoloV1 contains the default set of pre-compiled Ethereum
+// contracts used in the Yolo v1 test release.
+var PrecompiledContractsYoloV1 = 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}): &bn256AddIstanbul{},
+ common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{},
+ common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{},
+ common.BytesToAddress([]byte{9}): &blake2F{},
+ common.BytesToAddress([]byte{10}): &bls12381G1Add{},
+ common.BytesToAddress([]byte{11}): &bls12381G1Mul{},
+ common.BytesToAddress([]byte{12}): &bls12381G1MultiExp{},
+ common.BytesToAddress([]byte{13}): &bls12381G2Add{},
+ common.BytesToAddress([]byte{14}): &bls12381G2Mul{},
+ common.BytesToAddress([]byte{15}): &bls12381G2MultiExp{},
+ common.BytesToAddress([]byte{16}): &bls12381Pairing{},
+ common.BytesToAddress([]byte{17}): &bls12381MapG1{},
+ common.BytesToAddress([]byte{18}): &bls12381MapG2{},
+}
+
 // RunPrecompiledContract runs and evaluates the output of a precompiled contract.
-func RunPrecompiledContract(p PrecompiledContract, input []byte, contract *Contract) (ret []byte, err error) {
- gas := p.RequiredGas(input)
- if contract.UseGas(gas) {
- return p.Run(input)
+// It returns
+// - the returned bytes,
+// - the _remaining_ gas,
+// - any error that occurred
+func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error) {
+ gasCost := p.RequiredGas(input)
+ if suppliedGas < gasCost {
+ return nil, 0, ErrOutOfGas
 }
- return nil, ErrOutOfGas
+ suppliedGas -= gasCost
+ output, err := p.Run(input)
+ return output, suppliedGas, err
 }
 
 // ECRECOVER implemented as a native contract.
@@ -106,8 +138,13 @@ func (c *ecrecover) Run(input []byte) ([]byte, error) {
 if !allZero(input[32:63]) || !crypto.ValidateSignatureValues(v, r, s, false) {
 return nil, nil
 }
+ // We must make sure not to modify the 'input', so placing the 'v' along with
+ // the signature needs to be done on a new allocation
+ sig := make([]byte, 65)
+ copy(sig, input[64:128])
+ sig[64] = v
 // v needs to be at the end for libsecp256k1
- pubKey, err := crypto.Ecrecover(input[:32], append(input[64:128], v))
+ pubKey, err := crypto.Ecrecover(input[:32], sig)
 // make sure the public key is a valid one
 if err != nil {
 return nil, nil
@@ -166,6 +203,7 @@ func (c *dataCopy) Run(in []byte) ([]byte, error) {
 type bigModExp struct{}
 
 var (
+ big0 = big.NewInt(0)
 big1 = big.NewInt(1)
 big4 = big.NewInt(4)
 big8 = big.NewInt(8)
@@ -458,7 +496,7 @@ var (
 )
 
 func (c *blake2F) Run(input []byte) ([]byte, error) {
- // Make sure the input is valid (correct lenth and final flag)
+ // Make sure the input is valid (correct length and final flag)
 if len(input) != blake2FInputLength {
 return nil, errBlake2FInvalidInputLength
 }
@@ -495,3 +533,428 @@ func (c *blake2F) Run(input []byte) ([]byte, error) {
 }
 return output, nil
 }
+
+var (
+ errBLS12381InvalidInputLength = errors.New("invalid input length")
+ errBLS12381InvalidFieldElementTopBytes = errors.New("invalid field element top bytes")
+ errBLS12381G1PointSubgroup = errors.New("g1 point is not on correct subgroup")
+ errBLS12381G2PointSubgroup = errors.New("g2 point is not on correct subgroup")
+)
+
+// bls12381G1Add implements EIP-2537 G1Add precompile.
+type bls12381G1Add struct{}
+
+// RequiredGas returns the gas required to execute the pre-compiled contract.
+func (c *bls12381G1Add) RequiredGas(input []byte) uint64 {
+ return params.Bls12381G1AddGas
+}
+
+func (c *bls12381G1Add) Run(input []byte) ([]byte, error) {
+ // Implements EIP-2537 G1Add precompile.
+ // > G1 addition call expects `256` bytes as an input that is interpreted as byte concatenation of two G1 points (`128` bytes each).
+ // > Output is an encoding of addition operation result - single G1 point (`128` bytes).
+ if len(input) != 256 {
+ return nil, errBLS12381InvalidInputLength
+ }
+ var err error
+ var p0, p1 *bls12381.PointG1
+
+ // Initialize G1
+ g := bls12381.NewG1()
+
+ // Decode G1 point p_0
+ if p0, err = g.DecodePoint(input[:128]); err != nil {
+ return nil, err
+ }
+ // Decode G1 point p_1
+ if p1, err = g.DecodePoint(input[128:]); err != nil {
+ return nil, err
+ }
+
+ // Compute r = p_0 + p_1
+ r := g.New()
+ g.Add(r, p0, p1)
+
+ // Encode the G1 point result into 128 bytes
+ return g.EncodePoint(r), nil
+}
+
+// bls12381G1Mul implements EIP-2537 G1Mul precompile.
+type bls12381G1Mul struct{}
+
+// RequiredGas returns the gas required to execute the pre-compiled contract.
+func (c *bls12381G1Mul) RequiredGas(input []byte) uint64 {
+ return params.Bls12381G1MulGas
+}
+
+func (c *bls12381G1Mul) Run(input []byte) ([]byte, error) {
+ // Implements EIP-2537 G1Mul precompile.
+ // > G1 multiplication call expects `160` bytes as an input that is interpreted as byte concatenation of encoding of G1 point (`128` bytes) and encoding of a scalar value (`32` bytes).
+ // > Output is an encoding of multiplication operation result - single G1 point (`128` bytes).
+ if len(input) != 160 {
+ return nil, errBLS12381InvalidInputLength
+ }
+ var err error
+ var p0 *bls12381.PointG1
+
+ // Initialize G1
+ g := bls12381.NewG1()
+
+ // Decode G1 point
+ if p0, err = g.DecodePoint(input[:128]); err != nil {
+ return nil, err
+ }
+ // Decode scalar value
+ e := new(big.Int).SetBytes(input[128:])
+
+ // Compute r = e * p_0
+ r := g.New()
+ g.MulScalar(r, p0, e)
+
+ // Encode the G1 point into 128 bytes
+ return g.EncodePoint(r), nil
+}
+
+// bls12381G1MultiExp implements EIP-2537 G1MultiExp precompile.
+type bls12381G1MultiExp struct{}
+
+// RequiredGas returns the gas required to execute the pre-compiled contract.
+func (c *bls12381G1MultiExp) RequiredGas(input []byte) uint64 {
+ // Calculate G1 point, scalar value pair length
+ k := len(input) / 160
+ if k == 0 {
+ // Return 0 gas for small input length
+ return 0
+ }
+ // Lookup discount value for G1 point, scalar value pair length
+ var discount uint64
+ if dLen := len(params.Bls12381MultiExpDiscountTable); k < dLen {
+ discount = params.Bls12381MultiExpDiscountTable[k-1]
+ } else {
+ discount = params.Bls12381MultiExpDiscountTable[dLen-1]
+ }
+ // Calculate gas and return the result
+ return (uint64(k) * params.Bls12381G1MulGas * discount) / 1000
+}
+
+func (c *bls12381G1MultiExp) Run(input []byte) ([]byte, error) {
+ // Implements EIP-2537 G1MultiExp precompile.
+ // G1 multiplication call expects `160*k` bytes as an input that is interpreted as byte concatenation of `k` slices each of them being a byte concatenation of encoding of G1 point (`128` bytes) and encoding of a scalar value (`32` bytes).
+ // Output is an encoding of multiexponentiation operation result - single G1 point (`128` bytes).
+ k := len(input) / 160
+ if len(input) == 0 || len(input)%160 != 0 {
+ return nil, errBLS12381InvalidInputLength
+ }
+ var err error
+ points := make([]*bls12381.PointG1, k)
+ scalars := make([]*big.Int, k)
+
+ // Initialize G1
+ g := bls12381.NewG1()
+
+ // Decode point scalar pairs
+ for i := 0; i < k; i++ {
+ off := 160 * i
+ t0, t1, t2 := off, off+128, off+160
+ // Decode G1 point
+ if points[i], err = g.DecodePoint(input[t0:t1]); err != nil {
+ return nil, err
+ }
+ // Decode scalar value
+ scalars[i] = new(big.Int).SetBytes(input[t1:t2])
+ }
+
+ // Compute r = e_0 * p_0 + e_1 * p_1 + ... + e_(k-1) * p_(k-1)
+ r := g.New()
+ g.MultiExp(r, points, scalars)
+
+ // Encode the G1 point to 128 bytes
+ return g.EncodePoint(r), nil
+}
+
+// bls12381G2Add implements EIP-2537 G2Add precompile.
+type bls12381G2Add struct{}
+
+// RequiredGas returns the gas required to execute the pre-compiled contract.
+func (c *bls12381G2Add) RequiredGas(input []byte) uint64 {
+ return params.Bls12381G2AddGas
+}
+
+func (c *bls12381G2Add) Run(input []byte) ([]byte, error) {
+ // Implements EIP-2537 G2Add precompile.
+ // > G2 addition call expects `512` bytes as an input that is interpreted as byte concatenation of two G2 points (`256` bytes each).
+ // > Output is an encoding of addition operation result - single G2 point (`256` bytes).
+ if len(input) != 512 {
+ return nil, errBLS12381InvalidInputLength
+ }
+ var err error
+ var p0, p1 *bls12381.PointG2
+
+ // Initialize G2
+ g := bls12381.NewG2()
+ r := g.New()
+
+ // Decode G2 point p_0
+ if p0, err = g.DecodePoint(input[:256]); err != nil {
+ return nil, err
+ }
+ // Decode G2 point p_1
+ if p1, err = g.DecodePoint(input[256:]); err != nil {
+ return nil, err
+ }
+
+ // Compute r = p_0 + p_1
+ g.Add(r, p0, p1)
+
+ // Encode the G2 point into 256 bytes
+ return g.EncodePoint(r), nil
+}
+
+// bls12381G2Mul implements EIP-2537 G2Mul precompile.
+type bls12381G2Mul struct{}
+
+// RequiredGas returns the gas required to execute the pre-compiled contract.
+func (c *bls12381G2Mul) RequiredGas(input []byte) uint64 {
+ return params.Bls12381G2MulGas
+}
+
+func (c *bls12381G2Mul) Run(input []byte) ([]byte, error) {
+ // Implements EIP-2537 G2MUL precompile logic.
+ // > G2 multiplication call expects `288` bytes as an input that is interpreted as byte concatenation of encoding of G2 point (`256` bytes) and encoding of a scalar value (`32` bytes).
+ // > Output is an encoding of multiplication operation result - single G2 point (`256` bytes).
+ if len(input) != 288 {
+ return nil, errBLS12381InvalidInputLength
+ }
+ var err error
+ var p0 *bls12381.PointG2
+
+ // Initialize G2
+ g := bls12381.NewG2()
+
+ // Decode G2 point
+ if p0, err = g.DecodePoint(input[:256]); err != nil {
+ return nil, err
+ }
+ // Decode scalar value
+ e := new(big.Int).SetBytes(input[256:])
+
+ // Compute r = e * p_0
+ r := g.New()
+ g.MulScalar(r, p0, e)
+
+ // Encode the G2 point into 256 bytes
+ return g.EncodePoint(r), nil
+}
+
+// bls12381G2MultiExp implements EIP-2537 G2MultiExp precompile.
+type bls12381G2MultiExp struct{}
+
+// RequiredGas returns the gas required to execute the pre-compiled contract.
+func (c *bls12381G2MultiExp) RequiredGas(input []byte) uint64 {
+ // Calculate G2 point, scalar value pair length
+ k := len(input) / 288
+ if k == 0 {
+ // Return 0 gas for small input length
+ return 0
+ }
+ // Lookup discount value for G2 point, scalar value pair length
+ var discount uint64
+ if dLen := len(params.Bls12381MultiExpDiscountTable); k < dLen {
+ discount = params.Bls12381MultiExpDiscountTable[k-1]
+ } else {
+ discount = params.Bls12381MultiExpDiscountTable[dLen-1]
+ }
+ // Calculate gas and return the result
+ return (uint64(k) * params.Bls12381G2MulGas * discount) / 1000
+}
+
+func (c *bls12381G2MultiExp) Run(input []byte) ([]byte, error) {
+ // Implements EIP-2537 G2MultiExp precompile logic
+ // > G2 multiplication call expects `288*k` bytes as an input that is interpreted as byte concatenation of `k` slices each of them being a byte concatenation of encoding of G2 point (`256` bytes) and encoding of a scalar value (`32` bytes).
+ // > Output is an encoding of multiexponentiation operation result - single G2 point (`256` bytes).
+ k := len(input) / 288
+ if len(input) == 0 || len(input)%288 != 0 {
+ return nil, errBLS12381InvalidInputLength
+ }
+ var err error
+ points := make([]*bls12381.PointG2, k)
+ scalars := make([]*big.Int, k)
+
+ // Initialize G2
+ g := bls12381.NewG2()
+
+ // Decode point scalar pairs
+ for i := 0; i < k; i++ {
+ off := 288 * i
+ t0, t1, t2 := off, off+256, off+288
+ // Decode G1 point
+ if points[i], err = g.DecodePoint(input[t0:t1]); err != nil {
+ return nil, err
+ }
+ // Decode scalar value
+ scalars[i] = new(big.Int).SetBytes(input[t1:t2])
+ }
+
+ // Compute r = e_0 * p_0 + e_1 * p_1 + ... + e_(k-1) * p_(k-1)
+ r := g.New()
+ g.MultiExp(r, points, scalars)
+
+ // Encode the G2 point to 256 bytes.
+ return g.EncodePoint(r), nil
+}
+
+// bls12381Pairing implements EIP-2537 Pairing precompile.
+type bls12381Pairing struct{}
+
+// RequiredGas returns the gas required to execute the pre-compiled contract.
+func (c *bls12381Pairing) RequiredGas(input []byte) uint64 {
+ return params.Bls12381PairingBaseGas + uint64(len(input)/384)*params.Bls12381PairingPerPairGas
+}
+
+func (c *bls12381Pairing) Run(input []byte) ([]byte, error) {
+ // Implements EIP-2537 Pairing precompile logic.
+ // > Pairing call expects `384*k` bytes as an inputs that is interpreted as byte concatenation of `k` slices. Each slice has the following structure:
+ // > - `128` bytes of G1 point encoding
+ // > - `256` bytes of G2 point encoding
+ // > Output is a `32` bytes where last single byte is `0x01` if pairing result is equal to multiplicative identity in a pairing target field and `0x00` otherwise
+ // > (which is equivalent of Big Endian encoding of Solidity values `uint256(1)` and `uin256(0)` respectively).
+ k := len(input) / 384
+ if len(input) == 0 || len(input)%384 != 0 {
+ return nil, errBLS12381InvalidInputLength
+ }
+
+ // Initialize BLS12-381 pairing engine
+ e := bls12381.NewPairingEngine()
+ g1, g2 := e.G1, e.G2
+
+ // Decode pairs
+ for i := 0; i < k; i++ {
+ off := 384 * i
+ t0, t1, t2 := off, off+128, off+384
+
+ // Decode G1 point
+ p1, err := g1.DecodePoint(input[t0:t1])
+ if err != nil {
+ return nil, err
+ }
+ // Decode G2 point
+ p2, err := g2.DecodePoint(input[t1:t2])
+ if err != nil {
+ return nil, err
+ }
+
+ // 'point is on curve' check already done,
+ // Here we need to apply subgroup checks.
+ if !g1.InCorrectSubgroup(p1) {
+ return nil, errBLS12381G1PointSubgroup
+ }
+ if !g2.InCorrectSubgroup(p2) {
+ return nil, errBLS12381G2PointSubgroup
+ }
+
+ // Update pairing engine with G1 and G2 ponits
+ e.AddPair(p1, p2)
+ }
+ // Prepare 32 byte output
+ out := make([]byte, 32)
+
+ // Compute pairing and set the result
+ if e.Check() {
+ out[31] = 1
+ }
+ return out, nil
+}
+
+// decodeBLS12381FieldElement decodes BLS12-381 elliptic curve field element.
+// Removes top 16 bytes of 64 byte input.
+func decodeBLS12381FieldElement(in []byte) ([]byte, error) {
+ if len(in) != 64 {
+ return nil, errors.New("invalid field element length")
+ }
+ // check top bytes
+ for i := 0; i < 16; i++ {
+ if in[i] != byte(0x00) {
+ return nil, errBLS12381InvalidFieldElementTopBytes
+ }
+ }
+ out := make([]byte, 48)
+ copy(out[:], in[16:])
+ return out, nil
+}
+
+// bls12381MapG1 implements EIP-2537 MapG1 precompile.
+type bls12381MapG1 struct{}
+
+// RequiredGas returns the gas required to execute the pre-compiled contract.
+func (c *bls12381MapG1) RequiredGas(input []byte) uint64 {
+ return params.Bls12381MapG1Gas
+}
+
+func (c *bls12381MapG1) Run(input []byte) ([]byte, error) {
+ // Implements EIP-2537 Map_To_G1 precompile.
+ // > Field-to-curve call expects `64` bytes an an input that is interpreted as a an element of the base field.
+ // > Output of this call is `128` bytes and is G1 point following respective encoding rules.
+ if len(input) != 64 {
+ return nil, errBLS12381InvalidInputLength
+ }
+
+ // Decode input field element
+ fe, err := decodeBLS12381FieldElement(input)
+ if err != nil {
+ return nil, err
+ }
+
+ // Initialize G1
+ g := bls12381.NewG1()
+
+ // Compute mapping
+ r, err := g.MapToCurve(fe)
+ if err != nil {
+ return nil, err
+ }
+
+ // Encode the G1 point to 128 bytes
+ return g.EncodePoint(r), nil
+}
+
+// bls12381MapG2 implements EIP-2537 MapG2 precompile.
+type bls12381MapG2 struct{}
+
+// RequiredGas returns the gas required to execute the pre-compiled contract.
+func (c *bls12381MapG2) RequiredGas(input []byte) uint64 {
+ return params.Bls12381MapG2Gas
+}
+
+func (c *bls12381MapG2) Run(input []byte) ([]byte, error) {
+ // Implements EIP-2537 Map_FP2_TO_G2 precompile logic.
+ // > Field-to-curve call expects `128` bytes an an input that is interpreted as a an element of the quadratic extension field.
+ // > Output of this call is `256` bytes and is G2 point following respective encoding rules.
+ if len(input) != 128 {
+ return nil, errBLS12381InvalidInputLength
+ }
+
+ // Decode input field element
+ fe := make([]byte, 96)
+ c0, err := decodeBLS12381FieldElement(input[:64])
+ if err != nil {
+ return nil, err
+ }
+ copy(fe[48:], c0)
+ c1, err := decodeBLS12381FieldElement(input[64:])
+ if err != nil {
+ return nil, err
+ }
+ copy(fe[:48], c1)
+
+ // Initialize G2
+ g := bls12381.NewG2()
+
+ // Compute mapping
+ r, err := g.MapToCurve(fe)
+ if err != nil {
+ return nil, err
+ }
+
+ // Encode the G2 point to 256 bytes
+ return g.EncodePoint(r), nil
+}
diff --git a/core/vm/eips.go b/core/vm/eips.go
index 75e5fb1..5ec7587 100644
--- a/core/vm/eips.go
+++ b/core/vm/eips.go
@@ -18,27 +18,44 @@ package vm
 
 import (
 "fmt"
+ "sort"
 
 "github.com/ava-labs/coreth/params"
+ "github.com/holiman/uint256"
 )
 
+var activators = map[int]func(*JumpTable){
+ 2200: enable2200,
+ 1884: enable1884,
+ 1344: enable1344,
+ 2315: enable2315,
+}
+
 // EnableEIP enables the given EIP on the config.
 // This operation writes in-place, and callers need to ensure that the globally
 // defined jump tables are not polluted.
 func EnableEIP(eipNum int, jt *JumpTable) error {
- switch eipNum {
- case 2200:
- enable2200(jt)
- case 1884:
- enable1884(jt)
- case 1344:
- enable1344(jt)
- default:
+ enablerFn, ok := activators[eipNum]
+ if !ok {
 return fmt.Errorf("undefined eip %d", eipNum)
 }
+ enablerFn(jt)
 return nil
 }
 
+func ValidEip(eipNum int) bool {
+ _, ok := activators[eipNum]
+ return ok
+}
+func ActivateableEips() []string {
+ var nums []string
+ for k := range activators {
+ nums = append(nums, fmt.Sprintf("%d", k))
+ }
+ sort.Strings(nums)
+ return nums
+}
+
 // enable1884 applies EIP-1884 to the given jump table:
 // - Increase cost of BALANCE to 700
 // - Increase cost of EXTCODEHASH to 700
@@ -46,23 +63,22 @@ func EnableEIP(eipNum int, jt *JumpTable) error {
 // - Define SELFBALANCE, with cost GasFastStep (5)
 func enable1884(jt *JumpTable) {
 // Gas cost changes
+ jt[SLOAD].constantGas = params.SloadGasEIP1884
 jt[BALANCE].constantGas = params.BalanceGasEIP1884
 jt[EXTCODEHASH].constantGas = params.ExtcodeHashGasEIP1884
- jt[SLOAD].constantGas = params.SloadGasEIP1884
 
 // New opcode
- jt[SELFBALANCE] = operation{
+ jt[SELFBALANCE] = &operation{
 execute: opSelfBalance,
 constantGas: GasFastStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 }
 }
 
-func opSelfBalance(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- balance := interpreter.intPool.get().Set(interpreter.evm.StateDB.GetBalance(contract.Address()))
- stack.push(balance)
+func opSelfBalance(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ balance, _ := uint256.FromBig(interpreter.evm.StateDB.GetBalance(callContext.contract.Address()))
+ callContext.stack.push(balance)
 return nil, nil
 }
 
@@ -70,23 +86,51 @@ func opSelfBalance(pc *uint64, interpreter *EVMInterpreter, contract *Contract,
 // - Adds an opcode that returns the current chain’s EIP-155 unique identifier
 func enable1344(jt *JumpTable) {
 // New opcode
- jt[CHAINID] = operation{
+ jt[CHAINID] = &operation{
 execute: opChainID,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 }
 }
 
 // opChainID implements CHAINID opcode
-func opChainID(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- chainId := interpreter.intPool.get().Set(interpreter.evm.chainConfig.ChainID)
- stack.push(chainId)
+func opChainID(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ chainId, _ := uint256.FromBig(interpreter.evm.chainConfig.ChainID)
+ callContext.stack.push(chainId)
 return nil, nil
 }
 
 // enable2200 applies EIP-2200 (Rebalance net-metered SSTORE)
 func enable2200(jt *JumpTable) {
+ jt[SLOAD].constantGas = params.SloadGasEIP2200
 jt[SSTORE].dynamicGas = gasSStoreEIP2200
 }
+
+// enable2315 applies EIP-2315 (Simple Subroutines)
+// - Adds opcodes that jump to and return from subroutines
+func enable2315(jt *JumpTable) {
+ // New opcode
+ jt[BEGINSUB] = &operation{
+ execute: opBeginSub,
+ constantGas: GasQuickStep,
+ minStack: minStack(0, 0),
+ maxStack: maxStack(0, 0),
+ }
+ // New opcode
+ jt[JUMPSUB] = &operation{
+ execute: opJumpSub,
+ constantGas: GasSlowStep,
+ minStack: minStack(1, 0),
+ maxStack: maxStack(1, 0),
+ jumps: true,
+ }
+ // New opcode
+ jt[RETURNSUB] = &operation{
+ execute: opReturnSub,
+ constantGas: GasFastStep,
+ minStack: minStack(0, 0),
+ maxStack: maxStack(0, 0),
+ jumps: true,
+ }
+}
diff --git a/core/vm/errors.go b/core/vm/errors.go
index 94f0ed8..9f3f335 100644
--- a/core/vm/errors.go
+++ b/core/vm/errors.go
@@ -16,16 +16,57 @@
 
 package vm
 
-import "errors"
+import (
+ "errors"
+ "fmt"
+)
 
-// List execution errors
+// List evm execution errors
 var (
+ // ErrInvalidSubroutineEntry means that a BEGINSUB was reached via iteration,
+ // as opposed to from a JUMPSUB instruction
+ ErrInvalidSubroutineEntry = errors.New("invalid subroutine entry")
 ErrOutOfGas = errors.New("out of gas")
 ErrCodeStoreOutOfGas = errors.New("contract creation code storage out of gas")
 ErrDepth = errors.New("max call depth exceeded")
- ErrTraceLimitReached = errors.New("the number of logs reached the specified limit")
 ErrInsufficientBalance = errors.New("insufficient balance for transfer")
 ErrIncompatibleAccount = errors.New("incompatible account")
 ErrContractAddressCollision = errors.New("contract address collision")
- ErrNoCompatibleInterpreter = errors.New("no compatible interpreter")
+ ErrExecutionReverted = errors.New("execution reverted")
+ ErrMaxCodeSizeExceeded = errors.New("max code size exceeded")
+ ErrInvalidJump = errors.New("invalid jump destination")
+ ErrWriteProtection = errors.New("write protection")
+ ErrReturnDataOutOfBounds = errors.New("return data out of bounds")
+ ErrGasUintOverflow = errors.New("gas uint64 overflow")
+ ErrInvalidRetsub = errors.New("invalid retsub")
+ ErrReturnStackExceeded = errors.New("return stack limit reached")
 )
+
+// ErrStackUnderflow wraps an evm error when the items on the stack less
+// than the minimal requirement.
+type ErrStackUnderflow struct {
+ stackLen int
+ required int
+}
+
+func (e *ErrStackUnderflow) Error() string {
+ return fmt.Sprintf("stack underflow (%d <=> %d)", e.stackLen, e.required)
+}
+
+// ErrStackOverflow wraps an evm error when the items on the stack exceeds
+// the maximum allowance.
+type ErrStackOverflow struct {
+ stackLen int
+ limit int
+}
+
+func (e *ErrStackOverflow) Error() string {
+ return fmt.Sprintf("stack limit reached %d (%d)", e.stackLen, e.limit)
+}
+
+// ErrInvalidOpCode wraps an evm error when an invalid opcode is encountered.
+type ErrInvalidOpCode struct {
+ opcode OpCode
+}
+
+func (e *ErrInvalidOpCode) Error() string { return fmt.Sprintf("invalid opcode: %s", e.opcode) }
diff --git a/core/vm/evm.go b/core/vm/evm.go
index be8b240..e895211 100644
--- a/core/vm/evm.go
+++ b/core/vm/evm.go
@@ -17,13 +17,15 @@
 package vm
 
 import (
+ "errors"
 "math/big"
 "sync/atomic"
 "time"
 
 "github.com/ava-labs/coreth/params"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/holiman/uint256"
 )
 
 // emptyCodeHash is used by create to ensure deployment is disallowed to already
@@ -42,20 +44,24 @@ type (
 GetHashFunc func(uint64) common.Hash
 )
 
+func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) {
+ var precompiles map[common.Address]PrecompiledContract
+ switch {
+ case evm.chainRules.IsYoloV1:
+ precompiles = PrecompiledContractsYoloV1
+ case evm.chainRules.IsIstanbul:
+ precompiles = PrecompiledContractsIstanbul
+ case evm.chainRules.IsByzantium:
+ precompiles = PrecompiledContractsByzantium
+ default:
+ precompiles = PrecompiledContractsHomestead
+ }
+ p, ok := precompiles[addr]
+ return p, ok
+}
+
 // run runs the given contract and takes care of running precompiles with a fallback to the byte code interpreter.
 func run(evm *EVM, contract *Contract, input []byte, readOnly bool) ([]byte, error) {
- if contract.CodeAddr != nil {
- precompiles := PrecompiledContractsHomestead
- if evm.chainRules.IsByzantium {
- precompiles = PrecompiledContractsByzantium
- }
- if evm.chainRules.IsIstanbul {
- precompiles = PrecompiledContractsIstanbul
- }
- if p := precompiles[*contract.CodeAddr]; p != nil {
- return RunPrecompiledContract(p, input, contract)
- }
- }
 for _, interpreter := range evm.interpreters {
 if interpreter.CanRun(contract.Code) {
 if evm.interpreter != interpreter {
@@ -69,7 +75,7 @@ func run(evm *EVM, contract *Contract, input []byte, readOnly bool) ([]byte, err
 return interpreter.Run(contract, input, readOnly)
 }
 }
- return nil, ErrNoCompatibleInterpreter
+ return nil, errors.New("no compatible interpreter")
 }
 
 // Context provides the EVM with auxiliary information. Once provided
@@ -194,29 +200,19 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 if evm.vmConfig.NoRecursion && evm.depth > 0 {
 return nil, gas, nil
 }
-
 // Fail if we're trying to execute above the call depth limit
 if evm.depth > int(params.CallCreateDepth) {
 return nil, gas, ErrDepth
 }
 // Fail if we're trying to transfer more than the available balance
- if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
+ if value.Sign() != 0 && !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
 return nil, gas, ErrInsufficientBalance
 }
+ snapshot := evm.StateDB.Snapshot()
+ p, isPrecompile := evm.precompile(addr)
 
- var (
- to = AccountRef(addr)
- snapshot = evm.StateDB.Snapshot()
- )
 if !evm.StateDB.Exist(addr) {
- precompiles := PrecompiledContractsHomestead
- if evm.chainRules.IsByzantium {
- precompiles = PrecompiledContractsByzantium
- }
- if evm.chainRules.IsIstanbul {
- precompiles = PrecompiledContractsIstanbul
- }
- if precompiles[addr] == nil && evm.chainRules.IsEIP158 && value.Sign() == 0 {
+ if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 {
 // Calling a non existing account, don't do anything, but ping the tracer
 if evm.vmConfig.Debug && evm.depth == 0 {
 evm.vmConfig.Tracer.CaptureStart(caller.Address(), addr, false, input, gas, value)
@@ -226,35 +222,47 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 }
 evm.StateDB.CreateAccount(addr)
 }
- evm.Transfer(evm.StateDB, caller.Address(), to.Address(), value)
- // Initialise a new contract and set the code that is to be used by the EVM.
- // The contract is a scoped environment for this execution context only.
- contract := NewContract(caller, to, value, gas)
- contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
-
- // Even if the account has no code, we need to continue because it might be a precompile
- start := time.Now()
+ evm.Transfer(evm.StateDB, caller.Address(), addr, value)
 
 // Capture the tracer start/end events in debug mode
 if evm.vmConfig.Debug && evm.depth == 0 {
 evm.vmConfig.Tracer.CaptureStart(caller.Address(), addr, false, input, gas, value)
-
- defer func() { // Lazy evaluation of the parameters
- evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
- }()
+ defer func(startGas uint64, startTime time.Time) { // Lazy evaluation of the parameters
+ evm.vmConfig.Tracer.CaptureEnd(ret, startGas-gas, time.Since(startTime), err)
+ }(gas, time.Now())
+ }
+
+ if isPrecompile {
+ ret, gas, err = RunPrecompiledContract(p, input, gas)
+ } else {
+ // Initialise a new contract and set the code that is to be used by the EVM.
+ // The contract is a scoped environment for this execution context only.
+ code := evm.StateDB.GetCode(addr)
+ if len(code) == 0 {
+ ret, err = nil, nil // gas is unchanged
+ } else {
+ addrCopy := addr
+ // If the account has no code, we can abort here
+ // The depth-check is already done, and precompiles handled above
+ contract := NewContract(caller, AccountRef(addrCopy), value, gas)
+ contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), code)
+ ret, err = run(evm, contract, input, false)
+ gas = contract.Gas
+ }
 }
- ret, err = run(evm, contract, input, false)
-
 // 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 {
 evm.StateDB.RevertToSnapshot(snapshot)
- if err != errExecutionReverted {
- contract.UseGas(contract.Gas)
+ if err != ErrExecutionReverted {
+ gas = 0
 }
+ // TODO: consider clearing up unused snapshots:
+ //} else {
+ // evm.StateDB.DiscardSnapshot(snapshot)
 }
- return ret, contract.Gas, err
+ return ret, gas, err
 }
 
 // This allows the user transfer balance of a specified coinId in addition to a normal Call().
@@ -262,13 +270,13 @@ func (evm *EVM) CallExpert(caller ContractRef, addr common.Address, input []byte
 if evm.vmConfig.NoRecursion && evm.depth > 0 {
 return nil, gas, nil
 }
-
 // Fail if we're trying to execute above the call depth limit
 if evm.depth > int(params.CallCreateDepth) {
 return nil, gas, ErrDepth
 }
+
 // Fail if we're trying to transfer more than the available balance
- if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
+ if value.Sign() != 0 && !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
 return nil, gas, ErrInsufficientBalance
 }
 
@@ -280,17 +288,11 @@ func (evm *EVM) CallExpert(caller ContractRef, addr common.Address, input []byte
 return nil, gas, ErrIncompatibleAccount
 }
 
- var snapshot = evm.StateDB.Snapshot()
+ snapshot := evm.StateDB.Snapshot()
+ p, isPrecompile := evm.precompile(addr)
 
 if !evm.StateDB.Exist(addr) {
- precompiles := PrecompiledContractsHomestead
- if evm.chainRules.IsByzantium {
- precompiles = PrecompiledContractsByzantium
- }
- if evm.chainRules.IsIstanbul {
- precompiles = PrecompiledContractsIstanbul
- }
- if precompiles[addr] == nil && evm.chainRules.IsEIP158 && value.Sign() == 0 {
+ if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 {
 // Calling a non existing account, don't do anything, but ping the tracer
 if evm.vmConfig.Debug && evm.depth == 0 {
 evm.vmConfig.Tracer.CaptureStart(caller.Address(), addr, false, input, gas, value)
@@ -300,36 +302,48 @@ func (evm *EVM) CallExpert(caller ContractRef, addr common.Address, input []byte
 }
 evm.StateDB.CreateAccount(addr)
 }
- evm.Transfer(evm.StateDB, caller.Address(), to.Address(), value)
- evm.TransferMultiCoin(evm.StateDB, caller.Address(), to.Address(), coinID, value2)
- // Initialise a new contract and set the code that is to be used by the EVM.
- // The contract is a scoped environment for this execution context only.
- contract := NewContract(caller, to, value, gas)
- contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
-
- // Even if the account has no code, we need to continue because it might be a precompile
- start := time.Now()
+ evm.Transfer(evm.StateDB, caller.Address(), addr, value)
+ evm.TransferMultiCoin(evm.StateDB, caller.Address(), addr, coinID, value2)
 
 // Capture the tracer start/end events in debug mode
 if evm.vmConfig.Debug && evm.depth == 0 {
 evm.vmConfig.Tracer.CaptureStart(caller.Address(), addr, false, input, gas, value)
-
- defer func() { // Lazy evaluation of the parameters
- evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
- }()
+ defer func(startGas uint64, startTime time.Time) { // Lazy evaluation of the parameters
+ evm.vmConfig.Tracer.CaptureEnd(ret, startGas-gas, time.Since(startTime), err)
+ }(gas, time.Now())
+ }
+
+ if isPrecompile {
+ ret, gas, err = RunPrecompiledContract(p, input, gas)
+ } else {
+ // Initialise a new contract and set the code that is to be used by the EVM.
+ // The contract is a scoped environment for this execution context only.
+ code := evm.StateDB.GetCode(addr)
+ if len(code) == 0 {
+ ret, err = nil, nil // gas is unchanged
+ } else {
+ addrCopy := addr
+ // If the account has no code, we can abort here
+ // The depth-check is already done, and precompiles handled above
+ contract := NewContract(caller, AccountRef(addrCopy), value, gas)
+ contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), code)
+ ret, err = run(evm, contract, input, false)
+ gas = contract.Gas
+ }
 }
- ret, err = run(evm, contract, input, false)
-
 // 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 {
 evm.StateDB.RevertToSnapshot(snapshot)
- if err != errExecutionReverted {
- contract.UseGas(contract.Gas)
+ if err != ErrExecutionReverted {
+ gas = 0
 }
+ // TODO: consider clearing up unused snapshots:
+ //} else {
+ // evm.StateDB.DiscardSnapshot(snapshot)
 }
- return ret, contract.Gas, err
+ return ret, gas, err
 }
 
 // CallCode executes the contract associated with the addr with the given input
@@ -343,33 +357,38 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte,
 if evm.vmConfig.NoRecursion && evm.depth > 0 {
 return nil, gas, nil
 }
-
 // Fail if we're trying to execute above the call depth limit
 if evm.depth > int(params.CallCreateDepth) {
 return nil, gas, ErrDepth
 }
 // Fail if we're trying to transfer more than the available balance
- if !evm.CanTransfer(evm.StateDB, caller.Address(), value) {
+ // Note although it's noop to transfer X ether to caller itself. But
+ // if caller doesn't have enough balance, it would be an error to allow
+ // over-charging itself. So the check here is necessary.
+ if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
 return nil, gas, ErrInsufficientBalance
 }
+ var snapshot = evm.StateDB.Snapshot()
 
- var (
- snapshot = evm.StateDB.Snapshot()
- to = AccountRef(caller.Address())
- )
- // Initialise a new contract and set the code that is to be used by the EVM.
- // The contract is a scoped environment for this execution context only.
- contract := NewContract(caller, to, value, gas)
- contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
-
- ret, err = run(evm, contract, input, false)
+ // It is allowed to call precompiles, even via delegatecall
+ if p, isPrecompile := evm.precompile(addr); isPrecompile {
+ ret, gas, err = RunPrecompiledContract(p, input, gas)
+ } else {
+ addrCopy := addr
+ // Initialise a new contract and set the code that is to be used by the EVM.
+ // The contract is a scoped environment for this execution context only.
+ contract := NewContract(caller, AccountRef(caller.Address()), value, gas)
+ contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))
+ ret, err = run(evm, contract, input, false)
+ gas = contract.Gas
+ }
 if err != nil {
 evm.StateDB.RevertToSnapshot(snapshot)
- if err != errExecutionReverted {
- contract.UseGas(contract.Gas)
+ if err != ErrExecutionReverted {
+ gas = 0
 }
 }
- return ret, contract.Gas, err
+ return ret, gas, err
 }
 
 // DelegateCall executes the contract associated with the addr with the given input
@@ -385,24 +404,26 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by
 if evm.depth > int(params.CallCreateDepth) {
 return nil, gas, ErrDepth
 }
+ var snapshot = evm.StateDB.Snapshot()
 
- var (
- snapshot = evm.StateDB.Snapshot()
- to = AccountRef(caller.Address())
- )
-
- // Initialise a new contract and make initialise the delegate values
- contract := NewContract(caller, to, nil, gas).AsDelegate()
- contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
-
- ret, err = run(evm, contract, input, false)
+ // It is allowed to call precompiles, even via delegatecall
+ if p, isPrecompile := evm.precompile(addr); isPrecompile {
+ ret, gas, err = RunPrecompiledContract(p, input, gas)
+ } else {
+ addrCopy := addr
+ // Initialise a new contract and make initialise the delegate values
+ contract := NewContract(caller, AccountRef(caller.Address()), nil, gas).AsDelegate()
+ contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))
+ ret, err = run(evm, contract, input, false)
+ gas = contract.Gas
+ }
 if err != nil {
 evm.StateDB.RevertToSnapshot(snapshot)
- if err != errExecutionReverted {
- contract.UseGas(contract.Gas)
+ if err != ErrExecutionReverted {
+ gas = 0
 }
 }
- return ret, contract.Gas, err
+ return ret, gas, err
 }
 
 // StaticCall executes the contract associated with the addr with the given input
@@ -417,33 +438,43 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte
 if evm.depth > int(params.CallCreateDepth) {
 return nil, gas, ErrDepth
 }
-
- var (
- to = AccountRef(addr)
- snapshot = evm.StateDB.Snapshot()
- )
- // Initialise a new contract and set the code that is to be used by the EVM.
- // The contract is a scoped environment for this execution context only.
- contract := NewContract(caller, to, new(big.Int), gas)
- contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
+ // We take a snapshot here. This is a bit counter-intuitive, and could probably be skipped.
+ // However, even a staticcall is considered a 'touch'. On mainnet, static calls were introduced
+ // after all empty accounts were deleted, so this is not required. However, if we omit this,
+ // then certain tests start failing; stRevertTest/RevertPrecompiledTouchExactOOG.json.
+ // We could change this, but for now it's left for legacy reasons
+ var snapshot = evm.StateDB.Snapshot()
 
 // We do an AddBalance of zero here, just in order to trigger a touch.
 // This doesn't matter on Mainnet, where all empties are gone at the time of Byzantium,
 // but is the correct thing to do and matters on other networks, in tests, and potential
 // future scenarios
- evm.StateDB.AddBalance(addr, bigZero)
-
- // 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.
- ret, err = run(evm, contract, input, true)
+ evm.StateDB.AddBalance(addr, big0)
+
+ if p, isPrecompile := evm.precompile(addr); isPrecompile {
+ ret, gas, err = RunPrecompiledContract(p, input, gas)
+ } else {
+ // At this point, we use a copy of address. If we don't, the go compiler will
+ // leak the 'contract' to the outer scope, and make allocation for 'contract'
+ // even if the actual execution ends on RunPrecompiled above.
+ addrCopy := addr
+ // Initialise a new contract and set the code that is to be used by the EVM.
+ // The contract is a scoped environment for this execution context only.
+ contract := NewContract(caller, AccountRef(addrCopy), new(big.Int), gas)
+ contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))
+ // 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.
+ ret, err = run(evm, contract, input, true)
+ gas = contract.Gas
+ }
 if err != nil {
 evm.StateDB.RevertToSnapshot(snapshot)
- if err != errExecutionReverted {
- contract.UseGas(contract.Gas)
+ if err != ErrExecutionReverted {
+ gas = 0
 }
 }
- return ret, contract.Gas, err
+ return ret, gas, err
 }
 
 type codeAndHash struct {
@@ -520,13 +551,13 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64,
 // when we're in homestead this also counts for code storage gas errors.
 if maxCodeSizeExceeded || (err != nil && (evm.chainRules.IsHomestead || err != ErrCodeStoreOutOfGas)) {
 evm.StateDB.RevertToSnapshot(snapshot)
- if err != errExecutionReverted {
+ if err != ErrExecutionReverted {
 contract.UseGas(contract.Gas)
 }
 }
 // Assign err if contract code size exceeds the max while the err is still empty.
 if maxCodeSizeExceeded && err == nil {
- err = errMaxCodeSizeExceeded
+ err = ErrMaxCodeSizeExceeded
 }
 if evm.vmConfig.Debug && evm.depth == 0 {
 evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
@@ -545,9 +576,9 @@ func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.I
 //
 // The different between Create2 with Create is Create2 uses sha3(0xff ++ msg.sender ++ salt ++ sha3(init_code))[12:]
 // instead of the usual sender-and-nonce-hash as the address where the contract is initialized at.
-func (evm *EVM) Create2(caller ContractRef, code []byte, gas uint64, endowment *big.Int, salt *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {
+func (evm *EVM) Create2(caller ContractRef, code []byte, gas uint64, endowment *big.Int, salt *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {
 codeAndHash := &codeAndHash{code: code}
- contractAddr = crypto.CreateAddress2(caller.Address(), common.BigToHash(salt), codeAndHash.Hash().Bytes())
+ contractAddr = crypto.CreateAddress2(caller.Address(), common.Hash(salt.Bytes32()), codeAndHash.Hash().Bytes())
 return evm.create(caller, codeAndHash, gas, endowment, contractAddr)
 }
 
diff --git a/core/vm/gas.go b/core/vm/gas.go
index bd8b4f1..5cf1d85 100644
--- a/core/vm/gas.go
+++ b/core/vm/gas.go
@@ -17,7 +17,7 @@
 package vm
 
 import (
- "math/big"
+ "github.com/holiman/uint256"
 )
 
 // Gas costs
@@ -30,23 +30,23 @@ const (
 GasExtStep uint64 = 20
 )
 
-// calcGas returns the actual gas cost of the call.
+// callGas returns the actual gas cost of the call.
 //
 // The cost of gas was changed during the homestead price change HF.
 // As part of EIP 150 (TangerineWhistle), the returned gas is gas - base * 63 / 64.
-func callGas(isEip150 bool, availableGas, base uint64, callCost *big.Int) (uint64, error) {
+func callGas(isEip150 bool, availableGas, base uint64, callCost *uint256.Int) (uint64, error) {
 if isEip150 {
 availableGas = availableGas - base
 gas := availableGas - availableGas/64
 // If the bit length exceeds 64 bit we know that the newly calculated "gas" for EIP150
- // is smaller than the requested amount. Therefor we return the new gas instead
+ // is smaller than the requested amount. Therefore we return the new gas instead
 // of returning an error.
 if !callCost.IsUint64() || gas < callCost.Uint64() {
 return gas, nil
 }
 }
 if !callCost.IsUint64() {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 
 return callCost.Uint64(), nil
diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go
index 2adaf85..0182892 100644
--- a/core/vm/gas_table.go
+++ b/core/vm/gas_table.go
@@ -20,8 +20,8 @@ import (
 "errors"
 
 "github.com/ava-labs/coreth/params"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/math"
 )
 
 // memoryGasCost calculates the quadratic gas for memory expansion. It does so
@@ -36,7 +36,7 @@ func memoryGasCost(mem *Memory, newMemSize uint64) (uint64, error) {
 // overflow. The constant 0x1FFFFFFFE0 is the highest number that can be used
 // without overflowing the gas calculation.
 if newMemSize > 0x1FFFFFFFE0 {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 newMemSizeWords := toWordSize(newMemSize)
 newMemSize = newMemSizeWords * 32
@@ -70,17 +70,17 @@ func memoryCopierGas(stackpos int) gasFunc {
 return 0, err
 }
 // And gas for copying data, charged per word at param.CopyGas
- words, overflow := bigUint64(stack.Back(stackpos))
+ words, overflow := stack.Back(stackpos).Uint64WithOverflow()
 if overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 
 if words, overflow = math.SafeMul(toWordSize(words), params.CopyGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 
 if gas, overflow = math.SafeAdd(gas, words); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 return gas, nil
 }
@@ -96,7 +96,7 @@ var (
 func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
 var (
 y, x = stack.Back(1), stack.Back(0)
- current = evm.StateDB.GetState(contract.Address(), common.BigToHash(x))
+ current = evm.StateDB.GetState(contract.Address(), common.Hash(x.Bytes32()))
 )
 // The legacy gas metering only takes into consideration the current state
 // Legacy rules should be applied if we are in Petersburg (removal of EIP-1283)
@@ -131,11 +131,11 @@ func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySi
 // 2.2.2. If original value equals new value (this storage slot is reset)
 // 2.2.2.1. If original value is 0, add 19800 gas to refund counter.
 // 2.2.2.2. Otherwise, add 4800 gas to refund counter.
- value := common.BigToHash(y)
+ value := common.Hash(y.Bytes32())
 if current == value { // noop (1)
 return params.NetSstoreNoopGas, nil
 }
- original := evm.StateDB.GetCommittedState(contract.Address(), common.BigToHash(x))
+ original := evm.StateDB.GetCommittedState(contract.Address(), common.Hash(x.Bytes32()))
 if original == current {
 if original == (common.Hash{}) { // create slot (2.1.1)
 return params.NetSstoreInitGas, nil
@@ -183,14 +183,14 @@ func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m
 // Gas sentry honoured, do the actual gas calculation based on the stored value
 var (
 y, x = stack.Back(1), stack.Back(0)
- current = evm.StateDB.GetState(contract.Address(), common.BigToHash(x))
+ current = evm.StateDB.GetState(contract.Address(), common.Hash(x.Bytes32()))
 )
- value := common.BigToHash(y)
+ value := common.Hash(y.Bytes32())
 
 if current == value { // noop (1)
 return params.SstoreNoopGasEIP2200, nil
 }
- original := evm.StateDB.GetCommittedState(contract.Address(), common.BigToHash(x))
+ original := evm.StateDB.GetCommittedState(contract.Address(), common.Hash(x.Bytes32()))
 if original == current {
 if original == (common.Hash{}) { // create slot (2.1.1)
 return params.SstoreInitGasEIP2200, nil
@@ -219,9 +219,9 @@ func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m
 
 func makeGasLog(n uint64) gasFunc {
 return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
- requestedSize, overflow := bigUint64(stack.Back(1))
+ requestedSize, overflow := stack.Back(1).Uint64WithOverflow()
 if overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 
 gas, err := memoryGasCost(mem, memorySize)
@@ -230,18 +230,18 @@ func makeGasLog(n uint64) gasFunc {
 }
 
 if gas, overflow = math.SafeAdd(gas, params.LogGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 if gas, overflow = math.SafeAdd(gas, n*params.LogTopicGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 
 var memorySizeGas uint64
 if memorySizeGas, overflow = math.SafeMul(requestedSize, params.LogDataGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 if gas, overflow = math.SafeAdd(gas, memorySizeGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 return gas, nil
 }
@@ -252,15 +252,15 @@ func gasSha3(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize
 if err != nil {
 return 0, err
 }
- wordGas, overflow := bigUint64(stack.Back(1))
+ wordGas, overflow := stack.Back(1).Uint64WithOverflow()
 if overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 if wordGas, overflow = math.SafeMul(toWordSize(wordGas), params.Sha3WordGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 if gas, overflow = math.SafeAdd(gas, wordGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 return gas, nil
 }
@@ -286,15 +286,15 @@ func gasCreate2(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memoryS
 if err != nil {
 return 0, err
 }
- wordGas, overflow := bigUint64(stack.Back(2))
+ wordGas, overflow := stack.Back(2).Uint64WithOverflow()
 if overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 if wordGas, overflow = math.SafeMul(toWordSize(wordGas), params.Sha3WordGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 if gas, overflow = math.SafeAdd(gas, wordGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 return gas, nil
 }
@@ -307,7 +307,7 @@ func gasExpFrontier(evm *EVM, contract *Contract, stack *Stack, mem *Memory, mem
 overflow bool
 )
 if gas, overflow = math.SafeAdd(gas, params.ExpGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 return gas, nil
 }
@@ -320,7 +320,7 @@ func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memor
 overflow bool
 )
 if gas, overflow = math.SafeAdd(gas, params.ExpGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 return gas, nil
 }
@@ -328,8 +328,8 @@ func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memor
 func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
 var (
 gas uint64
- transfersValue = stack.Back(2).Sign() != 0
- address = common.BigToAddress(stack.Back(1))
+ transfersValue = !stack.Back(2).IsZero()
+ address = common.Address(stack.Back(1).Bytes20())
 )
 if evm.chainRules.IsEIP158 {
 if transfersValue && evm.StateDB.Empty(address) {
@@ -347,7 +347,7 @@ func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize
 }
 var overflow bool
 if gas, overflow = math.SafeAdd(gas, memoryGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 
 evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0))
@@ -355,7 +355,7 @@ func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize
 return 0, err
 }
 if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 return gas, nil
 }
@@ -373,14 +373,14 @@ func gasCallCode(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memory
 gas += params.CallValueTransferGas
 }
 if gas, overflow = math.SafeAdd(gas, memoryGas); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0))
 if err != nil {
 return 0, err
 }
 if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 return gas, nil
 }
@@ -396,7 +396,7 @@ func gasDelegateCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me
 }
 var overflow bool
 if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 return gas, nil
 }
@@ -412,7 +412,7 @@ func gasStaticCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memo
 }
 var overflow bool
 if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {
- return 0, errGasUintOverflow
+ return 0, ErrGasUintOverflow
 }
 return gas, nil
 }
@@ -422,7 +422,7 @@ func gasSelfdestruct(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me
 // EIP150 homestead gas reprice fork:
 if evm.chainRules.IsEIP150 {
 gas = params.SelfdestructGasEIP150
- var address = common.BigToAddress(stack.Back(0))
+ var address = common.Address(stack.Back(0).Bytes20())
 
 if evm.chainRules.IsEIP158 {
 // if empty and transfers value
diff --git a/core/vm/gen_structlog.go b/core/vm/gen_structlog.go
index 038841c..ac1a907 100644
--- a/core/vm/gen_structlog.go
+++ b/core/vm/gen_structlog.go
@@ -6,9 +6,9 @@ import (
 "encoding/json"
 "math/big"
 
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/hexutil"
- "github.com/ava-labs/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/common/math"
 )
 
 var _ = (*structLogMarshaling)(nil)
@@ -23,6 +23,8 @@ func (s StructLog) MarshalJSON() ([]byte, error) {
 Memory hexutil.Bytes `json:"memory"`
 MemorySize int `json:"memSize"`
 Stack []*math.HexOrDecimal256 `json:"stack"`
+ ReturnStack []math.HexOrDecimal64 `json:"returnStack"`
+ ReturnData []byte `json:"returnData"`
 Storage map[common.Hash]common.Hash `json:"-"`
 Depth int `json:"depth"`
 RefundCounter uint64 `json:"refund"`
@@ -43,6 +45,13 @@ func (s StructLog) MarshalJSON() ([]byte, error) {
 enc.Stack[k] = (*math.HexOrDecimal256)(v)
 }
 }
+ if s.ReturnStack != nil {
+ enc.ReturnStack = make([]math.HexOrDecimal64, len(s.ReturnStack))
+ for k, v := range s.ReturnStack {
+ enc.ReturnStack[k] = math.HexOrDecimal64(v)
+ }
+ }
+ enc.ReturnData = s.ReturnData
 enc.Storage = s.Storage
 enc.Depth = s.Depth
 enc.RefundCounter = s.RefundCounter
@@ -62,6 +71,8 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 Memory *hexutil.Bytes `json:"memory"`
 MemorySize *int `json:"memSize"`
 Stack []*math.HexOrDecimal256 `json:"stack"`
+ ReturnStack []math.HexOrDecimal64 `json:"returnStack"`
+ ReturnData []byte `json:"returnData"`
 Storage map[common.Hash]common.Hash `json:"-"`
 Depth *int `json:"depth"`
 RefundCounter *uint64 `json:"refund"`
@@ -95,6 +106,15 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 s.Stack[k] = (*big.Int)(v)
 }
 }
+ if dec.ReturnStack != nil {
+ s.ReturnStack = make([]uint32, len(dec.ReturnStack))
+ for k, v := range dec.ReturnStack {
+ s.ReturnStack[k] = uint32(v)
+ }
+ }
+ if dec.ReturnData != nil {
+ s.ReturnData = dec.ReturnData
+ }
 if dec.Storage != nil {
 s.Storage = dec.Storage
 }
diff --git a/core/vm/instructions.go b/core/vm/instructions.go
index ecdccbd..abfa2aa 100644
--- a/core/vm/instructions.go
+++ b/core/vm/instructions.go
@@ -18,373 +18,223 @@ package vm
 
 import (
 "errors"
- "math/big"
-
 "github.com/ava-labs/coreth/core/types"
 "github.com/ava-labs/coreth/params"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/holiman/uint256"
 "golang.org/x/crypto/sha3"
 )
 
-var (
- bigZero = new(big.Int)
- tt255 = math.BigPow(2, 255)
- errWriteProtection = errors.New("evm: write protection")
- errReturnDataOutOfBounds = errors.New("evm: return data out of bounds")
- errExecutionReverted = errors.New("evm: execution reverted")
- errMaxCodeSizeExceeded = errors.New("evm: max code size exceeded")
- errInvalidJump = errors.New("evm: invalid jump destination")
-)
-
-func opAdd(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.peek()
- math.U256(y.Add(x, y))
-
- interpreter.intPool.put(x)
+func opAdd(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ y.Add(&x, y)
 return nil, nil
 }
 
-func opSub(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.peek()
- math.U256(y.Sub(x, y))
-
- interpreter.intPool.put(x)
+func opSub(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ y.Sub(&x, y)
 return nil, nil
 }
 
-func opMul(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.pop()
- stack.push(math.U256(x.Mul(x, y)))
-
- interpreter.intPool.put(y)
-
+func opMul(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ y.Mul(&x, y)
 return nil, nil
 }
 
-func opDiv(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.peek()
- if y.Sign() != 0 {
- math.U256(y.Div(x, y))
- } else {
- y.SetUint64(0)
- }
- interpreter.intPool.put(x)
+func opDiv(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ y.Div(&x, y)
 return nil, nil
 }
 
-func opSdiv(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := math.S256(stack.pop()), math.S256(stack.pop())
- res := interpreter.intPool.getZero()
-
- if y.Sign() == 0 || x.Sign() == 0 {
- stack.push(res)
- } else {
- if x.Sign() != y.Sign() {
- res.Div(x.Abs(x), y.Abs(y))
- res.Neg(res)
- } else {
- res.Div(x.Abs(x), y.Abs(y))
- }
- stack.push(math.U256(res))
- }
- interpreter.intPool.put(x, y)
+func opSdiv(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ y.SDiv(&x, y)
 return nil, nil
 }
 
-func opMod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.pop()
- if y.Sign() == 0 {
- stack.push(x.SetUint64(0))
- } else {
- stack.push(math.U256(x.Mod(x, y)))
- }
- interpreter.intPool.put(y)
+func opMod(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ y.Mod(&x, y)
 return nil, nil
 }
 
-func opSmod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := math.S256(stack.pop()), math.S256(stack.pop())
- res := interpreter.intPool.getZero()
-
- if y.Sign() == 0 {
- stack.push(res)
- } else {
- if x.Sign() < 0 {
- res.Mod(x.Abs(x), y.Abs(y))
- res.Neg(res)
- } else {
- res.Mod(x.Abs(x), y.Abs(y))
- }
- stack.push(math.U256(res))
- }
- interpreter.intPool.put(x, y)
+func opSmod(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ y.SMod(&x, y)
 return nil, nil
 }
 
-func opExp(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- base, exponent := stack.pop(), stack.pop()
- // some shortcuts
- cmpToOne := exponent.Cmp(big1)
- if cmpToOne < 0 { // Exponent is zero
- // x ^ 0 == 1
- stack.push(base.SetUint64(1))
- } else if base.Sign() == 0 {
- // 0 ^ y, if y != 0, == 0
- stack.push(base.SetUint64(0))
- } else if cmpToOne == 0 { // Exponent is one
- // x ^ 1 == x
- stack.push(base)
- } else {
- stack.push(math.Exp(base, exponent))
- interpreter.intPool.put(base)
- }
- interpreter.intPool.put(exponent)
+func opExp(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ base, exponent := callContext.stack.pop(), callContext.stack.peek()
+ exponent.Exp(&base, exponent)
 return nil, nil
 }
 
-func opSignExtend(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- back := stack.pop()
- if back.Cmp(big.NewInt(31)) < 0 {
- bit := uint(back.Uint64()*8 + 7)
- num := stack.pop()
- mask := back.Lsh(common.Big1, bit)
- mask.Sub(mask, common.Big1)
- if num.Bit(int(bit)) > 0 {
- num.Or(num, mask.Not(mask))
- } else {
- num.And(num, mask)
- }
-
- stack.push(math.U256(num))
- }
-
- interpreter.intPool.put(back)
+func opSignExtend(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ back, num := callContext.stack.pop(), callContext.stack.peek()
+ num.ExtendSign(num, &back)
 return nil, nil
 }
 
-func opNot(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x := stack.peek()
- math.U256(x.Not(x))
+func opNot(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x := callContext.stack.peek()
+ x.Not(x)
 return nil, nil
 }
 
-func opLt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.peek()
- if x.Cmp(y) < 0 {
- y.SetUint64(1)
+func opLt(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ if x.Lt(y) {
+ y.SetOne()
 } else {
- y.SetUint64(0)
+ y.Clear()
 }
- interpreter.intPool.put(x)
 return nil, nil
 }
 
-func opGt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.peek()
- if x.Cmp(y) > 0 {
- y.SetUint64(1)
+func opGt(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ if x.Gt(y) {
+ y.SetOne()
 } else {
- y.SetUint64(0)
+ y.Clear()
 }
- interpreter.intPool.put(x)
 return nil, nil
 }
 
-func opSlt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.peek()
-
- xSign := x.Cmp(tt255)
- ySign := y.Cmp(tt255)
-
- switch {
- case xSign >= 0 && ySign < 0:
- y.SetUint64(1)
-
- case xSign < 0 && ySign >= 0:
- y.SetUint64(0)
-
- default:
- if x.Cmp(y) < 0 {
- y.SetUint64(1)
- } else {
- y.SetUint64(0)
- }
+func opSlt(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ if x.Slt(y) {
+ y.SetOne()
+ } else {
+ y.Clear()
 }
- interpreter.intPool.put(x)
 return nil, nil
 }
 
-func opSgt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.peek()
-
- xSign := x.Cmp(tt255)
- ySign := y.Cmp(tt255)
-
- switch {
- case xSign >= 0 && ySign < 0:
- y.SetUint64(0)
-
- case xSign < 0 && ySign >= 0:
- y.SetUint64(1)
-
- default:
- if x.Cmp(y) > 0 {
- y.SetUint64(1)
- } else {
- y.SetUint64(0)
- }
+func opSgt(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ if x.Sgt(y) {
+ y.SetOne()
+ } else {
+ y.Clear()
 }
- interpreter.intPool.put(x)
 return nil, nil
 }
 
-func opEq(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.peek()
- if x.Cmp(y) == 0 {
- y.SetUint64(1)
+func opEq(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ if x.Eq(y) {
+ y.SetOne()
 } else {
- y.SetUint64(0)
+ y.Clear()
 }
- interpreter.intPool.put(x)
 return nil, nil
 }
 
-func opIszero(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x := stack.peek()
- if x.Sign() > 0 {
- x.SetUint64(0)
+func opIszero(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x := callContext.stack.peek()
+ if x.IsZero() {
+ x.SetOne()
 } else {
- x.SetUint64(1)
+ x.Clear()
 }
 return nil, nil
 }
 
-func opAnd(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.pop()
- stack.push(x.And(x, y))
-
- interpreter.intPool.put(y)
+func opAnd(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ y.And(&x, y)
 return nil, nil
 }
 
-func opOr(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.peek()
- y.Or(x, y)
-
- interpreter.intPool.put(x)
+func opOr(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ y.Or(&x, y)
 return nil, nil
 }
 
-func opXor(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y := stack.pop(), stack.peek()
- y.Xor(x, y)
-
- interpreter.intPool.put(x)
+func opXor(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y := callContext.stack.pop(), callContext.stack.peek()
+ y.Xor(&x, y)
 return nil, nil
 }
 
-func opByte(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- th, val := stack.pop(), stack.peek()
- if th.Cmp(common.Big32) < 0 {
- b := math.Byte(val, 32, int(th.Int64()))
- val.SetUint64(uint64(b))
- } else {
- val.SetUint64(0)
- }
- interpreter.intPool.put(th)
+func opByte(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ th, val := callContext.stack.pop(), callContext.stack.peek()
+ val.Byte(&th)
 return nil, nil
 }
 
-func opAddmod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y, z := stack.pop(), stack.pop(), stack.pop()
- if z.Cmp(bigZero) > 0 {
- x.Add(x, y)
- x.Mod(x, z)
- stack.push(math.U256(x))
+func opAddmod(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y, z := callContext.stack.pop(), callContext.stack.pop(), callContext.stack.peek()
+ if z.IsZero() {
+ z.Clear()
 } else {
- stack.push(x.SetUint64(0))
+ z.AddMod(&x, &y, z)
 }
- interpreter.intPool.put(y, z)
 return nil, nil
 }
 
-func opMulmod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- x, y, z := stack.pop(), stack.pop(), stack.pop()
- if z.Cmp(bigZero) > 0 {
- x.Mul(x, y)
- x.Mod(x, z)
- stack.push(math.U256(x))
- } else {
- stack.push(x.SetUint64(0))
- }
- interpreter.intPool.put(y, z)
+func opMulmod(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x, y, z := callContext.stack.pop(), callContext.stack.pop(), callContext.stack.peek()
+ 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, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opSHL(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 // Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards
- shift, value := math.U256(stack.pop()), math.U256(stack.peek())
- defer interpreter.intPool.put(shift) // First operand back into the pool
-
- if shift.Cmp(common.Big256) >= 0 {
- value.SetUint64(0)
- return nil, nil
+ shift, value := callContext.stack.pop(), callContext.stack.peek()
+ if shift.LtUint64(256) {
+ value.Lsh(value, uint(shift.Uint64()))
+ } else {
+ value.Clear()
 }
- n := uint(shift.Uint64())
- math.U256(value.Lsh(value, n))
-
 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, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opSHR(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 // Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards
- shift, value := math.U256(stack.pop()), math.U256(stack.peek())
- defer interpreter.intPool.put(shift) // First operand back into the pool
-
- if shift.Cmp(common.Big256) >= 0 {
- value.SetUint64(0)
- return nil, nil
+ shift, value := callContext.stack.pop(), callContext.stack.peek()
+ if shift.LtUint64(256) {
+ value.Rsh(value, uint(shift.Uint64()))
+ } else {
+ value.Clear()
 }
- n := uint(shift.Uint64())
- math.U256(value.Rsh(value, n))
-
 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, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- // Note, S256 returns (potentially) a new bigint, so we're popping, not peeking this one
- shift, value := math.U256(stack.pop()), math.S256(stack.pop())
- defer interpreter.intPool.put(shift) // First operand back into the pool
-
- if shift.Cmp(common.Big256) >= 0 {
+func opSAR(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ shift, value := callContext.stack.pop(), callContext.stack.peek()
+ if shift.GtUint64(256) {
 if value.Sign() >= 0 {
- value.SetUint64(0)
+ value.Clear()
 } else {
- value.SetInt64(-1)
+ // Max negative shift: all bits set
+ value.SetAllOne()
 }
- stack.push(math.U256(value))
 return nil, nil
 }
 n := uint(shift.Uint64())
- value.Rsh(value, n)
- stack.push(math.U256(value))
-
+ value.SRsh(value, n)
 return nil, nil
 }
 
-func opSha3(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- offset, size := stack.pop(), stack.pop()
- data := memory.Get(offset.Int64(), size.Int64())
+func opSha3(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ offset, size := callContext.stack.pop(), callContext.stack.peek()
+ data := callContext.memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))
 
 if interpreter.hasher == nil {
 interpreter.hasher = sha3.NewLegacyKeccak256().(keccakState)
@@ -398,127 +248,154 @@ func opSha3(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory
 if evm.vmConfig.EnablePreimageRecording {
 evm.StateDB.AddPreimage(interpreter.hasherBuf, data)
 }
- stack.push(interpreter.intPool.get().SetBytes(interpreter.hasherBuf[:]))
 
- interpreter.intPool.put(offset, size)
+ size.SetBytes(interpreter.hasherBuf[:])
 return nil, nil
 }
-
-func opAddress(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().SetBytes(contract.Address().Bytes()))
+func opAddress(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.push(new(uint256.Int).SetBytes(callContext.contract.Address().Bytes()))
 return nil, nil
 }
 
-func opBalance(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- slot := stack.peek()
- slot.Set(interpreter.evm.StateDB.GetBalance(common.BigToAddress(slot)))
+func opBalance(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ slot := callContext.stack.peek()
+ address := common.Address(slot.Bytes20())
+ slot.SetFromBig(interpreter.evm.StateDB.GetBalance(address))
 return nil, nil
 }
 
-func opBalanceMultiCoin(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- addr, cid := stack.pop(), stack.pop()
- stack.push(interpreter.evm.StateDB.GetBalanceMultiCoin(common.BigToAddress(addr), common.BigToHash(cid)))
+func opBalanceMultiCoin(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ addr, cid := callContext.stack.pop(), callContext.stack.pop()
+ res, err := uint256.FromBig(interpreter.evm.StateDB.GetBalanceMultiCoin(
+ common.BigToAddress(addr.ToBig()), common.BigToHash(cid.ToBig())))
+ if err {
+ return nil, errors.New("balance overflow")
+ }
+ callContext.stack.push(res)
 return nil, nil
 }
 
-func opOrigin(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().SetBytes(interpreter.evm.Origin.Bytes()))
+func opOrigin(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.push(new(uint256.Int).SetBytes(interpreter.evm.Origin.Bytes()))
 return nil, nil
 }
-
-func opCaller(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().SetBytes(contract.Caller().Bytes()))
+func opCaller(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.push(new(uint256.Int).SetBytes(callContext.contract.Caller().Bytes()))
 return nil, nil
 }
 
-func opCallValue(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().Set(contract.value))
+func opCallValue(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ v, _ := uint256.FromBig(callContext.contract.value)
+ callContext.stack.push(v)
 return nil, nil
 }
 
-func opCallDataLoad(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().SetBytes(getDataBig(contract.Input, stack.pop(), big32)))
+func opCallDataLoad(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ x := callContext.stack.peek()
+ if offset, overflow := x.Uint64WithOverflow(); !overflow {
+ data := getData(callContext.contract.Input, offset, 32)
+ x.SetBytes(data)
+ } else {
+ x.Clear()
+ }
 return nil, nil
 }
 
-func opCallDataSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().SetInt64(int64(len(contract.Input))))
+func opCallDataSize(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.push(new(uint256.Int).SetUint64(uint64(len(callContext.contract.Input))))
 return nil, nil
 }
 
-func opCallDataCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opCallDataCopy(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 var (
- memOffset = stack.pop()
- dataOffset = stack.pop()
- length = stack.pop()
+ memOffset = callContext.stack.pop()
+ dataOffset = callContext.stack.pop()
+ length = callContext.stack.pop()
 )
- memory.Set(memOffset.Uint64(), length.Uint64(), getDataBig(contract.Input, dataOffset, length))
+ dataOffset64, overflow := dataOffset.Uint64WithOverflow()
+ if overflow {
+ dataOffset64 = 0xffffffffffffffff
+ }
+ // These values are checked for overflow during gas cost calculation
+ memOffset64 := memOffset.Uint64()
+ length64 := length.Uint64()
+ callContext.memory.Set(memOffset64, length64, getData(callContext.contract.Input, dataOffset64, length64))
 
- interpreter.intPool.put(memOffset, dataOffset, length)
 return nil, nil
 }
 
-func opReturnDataSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().SetUint64(uint64(len(interpreter.returnData))))
+func opReturnDataSize(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.push(new(uint256.Int).SetUint64(uint64(len(interpreter.returnData))))
 return nil, nil
 }
 
-func opReturnDataCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opReturnDataCopy(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 var (
- memOffset = stack.pop()
- dataOffset = stack.pop()
- length = stack.pop()
-
- end = interpreter.intPool.get().Add(dataOffset, length)
+ memOffset = callContext.stack.pop()
+ dataOffset = callContext.stack.pop()
+ length = callContext.stack.pop()
 )
- defer interpreter.intPool.put(memOffset, dataOffset, length, end)
 
- if !end.IsUint64() || uint64(len(interpreter.returnData)) < end.Uint64() {
- return nil, errReturnDataOutOfBounds
+ offset64, overflow := dataOffset.Uint64WithOverflow()
+ if overflow {
+ return nil, ErrReturnDataOutOfBounds
 }
- memory.Set(memOffset.Uint64(), length.Uint64(), interpreter.returnData[dataOffset.Uint64():end.Uint64()])
-
+ // we can reuse dataOffset now (aliasing it for clarity)
+ var end = dataOffset
+ end.Add(&dataOffset, &length)
+ end64, overflow := end.Uint64WithOverflow()
+ if overflow || uint64(len(interpreter.returnData)) < end64 {
+ return nil, ErrReturnDataOutOfBounds
+ }
+ callContext.memory.Set(memOffset.Uint64(), length.Uint64(), interpreter.returnData[offset64:end64])
 return nil, nil
 }
 
-func opExtCodeSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- slot := stack.peek()
- slot.SetUint64(uint64(interpreter.evm.StateDB.GetCodeSize(common.BigToAddress(slot))))
-
+func opExtCodeSize(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ slot := callContext.stack.peek()
+ slot.SetUint64(uint64(interpreter.evm.StateDB.GetCodeSize(common.Address(slot.Bytes20()))))
 return nil, nil
 }
 
-func opCodeSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- l := interpreter.intPool.get().SetInt64(int64(len(contract.Code)))
- stack.push(l)
-
+func opCodeSize(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ l := new(uint256.Int)
+ l.SetUint64(uint64(len(callContext.contract.Code)))
+ callContext.stack.push(l)
 return nil, nil
 }
 
-func opCodeCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opCodeCopy(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 var (
- memOffset = stack.pop()
- codeOffset = stack.pop()
- length = stack.pop()
+ memOffset = callContext.stack.pop()
+ codeOffset = callContext.stack.pop()
+ length = callContext.stack.pop()
 )
- codeCopy := getDataBig(contract.Code, codeOffset, length)
- memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)
+ uint64CodeOffset, overflow := codeOffset.Uint64WithOverflow()
+ if overflow {
+ uint64CodeOffset = 0xffffffffffffffff
+ }
+ codeCopy := getData(callContext.contract.Code, uint64CodeOffset, length.Uint64())
+ callContext.memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)
 
- interpreter.intPool.put(memOffset, codeOffset, length)
 return nil, nil
 }
 
-func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 var (
- addr = common.BigToAddress(stack.pop())
+ stack = callContext.stack
+ a = stack.pop()
 memOffset = stack.pop()
 codeOffset = stack.pop()
 length = stack.pop()
 )
- codeCopy := getDataBig(interpreter.evm.StateDB.GetCode(addr), codeOffset, length)
- memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)
+ uint64CodeOffset, overflow := codeOffset.Uint64WithOverflow()
+ if overflow {
+ uint64CodeOffset = 0xffffffffffffffff
+ }
+ addr := common.Address(a.Bytes20())
+ codeCopy := getData(interpreter.evm.StateDB.GetCode(addr), uint64CodeOffset, length.Uint64())
+ callContext.memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)
 
- interpreter.intPool.put(memOffset, codeOffset, length)
 return nil, nil
 }
 
@@ -548,398 +425,482 @@ func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract,
 //
 // (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, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- slot := stack.peek()
- address := common.BigToAddress(slot)
+func opExtCodeHash(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ slot := callContext.stack.peek()
+ address := common.Address(slot.Bytes20())
 if interpreter.evm.StateDB.Empty(address) {
- slot.SetUint64(0)
+ slot.Clear()
 } else {
 slot.SetBytes(interpreter.evm.StateDB.GetCodeHash(address).Bytes())
 }
 return nil, nil
 }
 
-func opGasprice(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().Set(interpreter.evm.GasPrice))
+func opGasprice(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ v, _ := uint256.FromBig(interpreter.evm.GasPrice)
+ callContext.stack.push(v)
 return nil, nil
 }
 
-func opBlockhash(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- num := stack.pop()
-
- n := interpreter.intPool.get().Sub(interpreter.evm.BlockNumber, common.Big257)
- if num.Cmp(n) > 0 && num.Cmp(interpreter.evm.BlockNumber) < 0 {
- stack.push(interpreter.evm.GetHash(num.Uint64()).Big())
+func opBlockhash(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ num := callContext.stack.peek()
+ num64, overflow := num.Uint64WithOverflow()
+ if overflow {
+ num.Clear()
+ return nil, nil
+ }
+ var upper, lower uint64
+ upper = interpreter.evm.BlockNumber.Uint64()
+ if upper < 257 {
+ lower = 0
 } else {
- stack.push(interpreter.intPool.getZero())
+ lower = upper - 256
+ }
+ if num64 >= lower && num64 < upper {
+ num.SetBytes(interpreter.evm.GetHash(num64).Bytes())
+ } else {
+ num.Clear()
 }
- interpreter.intPool.put(num, n)
 return nil, nil
 }
 
-func opCoinbase(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().SetBytes(interpreter.evm.Coinbase.Bytes()))
+func opCoinbase(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.push(new(uint256.Int).SetBytes(interpreter.evm.Coinbase.Bytes()))
 return nil, nil
 }
 
-func opTimestamp(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(math.U256(interpreter.intPool.get().Set(interpreter.evm.Time)))
+func opTimestamp(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ v, _ := uint256.FromBig(interpreter.evm.Time)
+ callContext.stack.push(v)
 return nil, nil
 }
 
-func opNumber(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(math.U256(interpreter.intPool.get().Set(interpreter.evm.BlockNumber)))
+func opNumber(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ v, _ := uint256.FromBig(interpreter.evm.BlockNumber)
+ callContext.stack.push(v)
 return nil, nil
 }
 
-func opDifficulty(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(math.U256(interpreter.intPool.get().Set(interpreter.evm.Difficulty)))
+func opDifficulty(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ v, _ := uint256.FromBig(interpreter.evm.Difficulty)
+ callContext.stack.push(v)
 return nil, nil
 }
 
-func opGasLimit(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(math.U256(interpreter.intPool.get().SetUint64(interpreter.evm.GasLimit)))
+func opGasLimit(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.push(new(uint256.Int).SetUint64(interpreter.evm.GasLimit))
 return nil, nil
 }
 
-func opPop(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- interpreter.intPool.put(stack.pop())
+func opPop(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.pop()
 return nil, nil
 }
 
-func opMload(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- offset := stack.pop()
- val := interpreter.intPool.get().SetBytes(memory.Get(offset.Int64(), 32))
- stack.push(val)
-
- interpreter.intPool.put(offset)
+func opMload(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ v := callContext.stack.peek()
+ offset := int64(v.Uint64())
+ v.SetBytes(callContext.memory.GetPtr(offset, 32))
 return nil, nil
 }
 
-func opMstore(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opMstore(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 // pop value of the stack
- mStart, val := stack.pop(), stack.pop()
- memory.Set32(mStart.Uint64(), val)
-
- interpreter.intPool.put(mStart, val)
+ mStart, val := callContext.stack.pop(), callContext.stack.pop()
+ callContext.memory.Set32(mStart.Uint64(), &val)
 return nil, nil
 }
 
-func opMstore8(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- off, val := stack.pop().Int64(), stack.pop().Int64()
- memory.store[off] = byte(val & 0xff)
-
+func opMstore8(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ off, val := callContext.stack.pop(), callContext.stack.pop()
+ callContext.memory.store[off.Uint64()] = byte(val.Uint64())
 return nil, nil
 }
 
-func opSload(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- loc := stack.peek()
- val := interpreter.evm.StateDB.GetState(contract.Address(), common.BigToHash(loc))
+func opSload(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ loc := callContext.stack.peek()
+ hash := common.Hash(loc.Bytes32())
+ val := interpreter.evm.StateDB.GetState(callContext.contract.Address(), hash)
 loc.SetBytes(val.Bytes())
 return nil, nil
 }
 
-func opSstore(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- loc := common.BigToHash(stack.pop())
- val := stack.pop()
- if err := interpreter.evm.StateDB.SetState(contract.Address(), loc, common.BigToHash(val)); err != nil {
+func opSstore(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ loc := callContext.stack.pop()
+ val := callContext.stack.pop()
+ if err := interpreter.evm.StateDB.SetState(callContext.contract.Address(),
+ common.Hash(loc.Bytes32()), common.Hash(val.Bytes32())); err != nil {
 return nil, err
 }
- interpreter.intPool.put(val)
 return nil, nil
 }
 
-func opJump(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- pos := stack.pop()
- if !contract.validJumpdest(pos) {
- return nil, errInvalidJump
+func opJump(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ pos := callContext.stack.pop()
+ if !callContext.contract.validJumpdest(&pos) {
+ return nil, ErrInvalidJump
 }
 *pc = pos.Uint64()
-
- interpreter.intPool.put(pos)
 return nil, nil
 }
 
-func opJumpi(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- pos, cond := stack.pop(), stack.pop()
- if cond.Sign() != 0 {
- if !contract.validJumpdest(pos) {
- return nil, errInvalidJump
+func opJumpi(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ pos, cond := callContext.stack.pop(), callContext.stack.pop()
+ if !cond.IsZero() {
+ if !callContext.contract.validJumpdest(&pos) {
+ return nil, ErrInvalidJump
 }
 *pc = pos.Uint64()
 } else {
 *pc++
 }
+ return nil, nil
+}
+
+func opJumpdest(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ return nil, nil
+}
 
- interpreter.intPool.put(pos, cond)
+func opBeginSub(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ return nil, ErrInvalidSubroutineEntry
+}
+
+func opJumpSub(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ if len(callContext.rstack.data) >= 1023 {
+ return nil, ErrReturnStackExceeded
+ }
+ pos := callContext.stack.pop()
+ if !pos.IsUint64() {
+ return nil, ErrInvalidJump
+ }
+ posU64 := pos.Uint64()
+ if !callContext.contract.validJumpSubdest(posU64) {
+ return nil, ErrInvalidJump
+ }
+ callContext.rstack.push(uint32(*pc))
+ *pc = posU64 + 1
 return nil, nil
 }
 
-func opJumpdest(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opReturnSub(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ if len(callContext.rstack.data) == 0 {
+ return nil, ErrInvalidRetsub
+ }
+ // Other than the check that the return stack is not empty, there is no
+ // need to validate the pc from 'returns', since we only ever push valid
+ //values onto it via jumpsub.
+ *pc = uint64(callContext.rstack.pop()) + 1
 return nil, nil
 }
 
-func opPc(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().SetUint64(*pc))
+func opPc(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.push(new(uint256.Int).SetUint64(*pc))
 return nil, nil
 }
 
-func opMsize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().SetInt64(int64(memory.Len())))
+func opMsize(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.push(new(uint256.Int).SetUint64(uint64(callContext.memory.Len())))
 return nil, nil
 }
 
-func opGas(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.push(interpreter.intPool.get().SetUint64(contract.Gas))
+func opGas(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.push(new(uint256.Int).SetUint64(callContext.contract.Gas))
 return nil, nil
 }
 
-func opCreate(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opCreate(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 var (
- value = stack.pop()
- offset, size = stack.pop(), stack.pop()
- input = memory.Get(offset.Int64(), size.Int64())
- gas = contract.Gas
+ value = callContext.stack.pop()
+ offset, size = callContext.stack.pop(), callContext.stack.pop()
+ input = callContext.memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
+ gas = callContext.contract.Gas
 )
 if interpreter.evm.chainRules.IsEIP150 {
 gas -= gas / 64
 }
+ // reuse size int for stackvalue
+ stackvalue := size
 
- contract.UseGas(gas)
- res, addr, returnGas, suberr := interpreter.evm.Create(contract, input, gas, value)
+ callContext.contract.UseGas(gas)
+ //TODO: use uint256.Int instead of converting with toBig()
+ var bigVal = big0
+ if !value.IsZero() {
+ bigVal = value.ToBig()
+ }
+
+ res, addr, returnGas, suberr := interpreter.evm.Create(callContext.contract, input, gas, bigVal)
 // 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 {
- stack.push(interpreter.intPool.getZero())
+ stackvalue.Clear()
 } else if suberr != nil && suberr != ErrCodeStoreOutOfGas {
- stack.push(interpreter.intPool.getZero())
+ stackvalue.Clear()
 } else {
- stack.push(interpreter.intPool.get().SetBytes(addr.Bytes()))
+ stackvalue.SetBytes(addr.Bytes())
 }
- contract.Gas += returnGas
- interpreter.intPool.put(value, offset, size)
+ callContext.stack.push(&stackvalue)
+ callContext.contract.Gas += returnGas
 
- if suberr == errExecutionReverted {
+ if suberr == ErrExecutionReverted {
 return res, nil
 }
 return nil, nil
 }
 
-func opCreate2(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opCreate2(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 var (
- endowment = stack.pop()
- offset, size = stack.pop(), stack.pop()
- salt = stack.pop()
- input = memory.Get(offset.Int64(), size.Int64())
- gas = contract.Gas
+ endowment = callContext.stack.pop()
+ offset, size = callContext.stack.pop(), callContext.stack.pop()
+ salt = callContext.stack.pop()
+ input = callContext.memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
+ gas = callContext.contract.Gas
 )
 
 // Apply EIP150
 gas -= gas / 64
- contract.UseGas(gas)
- res, addr, returnGas, suberr := interpreter.evm.Create2(contract, input, gas, endowment, salt)
+ callContext.contract.UseGas(gas)
+ // reuse size int for stackvalue
+ stackvalue := size
+ //TODO: use uint256.Int instead of converting with toBig()
+ bigEndowment := big0
+ if !endowment.IsZero() {
+ bigEndowment = endowment.ToBig()
+ }
+ res, addr, returnGas, suberr := interpreter.evm.Create2(callContext.contract, input, gas,
+ bigEndowment, &salt)
 // Push item on the stack based on the returned error.
 if suberr != nil {
- stack.push(interpreter.intPool.getZero())
+ stackvalue.Clear()
 } else {
- stack.push(interpreter.intPool.get().SetBytes(addr.Bytes()))
+ stackvalue.SetBytes(addr.Bytes())
 }
- contract.Gas += returnGas
- interpreter.intPool.put(endowment, offset, size, salt)
+ callContext.stack.push(&stackvalue)
+ callContext.contract.Gas += returnGas
 
- if suberr == errExecutionReverted {
+ if suberr == ErrExecutionReverted {
 return res, nil
 }
 return nil, nil
 }
 
-func opCall(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ stack := callContext.stack
 // Pop gas. The actual gas in interpreter.evm.callGasTemp.
- interpreter.intPool.put(stack.pop())
+ // 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 := common.BigToAddress(addr)
- value = math.U256(value)
+ toAddr := common.Address(addr.Bytes20())
 // Get the arguments from the memory.
- args := memory.Get(inOffset.Int64(), inSize.Int64())
+ args := callContext.memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
 
- if value.Sign() != 0 {
+ var bigVal = big0
+ //TODO: use uint256.Int instead of converting with toBig()
+ // By using big0 here, we save an alloc for the most common case (non-ether-transferring contract calls),
+ // but it would make more sense to extend the usage of uint256.Int
+ if !value.IsZero() {
 gas += params.CallStipend
+ bigVal = value.ToBig()
 }
- ret, returnGas, err := interpreter.evm.Call(contract, toAddr, args, gas, value)
+
+ ret, returnGas, err := interpreter.evm.Call(callContext.contract, toAddr, args, gas, bigVal)
+
 if err != nil {
- stack.push(interpreter.intPool.getZero())
+ temp.Clear()
 } else {
- stack.push(interpreter.intPool.get().SetUint64(1))
+ temp.SetOne()
 }
- if err == nil || err == errExecutionReverted {
- memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
+ stack.push(&temp)
+ if err == nil || err == ErrExecutionReverted {
+ callContext.memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 }
- contract.Gas += returnGas
+ callContext.contract.Gas += returnGas
 
- interpreter.intPool.put(addr, value, inOffset, inSize, retOffset, retSize)
 return ret, nil
 }
 
-func opCallExpert(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opCallExpert(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ stack := callContext.stack
 // Pop gas. The actual gas in interpreter.evm.callGasTemp.
- interpreter.intPool.put(stack.pop())
+ // We can use this as a temporary value
+ temp := stack.pop()
 gas := interpreter.evm.callGasTemp
 // Pop other call parameters.
 addr, value, cid, value2, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
- toAddr := common.BigToAddress(addr)
- coinID := common.BigToHash(cid)
- value = math.U256(value)
- value2 = math.U256(value2)
+ toAddr := common.Address(addr.Bytes20())
+ coinID := common.BigToHash(cid.ToBig())
 // Get the arguments from the memory.
- args := memory.Get(inOffset.Int64(), inSize.Int64())
+ args := callContext.memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
 
- if value.Sign() != 0 {
+ var bigVal = big0
+ //TODO: use uint256.Int instead of converting with toBig()
+ // By using big0 here, we save an alloc for the most common case (non-ether-transferring contract calls),
+ // but it would make more sense to extend the usage of uint256.Int
+ if !value.IsZero() {
 gas += params.CallStipend
+ bigVal = value.ToBig()
 }
- ret, returnGas, err := interpreter.evm.CallExpert(contract, toAddr, args, gas, value, &coinID, value2)
+
+ var bigVal2 = big0
+ //TODO: use uint256.Int instead of converting with toBig()
+ // By using big0 here, we save an alloc for the most common case (non-ether-transferring contract calls),
+ // but it would make more sense to extend the usage of uint256.Int
+ if !value2.IsZero() {
+ bigVal2 = value2.ToBig()
+ }
+
+ ret, returnGas, err := interpreter.evm.CallExpert(callContext.contract, toAddr, args, gas, bigVal, &coinID, bigVal2)
+
 if err != nil {
- stack.push(interpreter.intPool.getZero())
+ temp.Clear()
 } else {
- stack.push(interpreter.intPool.get().SetUint64(1))
+ temp.SetOne()
 }
- if err == nil || err == errExecutionReverted {
- memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
+ stack.push(&temp)
+ if err == nil || err == ErrExecutionReverted {
+ callContext.memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 }
- contract.Gas += returnGas
+ callContext.contract.Gas += returnGas
 
- interpreter.intPool.put(addr, value, inOffset, inSize, retOffset, retSize)
 return ret, nil
 }
-
-func opCallCode(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opCallCode(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 // Pop gas. The actual gas is in interpreter.evm.callGasTemp.
- interpreter.intPool.put(stack.pop())
+ stack := callContext.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 := common.BigToAddress(addr)
- value = math.U256(value)
+ toAddr := common.Address(addr.Bytes20())
 // Get arguments from the memory.
- args := memory.Get(inOffset.Int64(), inSize.Int64())
+ args := callContext.memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
 
- if value.Sign() != 0 {
+ //TODO: use uint256.Int instead of converting with toBig()
+ var bigVal = big0
+ if !value.IsZero() {
 gas += params.CallStipend
+ bigVal = value.ToBig()
 }
- ret, returnGas, err := interpreter.evm.CallCode(contract, toAddr, args, gas, value)
+
+ ret, returnGas, err := interpreter.evm.CallCode(callContext.contract, toAddr, args, gas, bigVal)
 if err != nil {
- stack.push(interpreter.intPool.getZero())
+ temp.Clear()
 } else {
- stack.push(interpreter.intPool.get().SetUint64(1))
+ temp.SetOne()
 }
- if err == nil || err == errExecutionReverted {
- memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
+ stack.push(&temp)
+ if err == nil || err == ErrExecutionReverted {
+ callContext.memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 }
- contract.Gas += returnGas
+ callContext.contract.Gas += returnGas
 
- interpreter.intPool.put(addr, value, inOffset, inSize, retOffset, retSize)
 return ret, nil
 }
 
-func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ stack := callContext.stack
 // Pop gas. The actual gas is in interpreter.evm.callGasTemp.
- interpreter.intPool.put(stack.pop())
+ // 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 := common.BigToAddress(addr)
+ toAddr := common.Address(addr.Bytes20())
 // Get arguments from the memory.
- args := memory.Get(inOffset.Int64(), inSize.Int64())
+ args := callContext.memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
 
- ret, returnGas, err := interpreter.evm.DelegateCall(contract, toAddr, args, gas)
+ ret, returnGas, err := interpreter.evm.DelegateCall(callContext.contract, toAddr, args, gas)
 if err != nil {
- stack.push(interpreter.intPool.getZero())
+ temp.Clear()
 } else {
- stack.push(interpreter.intPool.get().SetUint64(1))
+ temp.SetOne()
 }
- if err == nil || err == errExecutionReverted {
- memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
+ stack.push(&temp)
+ if err == nil || err == ErrExecutionReverted {
+ callContext.memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 }
- contract.Gas += returnGas
+ callContext.contract.Gas += returnGas
 
- interpreter.intPool.put(addr, inOffset, inSize, retOffset, retSize)
 return ret, nil
 }
 
-func opStaticCall(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opStaticCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 // Pop gas. The actual gas is in interpreter.evm.callGasTemp.
- interpreter.intPool.put(stack.pop())
+ stack := callContext.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 := common.BigToAddress(addr)
+ toAddr := common.Address(addr.Bytes20())
 // Get arguments from the memory.
- args := memory.Get(inOffset.Int64(), inSize.Int64())
+ args := callContext.memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
 
- ret, returnGas, err := interpreter.evm.StaticCall(contract, toAddr, args, gas)
+ ret, returnGas, err := interpreter.evm.StaticCall(callContext.contract, toAddr, args, gas)
 if err != nil {
- stack.push(interpreter.intPool.getZero())
+ temp.Clear()
 } else {
- stack.push(interpreter.intPool.get().SetUint64(1))
+ temp.SetOne()
 }
- if err == nil || err == errExecutionReverted {
- memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
+ stack.push(&temp)
+ if err == nil || err == ErrExecutionReverted {
+ callContext.memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 }
- contract.Gas += returnGas
+ callContext.contract.Gas += returnGas
 
- interpreter.intPool.put(addr, inOffset, inSize, retOffset, retSize)
 return ret, nil
 }
 
-func opReturn(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- offset, size := stack.pop(), stack.pop()
- ret := memory.GetPtr(offset.Int64(), size.Int64())
+func opReturn(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ offset, size := callContext.stack.pop(), callContext.stack.pop()
+ ret := callContext.memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))
 
- interpreter.intPool.put(offset, size)
 return ret, nil
 }
 
-func opRevert(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- offset, size := stack.pop(), stack.pop()
- ret := memory.GetPtr(offset.Int64(), size.Int64())
+func opRevert(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ offset, size := callContext.stack.pop(), callContext.stack.pop()
+ ret := callContext.memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))
 
- interpreter.intPool.put(offset, size)
 return ret, nil
 }
 
-func opStop(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opStop(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 return nil, nil
 }
 
-func opSuicide(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- balance := interpreter.evm.StateDB.GetBalance(contract.Address())
- interpreter.evm.StateDB.AddBalance(common.BigToAddress(stack.pop()), balance)
-
- interpreter.evm.StateDB.Suicide(contract.Address())
+func opSuicide(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ beneficiary := callContext.stack.pop()
+ balance := interpreter.evm.StateDB.GetBalance(callContext.contract.Address())
+ interpreter.evm.StateDB.AddBalance(common.Address(beneficiary.Bytes20()), balance)
+ interpreter.evm.StateDB.Suicide(callContext.contract.Address())
 return nil, nil
 }
 
-func opEMC(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- return nil, interpreter.evm.StateDB.EnableMultiCoin(contract.Address())
+func opEMC(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ return nil, interpreter.evm.StateDB.EnableMultiCoin(callContext.contract.Address())
 }
 
 // following functions are used by the instruction jump table
 
 // make log instruction function
 func makeLog(size int) executionFunc {
- return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+ return func(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 topics := make([]common.Hash, size)
+ stack := callContext.stack
 mStart, mSize := stack.pop(), stack.pop()
 for i := 0; i < size; i++ {
- topics[i] = common.BigToHash(stack.pop())
+ addr := stack.pop()
+ topics[i] = common.Hash(addr.Bytes32())
 }
 
- d := memory.Get(mStart.Int64(), mSize.Int64())
+ d := callContext.memory.GetCopy(int64(mStart.Uint64()), int64(mSize.Uint64()))
 interpreter.evm.StateDB.AddLog(&types.Log{
- Address: contract.Address(),
+ Address: callContext.contract.Address(),
 Topics: topics,
 Data: d,
 // This is a non-consensus field, but assigned here because
@@ -947,30 +908,29 @@ func makeLog(size int) executionFunc {
 BlockNumber: interpreter.evm.BlockNumber.Uint64(),
 })
 
- interpreter.intPool.put(mStart, mSize)
 return nil, nil
 }
 }
 
 // opPush1 is a specialized version of pushN
-func opPush1(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+func opPush1(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 var (
- codeLen = uint64(len(contract.Code))
- integer = interpreter.intPool.get()
+ codeLen = uint64(len(callContext.contract.Code))
+ integer = new(uint256.Int)
 )
 *pc += 1
 if *pc < codeLen {
- stack.push(integer.SetUint64(uint64(contract.Code[*pc])))
+ callContext.stack.push(integer.SetUint64(uint64(callContext.contract.Code[*pc])))
 } else {
- stack.push(integer.SetUint64(0))
+ callContext.stack.push(integer.Clear())
 }
 return nil, nil
 }
 
 // make push instruction function
 func makePush(size uint64, pushByteSize int) executionFunc {
- return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- codeLen := len(contract.Code)
+ return func(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ codeLen := len(callContext.contract.Code)
 
 startMin := codeLen
 if int(*pc+1) < startMin {
@@ -982,8 +942,9 @@ func makePush(size uint64, pushByteSize int) executionFunc {
 endMin = startMin + pushByteSize
 }
 
- integer := interpreter.intPool.get()
- stack.push(integer.SetBytes(common.RightPadBytes(contract.Code[startMin:endMin], pushByteSize)))
+ integer := new(uint256.Int)
+ callContext.stack.push(integer.SetBytes(common.RightPadBytes(
+ callContext.contract.Code[startMin:endMin], pushByteSize)))
 
 *pc += size
 return nil, nil
@@ -992,8 +953,8 @@ func makePush(size uint64, pushByteSize int) executionFunc {
 
 // make dup instruction function
 func makeDup(size int64) executionFunc {
- return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.dup(interpreter.intPool, int(size))
+ return func(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.dup(int(size))
 return nil, nil
 }
 }
@@ -1002,8 +963,8 @@ func makeDup(size int64) executionFunc {
 func makeSwap(size int64) executionFunc {
 // switch n + 1 otherwise n would be swapped with n
 size++
- return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
- stack.swap(int(size))
+ return func(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
+ callContext.stack.swap(int(size))
 return nil, nil
 }
 }
diff --git a/core/vm/int_pool_verifier.go b/core/vm/int_pool_verifier.go
deleted file mode 100644
index 82fbfed..0000000
--- a/core/vm/int_pool_verifier.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2017 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/>.
-
-// +build VERIFY_EVM_INTEGER_POOL
-
-package vm
-
-import "fmt"
-
-const verifyPool = true
-
-func verifyIntegerPool(ip *intPool) {
- for i, item := range ip.pool.data {
- if item.Cmp(checkVal) != 0 {
- panic(fmt.Sprintf("%d'th item failed aggressive pool check. Value was modified", i))
- }
- }
-}
diff --git a/core/vm/int_pool_verifier_empty.go b/core/vm/int_pool_verifier_empty.go
deleted file mode 100644
index a5f1dc0..0000000
--- a/core/vm/int_pool_verifier_empty.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2017 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/>.
-
-// +build !VERIFY_EVM_INTEGER_POOL
-
-package vm
-
-const verifyPool = false
-
-func verifyIntegerPool(ip *intPool) {}
diff --git a/core/vm/interface.go b/core/vm/interface.go
index 7e2d324..4f95423 100644
--- a/core/vm/interface.go
+++ b/core/vm/interface.go
@@ -20,7 +20,7 @@ import (
 "math/big"
 
 "github.com/ava-labs/coreth/core/types"
- "github.com/ava-labs/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common"
 )
 
 // StateDB is an EVM database for full state querying.
diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go
index e23896a..a114a8d 100644
--- a/core/vm/interpreter.go
+++ b/core/vm/interpreter.go
@@ -17,13 +17,12 @@
 package vm
 
 import (
- "fmt"
 "hash"
 "sync/atomic"
 
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/math"
- "github.com/ava-labs/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/log"
 )
 
 var (
@@ -40,7 +39,7 @@ type Config struct {
 NoRecursion bool // Disables call, callcode, delegate call and create
 EnablePreimageRecording bool // Enables recording of SHA3/keccak preimages
 
- JumpTable [256]operation // EVM instruction table, automatically populated if unset
+ JumpTable [256]*operation // EVM instruction table, automatically populated if unset
 
 EWASMInterpreter string // External EWASM interpreter options
 EVMInterpreter string // External EVM interpreter options
@@ -70,6 +69,15 @@ type Interpreter interface {
 CanRun([]byte) bool
 }
 
+// callCtx contains the things that are per-call, such as stack and memory,
+// but not transients like pc and gas
+type callCtx struct {
+ memory *Memory
+ stack *Stack
+ rstack *ReturnStack
+ contract *Contract
+}
+
 // keccakState wraps sha3.state. In addition to the usual hash methods, it also supports
 // Read to get a variable amount of data from the hash state. Read is faster than Sum
 // because it doesn't copy the internal state, but also modifies the internal state.
@@ -83,8 +91,6 @@ type EVMInterpreter struct {
 evm *EVM
 cfg Config
 
- intPool *intPool
-
 hasher keccakState // Keccak256 hasher instance shared across opcodes
 hasherBuf common.Hash // Keccak256 hasher result array shared aross opcodes
 
@@ -97,9 +103,11 @@ func NewEVMInterpreter(evm *EVM, cfg Config) *EVMInterpreter {
 // We use the STOP instruction whether to see
 // the jump table was initialised. If it was not
 // we'll set the default jump table.
- if !cfg.JumpTable[STOP].valid {
+ if cfg.JumpTable[STOP] == nil {
 var jt JumpTable
 switch {
+ case evm.chainRules.IsYoloV1:
+ jt = yoloV1InstructionSet
 case evm.chainRules.IsIstanbul:
 jt = istanbulInstructionSet
 case evm.chainRules.IsConstantinople:
@@ -136,7 +144,7 @@ func NewEVMInterpreter(evm *EVM, cfg Config) *EVMInterpreter {
 //
 // It's important to note that any errors returned by the interpreter should be
 // considered a revert-and-consume-all-gas operation except for
-// errExecutionReverted which means revert-and-keep-gas-left.
+// ErrExecutionReverted which means revert-and-keep-gas-left.
 func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (ret []byte, err error) {
 if contract.Address() == BuiltinAddr {
 self := AccountRef(contract.Caller())
@@ -145,13 +153,6 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 }
 contract.self = self
 }
- if in.intPool == nil {
- in.intPool = poolOfIntPools.get()
- defer func() {
- poolOfIntPools.put(in.intPool)
- in.intPool = nil
- }()
- }
 
 // Increment the call depth which is restricted to 1024
 in.evm.depth++
@@ -174,9 +175,16 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 }
 
 var (
- op OpCode // current opcode
- mem = NewMemory() // bound memory
- stack = newstack() // local stack
+ op OpCode // current opcode
+ mem = NewMemory() // bound memory
+ stack = newstack() // local stack
+ returns = newReturnStack() // local returns stack
+ callContext = &callCtx{
+ memory: mem,
+ stack: stack,
+ rstack: returns,
+ contract: contract,
+ }
 // For optimisation reason we're using uint64 as the program counter.
 // It's theoretically possible to go above 2^64. The YP defines the PC
 // to be uint256. Practically much less so feasible.
@@ -188,18 +196,22 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 logged bool // deferred Tracer should ignore already logged steps
 res []byte // result of the opcode execution function
 )
+ // Don't move this deferrred function, it's placed before the capturestate-deferred method,
+ // so that it get's executed _after_: the capturestate needs the stacks before
+ // they are returned to the pools
+ defer func() {
+ returnStack(stack)
+ returnRStack(returns)
+ }()
 contract.Input = input
 
- // Reclaim the stack as an int pool when the execution stops
- defer func() { in.intPool.put(stack.data...) }()
-
 if in.cfg.Debug {
 defer func() {
 if err != nil {
 if !logged {
- in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err)
+ in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stack, returns, in.returnData, contract, in.evm.depth, err)
 } else {
- in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err)
+ in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, mem, stack, returns, contract, in.evm.depth, err)
 }
 }
 }()
@@ -208,7 +220,12 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 // explicit STOP, RETURN or SELFDESTRUCT is executed, an error occurred during
 // the execution of one of the operations or until the done flag is set by the
 // parent context.
- for atomic.LoadInt32(&in.evm.abort) == 0 {
+ steps := 0
+ for {
+ steps++
+ if steps%1000 == 0 && atomic.LoadInt32(&in.evm.abort) != 0 {
+ break
+ }
 if in.cfg.Debug {
 // Capture pre-execution values for tracing.
 logged, pcCopy, gasCopy = false, pc, contract.Gas
@@ -218,14 +235,14 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 // enough stack items available to perform the operation.
 op = contract.GetOp(pc)
 operation := in.cfg.JumpTable[op]
- if !operation.valid {
- return nil, fmt.Errorf("invalid opcode 0x%x", int(op))
+ if operation == nil {
+ return nil, &ErrInvalidOpCode{opcode: op}
 }
 // Validate stack
 if sLen := stack.len(); sLen < operation.minStack {
- return nil, fmt.Errorf("stack underflow (%d <=> %d)", sLen, operation.minStack)
+ return nil, &ErrStackUnderflow{stackLen: sLen, required: operation.minStack}
 } else if sLen > operation.maxStack {
- return nil, fmt.Errorf("stack limit reached %d (%d)", sLen, operation.maxStack)
+ return nil, &ErrStackOverflow{stackLen: sLen, limit: operation.maxStack}
 }
 // If the operation is valid, enforce and write restrictions
 if in.readOnly && in.evm.chainRules.IsByzantium {
@@ -235,7 +252,7 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 // account to the others means the state is modified and should also
 // return with an error.
 if operation.writes || ((op == CALL || op == CALLEX) && stack.Back(2).Sign() != 0) {
- return nil, errWriteProtection
+ return nil, ErrWriteProtection
 }
 }
 // Static portion of gas
@@ -252,12 +269,12 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 if operation.memorySize != nil {
 memSize, overflow := operation.memorySize(stack)
 if overflow {
- return nil, errGasUintOverflow
+ return nil, ErrGasUintOverflow
 }
 // memory is expanded in words of 32 bytes. Gas
 // is also calculated in words.
 if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow {
- return nil, errGasUintOverflow
+ return nil, ErrGasUintOverflow
 }
 }
 // Dynamic portion of gas
@@ -276,28 +293,23 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 }
 
 if in.cfg.Debug {
- in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err)
+ in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, mem, stack, returns, in.returnData, contract, in.evm.depth, err)
 logged = true
 }
 
 // execute the operation
- res, err = operation.execute(&pc, in, contract, mem, stack)
- // verifyPool is a build flag. Pool verification makes sure the integrity
- // of the integer pool by comparing values to a default value.
- if verifyPool {
- verifyIntegerPool(in.intPool)
- }
+ res, err = operation.execute(&pc, in, callContext)
 // if the operation clears the return data (e.g. it has returning data)
 // set the last return to the result of the operation.
 if operation.returns {
- in.returnData = res
+ in.returnData = common.CopyBytes(res)
 }
 
 switch {
 case err != nil:
 return nil, err
 case operation.reverts:
- return res, errExecutionReverted
+ return res, ErrExecutionReverted
 case operation.halts:
 return res, nil
 case !operation.jumps:
diff --git a/core/vm/intpool.go b/core/vm/intpool.go
deleted file mode 100644
index 917a78d..0000000
--- a/core/vm/intpool.go
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright 2017 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 (
- "math/big"
- "sync"
-)
-
-var checkVal = big.NewInt(-42)
-
-const poolLimit = 256
-
-// intPool is a pool of big integers that
-// can be reused for all big.Int operations.
-type intPool struct {
- pool *Stack
-}
-
-func newIntPool() *intPool {
- return &intPool{pool: newstack()}
-}
-
-// get retrieves a big int from the pool, allocating one if the pool is empty.
-// Note, the returned int's value is arbitrary and will not be zeroed!
-func (p *intPool) get() *big.Int {
- if p.pool.len() > 0 {
- return p.pool.pop()
- }
- return new(big.Int)
-}
-
-// getZero retrieves a big int from the pool, setting it to zero or allocating
-// a new one if the pool is empty.
-func (p *intPool) getZero() *big.Int {
- if p.pool.len() > 0 {
- return p.pool.pop().SetUint64(0)
- }
- return new(big.Int)
-}
-
-// put returns an allocated big int to the pool to be later reused by get calls.
-// Note, the values as saved as is; neither put nor get zeroes the ints out!
-func (p *intPool) put(is ...*big.Int) {
- if len(p.pool.data) > poolLimit {
- return
- }
- for _, i := range is {
- // verifyPool is a build flag. Pool verification makes sure the integrity
- // of the integer pool by comparing values to a default value.
- if verifyPool {
- i.Set(checkVal)
- }
- p.pool.push(i)
- }
-}
-
-// The intPool pool's default capacity
-const poolDefaultCap = 25
-
-// intPoolPool manages a pool of intPools.
-type intPoolPool struct {
- pools []*intPool
- lock sync.Mutex
-}
-
-var poolOfIntPools = &intPoolPool{
- pools: make([]*intPool, 0, poolDefaultCap),
-}
-
-// get is looking for an available pool to return.
-func (ipp *intPoolPool) get() *intPool {
- ipp.lock.Lock()
- defer ipp.lock.Unlock()
-
- if len(poolOfIntPools.pools) > 0 {
- ip := ipp.pools[len(ipp.pools)-1]
- ipp.pools = ipp.pools[:len(ipp.pools)-1]
- return ip
- }
- return newIntPool()
-}
-
-// put a pool that has been allocated with get.
-func (ipp *intPoolPool) put(ip *intPool) {
- ipp.lock.Lock()
- defer ipp.lock.Unlock()
-
- if len(ipp.pools) < cap(ipp.pools) {
- ipp.pools = append(ipp.pools, ip)
- }
-}
diff --git a/core/vm/jump_table.go b/core/vm/jump_table.go
index 737dd14..7e3e354 100644
--- a/core/vm/jump_table.go
+++ b/core/vm/jump_table.go
@@ -17,20 +17,16 @@
 package vm
 
 import (
- "errors"
-
 "github.com/ava-labs/coreth/params"
 )
 
 type (
- executionFunc func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error)
+ executionFunc func(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error)
 gasFunc func(*EVM, *Contract, *Stack, *Memory, uint64) (uint64, error) // last parameter is the requested memory size as a uint64
 // memorySizeFunc returns the required size, and whether the operation overflowed a uint64
 memorySizeFunc func(*Stack) (size uint64, overflow bool)
 )
 
-var errGasUintOverflow = errors.New("gas uint64 overflow")
-
 type operation struct {
 // execute is the operation function
 execute executionFunc
@@ -48,7 +44,6 @@ type operation struct {
 halts bool // indicates whether the operation should halt further execution
 jumps bool // indicates whether the program counter should not increment
 writes bool // determines whether this a state modifying operation
- valid bool // indication whether the retrieved operation is valid and known
 reverts bool // determines whether the operation reverts state (implicitly halts)
 returns bool // determines whether the operations sets the return data content
 }
@@ -61,10 +56,19 @@ var (
 byzantiumInstructionSet = newByzantiumInstructionSet()
 constantinopleInstructionSet = newConstantinopleInstructionSet()
 istanbulInstructionSet = newIstanbulInstructionSet()
+ yoloV1InstructionSet = newYoloV1InstructionSet()
 )
 
 // JumpTable contains the EVM opcodes supported at a given fork.
-type JumpTable [256]operation
+type JumpTable [256]*operation
+
+func newYoloV1InstructionSet() JumpTable {
+ instructionSet := newIstanbulInstructionSet()
+
+ enable2315(&instructionSet) // Subroutines - https://eips.ethereum.org/EIPS/eip-2315
+
+ return instructionSet
+}
 
 // newIstanbulInstructionSet returns the frontier, homestead
 // byzantium, contantinople and petersburg instructions.
@@ -82,42 +86,37 @@ func newIstanbulInstructionSet() JumpTable {
 // byzantium and contantinople instructions.
 func newConstantinopleInstructionSet() JumpTable {
 instructionSet := newByzantiumInstructionSet()
- instructionSet[SHL] = operation{
+ instructionSet[SHL] = &operation{
 execute: opSHL,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 }
- instructionSet[SHR] = operation{
+ instructionSet[SHR] = &operation{
 execute: opSHR,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 }
- instructionSet[SAR] = operation{
+ instructionSet[SAR] = &operation{
 execute: opSAR,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 }
- instructionSet[EXTCODEHASH] = operation{
+ instructionSet[EXTCODEHASH] = &operation{
 execute: opExtCodeHash,
 constantGas: params.ExtcodeHashGasConstantinople,
 minStack: minStack(1, 1),
 maxStack: maxStack(1, 1),
- valid: true,
 }
- instructionSet[CREATE2] = operation{
+ instructionSet[CREATE2] = &operation{
 execute: opCreate2,
 constantGas: params.Create2Gas,
 dynamicGas: gasCreate2,
 minStack: minStack(4, 1),
 maxStack: maxStack(4, 1),
 memorySize: memoryCreate2,
- valid: true,
 writes: true,
 returns: true,
 }
@@ -128,39 +127,35 @@ func newConstantinopleInstructionSet() JumpTable {
 // byzantium instructions.
 func newByzantiumInstructionSet() JumpTable {
 instructionSet := newSpuriousDragonInstructionSet()
- instructionSet[STATICCALL] = operation{
+ instructionSet[STATICCALL] = &operation{
 execute: opStaticCall,
 constantGas: params.CallGasEIP150,
 dynamicGas: gasStaticCall,
 minStack: minStack(6, 1),
 maxStack: maxStack(6, 1),
 memorySize: memoryStaticCall,
- valid: true,
 returns: true,
 }
- instructionSet[RETURNDATASIZE] = operation{
+ instructionSet[RETURNDATASIZE] = &operation{
 execute: opReturnDataSize,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 }
- instructionSet[RETURNDATACOPY] = operation{
+ instructionSet[RETURNDATACOPY] = &operation{
 execute: opReturnDataCopy,
 constantGas: GasFastestStep,
 dynamicGas: gasReturnDataCopy,
 minStack: minStack(3, 0),
 maxStack: maxStack(3, 0),
 memorySize: memoryReturnDataCopy,
- valid: true,
 }
- instructionSet[REVERT] = operation{
+ instructionSet[REVERT] = &operation{
 execute: opRevert,
 dynamicGas: gasRevert,
 minStack: minStack(2, 0),
 maxStack: maxStack(2, 0),
 memorySize: memoryRevert,
- valid: true,
 reverts: true,
 returns: true,
 }
@@ -193,14 +188,13 @@ func newTangerineWhistleInstructionSet() JumpTable {
 // instructions that can be executed during the homestead phase.
 func newHomesteadInstructionSet() JumpTable {
 instructionSet := newFrontierInstructionSet()
- instructionSet[DELEGATECALL] = operation{
+ instructionSet[DELEGATECALL] = &operation{
 execute: opDelegateCall,
 dynamicGas: gasDelegateCall,
 constantGas: params.CallGasFrontier,
 minStack: minStack(6, 1),
 maxStack: maxStack(6, 1),
 memorySize: memoryDelegateCall,
- valid: true,
 returns: true,
 }
 return instructionSet
@@ -216,161 +210,138 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(0, 0),
 maxStack: maxStack(0, 0),
 halts: true,
- valid: true,
 },
 ADD: {
 execute: opAdd,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 MUL: {
 execute: opMul,
 constantGas: GasFastStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 SUB: {
 execute: opSub,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 DIV: {
 execute: opDiv,
 constantGas: GasFastStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 SDIV: {
 execute: opSdiv,
 constantGas: GasFastStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 MOD: {
 execute: opMod,
 constantGas: GasFastStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 SMOD: {
 execute: opSmod,
 constantGas: GasFastStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 ADDMOD: {
 execute: opAddmod,
 constantGas: GasMidStep,
 minStack: minStack(3, 1),
 maxStack: maxStack(3, 1),
- valid: true,
 },
 MULMOD: {
 execute: opMulmod,
 constantGas: GasMidStep,
 minStack: minStack(3, 1),
 maxStack: maxStack(3, 1),
- valid: true,
 },
 EXP: {
 execute: opExp,
 dynamicGas: gasExpFrontier,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 SIGNEXTEND: {
 execute: opSignExtend,
 constantGas: GasFastStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 LT: {
 execute: opLt,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 GT: {
 execute: opGt,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 SLT: {
 execute: opSlt,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 SGT: {
 execute: opSgt,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 EQ: {
 execute: opEq,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 ISZERO: {
 execute: opIszero,
 constantGas: GasFastestStep,
 minStack: minStack(1, 1),
 maxStack: maxStack(1, 1),
- valid: true,
 },
 AND: {
 execute: opAnd,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 XOR: {
 execute: opXor,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 OR: {
 execute: opOr,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 NOT: {
 execute: opNot,
 constantGas: GasFastestStep,
 minStack: minStack(1, 1),
 maxStack: maxStack(1, 1),
- valid: true,
 },
 BYTE: {
 execute: opByte,
 constantGas: GasFastestStep,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 SHA3: {
 execute: opSha3,
@@ -379,63 +350,54 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
 memorySize: memorySha3,
- valid: true,
 },
 ADDRESS: {
 execute: opAddress,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 BALANCE: {
 execute: opBalance,
 constantGas: params.BalanceGasFrontier,
 minStack: minStack(1, 1),
 maxStack: maxStack(1, 1),
- valid: true,
 },
 BALANCEMC: {
 execute: opBalanceMultiCoin,
 constantGas: params.BalanceGasFrontier,
 minStack: minStack(2, 1),
 maxStack: maxStack(2, 1),
- valid: true,
 },
 ORIGIN: {
 execute: opOrigin,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 CALLER: {
 execute: opCaller,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 CALLVALUE: {
 execute: opCallValue,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 CALLDATALOAD: {
 execute: opCallDataLoad,
 constantGas: GasFastestStep,
 minStack: minStack(1, 1),
 maxStack: maxStack(1, 1),
- valid: true,
 },
 CALLDATASIZE: {
 execute: opCallDataSize,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 CALLDATACOPY: {
 execute: opCallDataCopy,
@@ -444,14 +406,12 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(3, 0),
 maxStack: maxStack(3, 0),
 memorySize: memoryCallDataCopy,
- valid: true,
 },
 CODESIZE: {
 execute: opCodeSize,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 CODECOPY: {
 execute: opCodeCopy,
@@ -460,21 +420,18 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(3, 0),
 maxStack: maxStack(3, 0),
 memorySize: memoryCodeCopy,
- valid: true,
 },
 GASPRICE: {
 execute: opGasprice,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 EXTCODESIZE: {
 execute: opExtCodeSize,
 constantGas: params.ExtcodeSizeGasFrontier,
 minStack: minStack(1, 1),
 maxStack: maxStack(1, 1),
- valid: true,
 },
 EXTCODECOPY: {
 execute: opExtCodeCopy,
@@ -483,56 +440,48 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(4, 0),
 maxStack: maxStack(4, 0),
 memorySize: memoryExtCodeCopy,
- valid: true,
 },
 BLOCKHASH: {
 execute: opBlockhash,
 constantGas: GasExtStep,
 minStack: minStack(1, 1),
 maxStack: maxStack(1, 1),
- valid: true,
 },
 COINBASE: {
 execute: opCoinbase,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 TIMESTAMP: {
 execute: opTimestamp,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 NUMBER: {
 execute: opNumber,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 DIFFICULTY: {
 execute: opDifficulty,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 GASLIMIT: {
 execute: opGasLimit,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 POP: {
 execute: opPop,
 constantGas: GasQuickStep,
 minStack: minStack(1, 0),
 maxStack: maxStack(1, 0),
- valid: true,
 },
 MLOAD: {
 execute: opMload,
@@ -541,7 +490,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(1, 1),
 maxStack: maxStack(1, 1),
 memorySize: memoryMLoad,
- valid: true,
 },
 MSTORE: {
 execute: opMstore,
@@ -550,7 +498,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(2, 0),
 maxStack: maxStack(2, 0),
 memorySize: memoryMStore,
- valid: true,
 },
 MSTORE8: {
 execute: opMstore8,
@@ -559,22 +506,18 @@ func newFrontierInstructionSet() JumpTable {
 memorySize: memoryMStore8,
 minStack: minStack(2, 0),
 maxStack: maxStack(2, 0),
-
- valid: true,
 },
 SLOAD: {
 execute: opSload,
 constantGas: params.SloadGasFrontier,
 minStack: minStack(1, 1),
 maxStack: maxStack(1, 1),
- valid: true,
 },
 SSTORE: {
 execute: opSstore,
 dynamicGas: gasSStore,
 minStack: minStack(2, 0),
 maxStack: maxStack(2, 0),
- valid: true,
 writes: true,
 },
 JUMP: {
@@ -583,7 +526,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(1, 0),
 maxStack: maxStack(1, 0),
 jumps: true,
- valid: true,
 },
 JUMPI: {
 execute: opJumpi,
@@ -591,490 +533,420 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(2, 0),
 maxStack: maxStack(2, 0),
 jumps: true,
- valid: true,
 },
 PC: {
 execute: opPc,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 MSIZE: {
 execute: opMsize,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 GAS: {
 execute: opGas,
 constantGas: GasQuickStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 JUMPDEST: {
 execute: opJumpdest,
 constantGas: params.JumpdestGas,
 minStack: minStack(0, 0),
 maxStack: maxStack(0, 0),
- valid: true,
 },
 EMC: {
 execute: opEMC,
 constantGas: params.EMCGas,
 minStack: minStack(0, 0),
 maxStack: maxStack(0, 0),
- valid: true,
 },
 PUSH1: {
 execute: opPush1,
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH2: {
 execute: makePush(2, 2),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH3: {
 execute: makePush(3, 3),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH4: {
 execute: makePush(4, 4),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH5: {
 execute: makePush(5, 5),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH6: {
 execute: makePush(6, 6),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH7: {
 execute: makePush(7, 7),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH8: {
 execute: makePush(8, 8),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH9: {
 execute: makePush(9, 9),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH10: {
 execute: makePush(10, 10),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH11: {
 execute: makePush(11, 11),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH12: {
 execute: makePush(12, 12),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH13: {
 execute: makePush(13, 13),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH14: {
 execute: makePush(14, 14),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH15: {
 execute: makePush(15, 15),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH16: {
 execute: makePush(16, 16),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH17: {
 execute: makePush(17, 17),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH18: {
 execute: makePush(18, 18),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH19: {
 execute: makePush(19, 19),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH20: {
 execute: makePush(20, 20),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH21: {
 execute: makePush(21, 21),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH22: {
 execute: makePush(22, 22),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH23: {
 execute: makePush(23, 23),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH24: {
 execute: makePush(24, 24),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH25: {
 execute: makePush(25, 25),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH26: {
 execute: makePush(26, 26),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH27: {
 execute: makePush(27, 27),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH28: {
 execute: makePush(28, 28),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH29: {
 execute: makePush(29, 29),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH30: {
 execute: makePush(30, 30),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH31: {
 execute: makePush(31, 31),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 PUSH32: {
 execute: makePush(32, 32),
 constantGas: GasFastestStep,
 minStack: minStack(0, 1),
 maxStack: maxStack(0, 1),
- valid: true,
 },
 DUP1: {
 execute: makeDup(1),
 constantGas: GasFastestStep,
 minStack: minDupStack(1),
 maxStack: maxDupStack(1),
- valid: true,
 },
 DUP2: {
 execute: makeDup(2),
 constantGas: GasFastestStep,
 minStack: minDupStack(2),
 maxStack: maxDupStack(2),
- valid: true,
 },
 DUP3: {
 execute: makeDup(3),
 constantGas: GasFastestStep,
 minStack: minDupStack(3),
 maxStack: maxDupStack(3),
- valid: true,
 },
 DUP4: {
 execute: makeDup(4),
 constantGas: GasFastestStep,
 minStack: minDupStack(4),
 maxStack: maxDupStack(4),
- valid: true,
 },
 DUP5: {
 execute: makeDup(5),
 constantGas: GasFastestStep,
 minStack: minDupStack(5),
 maxStack: maxDupStack(5),
- valid: true,
 },
 DUP6: {
 execute: makeDup(6),
 constantGas: GasFastestStep,
 minStack: minDupStack(6),
 maxStack: maxDupStack(6),
- valid: true,
 },
 DUP7: {
 execute: makeDup(7),
 constantGas: GasFastestStep,
 minStack: minDupStack(7),
 maxStack: maxDupStack(7),
- valid: true,
 },
 DUP8: {
 execute: makeDup(8),
 constantGas: GasFastestStep,
 minStack: minDupStack(8),
 maxStack: maxDupStack(8),
- valid: true,
 },
 DUP9: {
 execute: makeDup(9),
 constantGas: GasFastestStep,
 minStack: minDupStack(9),
 maxStack: maxDupStack(9),
- valid: true,
 },
 DUP10: {
 execute: makeDup(10),
 constantGas: GasFastestStep,
 minStack: minDupStack(10),
 maxStack: maxDupStack(10),
- valid: true,
 },
 DUP11: {
 execute: makeDup(11),
 constantGas: GasFastestStep,
 minStack: minDupStack(11),
 maxStack: maxDupStack(11),
- valid: true,
 },
 DUP12: {
 execute: makeDup(12),
 constantGas: GasFastestStep,
 minStack: minDupStack(12),
 maxStack: maxDupStack(12),
- valid: true,
 },
 DUP13: {
 execute: makeDup(13),
 constantGas: GasFastestStep,
 minStack: minDupStack(13),
 maxStack: maxDupStack(13),
- valid: true,
 },
 DUP14: {
 execute: makeDup(14),
 constantGas: GasFastestStep,
 minStack: minDupStack(14),
 maxStack: maxDupStack(14),
- valid: true,
 },
 DUP15: {
 execute: makeDup(15),
 constantGas: GasFastestStep,
 minStack: minDupStack(15),
 maxStack: maxDupStack(15),
- valid: true,
 },
 DUP16: {
 execute: makeDup(16),
 constantGas: GasFastestStep,
 minStack: minDupStack(16),
 maxStack: maxDupStack(16),
- valid: true,
 },
 SWAP1: {
 execute: makeSwap(1),
 constantGas: GasFastestStep,
 minStack: minSwapStack(2),
 maxStack: maxSwapStack(2),
- valid: true,
 },
 SWAP2: {
 execute: makeSwap(2),
 constantGas: GasFastestStep,
 minStack: minSwapStack(3),
 maxStack: maxSwapStack(3),
- valid: true,
 },
 SWAP3: {
 execute: makeSwap(3),
 constantGas: GasFastestStep,
 minStack: minSwapStack(4),
 maxStack: maxSwapStack(4),
- valid: true,
 },
 SWAP4: {
 execute: makeSwap(4),
 constantGas: GasFastestStep,
 minStack: minSwapStack(5),
 maxStack: maxSwapStack(5),
- valid: true,
 },
 SWAP5: {
 execute: makeSwap(5),
 constantGas: GasFastestStep,
 minStack: minSwapStack(6),
 maxStack: maxSwapStack(6),
- valid: true,
 },
 SWAP6: {
 execute: makeSwap(6),
 constantGas: GasFastestStep,
 minStack: minSwapStack(7),
 maxStack: maxSwapStack(7),
- valid: true,
 },
 SWAP7: {
 execute: makeSwap(7),
 constantGas: GasFastestStep,
 minStack: minSwapStack(8),
 maxStack: maxSwapStack(8),
- valid: true,
 },
 SWAP8: {
 execute: makeSwap(8),
 constantGas: GasFastestStep,
 minStack: minSwapStack(9),
 maxStack: maxSwapStack(9),
- valid: true,
 },
 SWAP9: {
 execute: makeSwap(9),
 constantGas: GasFastestStep,
 minStack: minSwapStack(10),
 maxStack: maxSwapStack(10),
- valid: true,
 },
 SWAP10: {
 execute: makeSwap(10),
 constantGas: GasFastestStep,
 minStack: minSwapStack(11),
 maxStack: maxSwapStack(11),
- valid: true,
 },
 SWAP11: {
 execute: makeSwap(11),
 constantGas: GasFastestStep,
 minStack: minSwapStack(12),
 maxStack: maxSwapStack(12),
- valid: true,
 },
 SWAP12: {
 execute: makeSwap(12),
 constantGas: GasFastestStep,
 minStack: minSwapStack(13),
 maxStack: maxSwapStack(13),
- valid: true,
 },
 SWAP13: {
 execute: makeSwap(13),
 constantGas: GasFastestStep,
 minStack: minSwapStack(14),
 maxStack: maxSwapStack(14),
- valid: true,
 },
 SWAP14: {
 execute: makeSwap(14),
 constantGas: GasFastestStep,
 minStack: minSwapStack(15),
 maxStack: maxSwapStack(15),
- valid: true,
 },
 SWAP15: {
 execute: makeSwap(15),
 constantGas: GasFastestStep,
 minStack: minSwapStack(16),
 maxStack: maxSwapStack(16),
- valid: true,
 },
 SWAP16: {
 execute: makeSwap(16),
 constantGas: GasFastestStep,
 minStack: minSwapStack(17),
 maxStack: maxSwapStack(17),
- valid: true,
 },
 LOG0: {
 execute: makeLog(0),
@@ -1082,7 +954,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(2, 0),
 maxStack: maxStack(2, 0),
 memorySize: memoryLog,
- valid: true,
 writes: true,
 },
 LOG1: {
@@ -1091,7 +962,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(3, 0),
 maxStack: maxStack(3, 0),
 memorySize: memoryLog,
- valid: true,
 writes: true,
 },
 LOG2: {
@@ -1100,7 +970,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(4, 0),
 maxStack: maxStack(4, 0),
 memorySize: memoryLog,
- valid: true,
 writes: true,
 },
 LOG3: {
@@ -1109,7 +978,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(5, 0),
 maxStack: maxStack(5, 0),
 memorySize: memoryLog,
- valid: true,
 writes: true,
 },
 LOG4: {
@@ -1118,7 +986,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(6, 0),
 maxStack: maxStack(6, 0),
 memorySize: memoryLog,
- valid: true,
 writes: true,
 },
 CREATE: {
@@ -1128,7 +995,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(3, 1),
 maxStack: maxStack(3, 1),
 memorySize: memoryCreate,
- valid: true,
 writes: true,
 returns: true,
 },
@@ -1139,7 +1005,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(7, 1),
 maxStack: maxStack(7, 1),
 memorySize: memoryCall,
- valid: true,
 returns: true,
 },
 CALLEX: {
@@ -1149,7 +1014,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(9, 1),
 maxStack: maxStack(9, 1),
 memorySize: memoryCallExpert,
- valid: true,
 returns: true,
 },
 CALLCODE: {
@@ -1159,7 +1023,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(7, 1),
 maxStack: maxStack(7, 1),
 memorySize: memoryCall,
- valid: true,
 returns: true,
 },
 RETURN: {
@@ -1169,7 +1032,6 @@ func newFrontierInstructionSet() JumpTable {
 maxStack: maxStack(2, 0),
 memorySize: memoryReturn,
 halts: true,
- valid: true,
 },
 SELFDESTRUCT: {
 execute: opSuicide,
@@ -1177,7 +1039,6 @@ func newFrontierInstructionSet() JumpTable {
 minStack: minStack(1, 0),
 maxStack: maxStack(1, 0),
 halts: true,
- valid: true,
 writes: true,
 },
 }
diff --git a/core/vm/logger.go b/core/vm/logger.go
index 95143f1..ea5d6f2 100644
--- a/core/vm/logger.go
+++ b/core/vm/logger.go
@@ -18,17 +18,21 @@ package vm
 
 import (
 "encoding/hex"
+ "errors"
 "fmt"
 "io"
 "math/big"
+ "strings"
 "time"
 
 "github.com/ava-labs/coreth/core/types"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/hexutil"
- "github.com/ava-labs/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/common/math"
 )
 
+var errTraceLimitReached = errors.New("the number of logs reached the specified limit")
+
 // Storage represents a contract's storage.
 type Storage map[common.Hash]common.Hash
 
@@ -38,17 +42,17 @@ func (s Storage) Copy() Storage {
 for key, value := range s {
 cpy[key] = value
 }
-
 return cpy
 }
 
 // LogConfig are the configuration options for structured logger the EVM
 type LogConfig struct {
- DisableMemory bool // disable memory capture
- DisableStack bool // disable stack capture
- DisableStorage bool // disable storage capture
- Debug bool // print output during capture end
- Limit int // maximum length of output, but zero means unlimited
+ DisableMemory bool // disable memory capture
+ DisableStack bool // disable stack capture
+ DisableStorage bool // disable storage capture
+ DisableReturnData bool // disable return data capture
+ Debug bool // print output during capture end
+ Limit int // maximum length of output, but zero means unlimited
 }
 
 //go:generate gencodec -type StructLog -field-override structLogMarshaling -out gen_structlog.go
@@ -63,6 +67,8 @@ type StructLog struct {
 Memory []byte `json:"memory"`
 MemorySize int `json:"memSize"`
 Stack []*big.Int `json:"stack"`
+ ReturnStack []uint32 `json:"returnStack"`
+ ReturnData []byte `json:"returnData"`
 Storage map[common.Hash]common.Hash `json:"-"`
 Depth int `json:"depth"`
 RefundCounter uint64 `json:"refund"`
@@ -72,6 +78,7 @@ type StructLog struct {
 // overrides for gencodec
 type structLogMarshaling struct {
 Stack []*math.HexOrDecimal256
+ ReturnStack []math.HexOrDecimal64
 Gas math.HexOrDecimal64
 GasCost math.HexOrDecimal64
 Memory hexutil.Bytes
@@ -98,9 +105,9 @@ func (s *StructLog) ErrorString() string {
 // Note that reference types are actual VM data structures; make copies
 // if you need to retain them beyond the current call.
 type Tracer interface {
- CaptureStart(from common.Address, to common.Address, call bool, input []byte, gas uint64, value *big.Int) error
- CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
- CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
+ CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error
+ CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error
+ CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, contract *Contract, depth int, err error) error
 CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error
 }
 
@@ -112,16 +119,16 @@ type Tracer interface {
 type StructLogger struct {
 cfg LogConfig
 
- logs []StructLog
- changedValues map[common.Address]Storage
- output []byte
- err error
+ storage map[common.Address]Storage
+ logs []StructLog
+ output []byte
+ err error
 }
 
 // NewStructLogger returns a new logger
 func NewStructLogger(cfg *LogConfig) *StructLogger {
 logger := &StructLogger{
- changedValues: make(map[common.Address]Storage),
+ storage: make(map[common.Address]Storage),
 }
 if cfg != nil {
 logger.cfg = *cfg
@@ -136,27 +143,11 @@ func (l *StructLogger) CaptureStart(from common.Address, to common.Address, crea
 
 // CaptureState logs a new structured log message and pushes it out to the environment
 //
-// CaptureState also tracks SSTORE ops to track dirty values.
-func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error {
+// CaptureState also tracks SLOAD/SSTORE ops to track storage change.
+func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error {
 // check if already accumulated the specified number of logs
 if l.cfg.Limit != 0 && l.cfg.Limit <= len(l.logs) {
- return ErrTraceLimitReached
- }
-
- // initialise new changed values storage container for this contract
- // if not present.
- if l.changedValues[contract.Address()] == nil {
- l.changedValues[contract.Address()] = make(Storage)
- }
-
- // capture SSTORE opcodes and determine the changed value and store
- // it in the local storage container.
- if op == SSTORE && stack.len() >= 2 {
- var (
- value = common.BigToHash(stack.data[stack.len()-2])
- address = common.BigToHash(stack.data[stack.len()-1])
- )
- l.changedValues[contract.Address()][address] = value
+ return errTraceLimitReached
 }
 // Copy a snapshot of the current memory state to a new buffer
 var mem []byte
@@ -169,24 +160,54 @@ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost ui
 if !l.cfg.DisableStack {
 stck = make([]*big.Int, len(stack.Data()))
 for i, item := range stack.Data() {
- stck[i] = new(big.Int).Set(item)
+ stck[i] = new(big.Int).Set(item.ToBig())
 }
 }
+ var rstack []uint32
+ if !l.cfg.DisableStack && rStack != nil {
+ rstck := make([]uint32, len(rStack.data))
+ copy(rstck, rStack.data)
+ }
 // Copy a snapshot of the current storage to a new container
 var storage Storage
 if !l.cfg.DisableStorage {
- storage = l.changedValues[contract.Address()].Copy()
+ // initialise new changed values storage container for this contract
+ // if not present.
+ if l.storage[contract.Address()] == nil {
+ l.storage[contract.Address()] = make(Storage)
+ }
+ // capture SLOAD opcodes and record the read entry in the local storage
+ if op == SLOAD && stack.len() >= 1 {
+ var (
+ address = common.Hash(stack.data[stack.len()-1].Bytes32())
+ value = env.StateDB.GetState(contract.Address(), address)
+ )
+ l.storage[contract.Address()][address] = value
+ }
+ // capture SSTORE opcodes and record the written entry in the local storage.
+ if op == SSTORE && stack.len() >= 2 {
+ var (
+ value = common.Hash(stack.data[stack.len()-2].Bytes32())
+ address = common.Hash(stack.data[stack.len()-1].Bytes32())
+ )
+ l.storage[contract.Address()][address] = value
+ }
+ storage = l.storage[contract.Address()].Copy()
+ }
+ var rdata []byte
+ if !l.cfg.DisableReturnData {
+ rdata = make([]byte, len(rData))
+ copy(rdata, rData)
 }
 // create a new snapshot of the EVM.
- log := StructLog{pc, op, gas, cost, mem, memory.Len(), stck, storage, depth, env.StateDB.GetRefund(), err}
-
+ log := StructLog{pc, op, gas, cost, mem, memory.Len(), stck, rstack, rdata, storage, depth, env.StateDB.GetRefund(), err}
 l.logs = append(l.logs, log)
 return nil
 }
 
 // CaptureFault implements the Tracer interface to trace an execution fault
 // while running an opcode.
-func (l *StructLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error {
+func (l *StructLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, contract *Contract, depth int, err error) error {
 return nil
 }
 
@@ -227,6 +248,12 @@ func WriteTrace(writer io.Writer, logs []StructLog) {
 fmt.Fprintf(writer, "%08d %x\n", len(log.Stack)-i-1, math.PaddedBigBytes(log.Stack[i], 32))
 }
 }
+ if len(log.ReturnStack) > 0 {
+ fmt.Fprintln(writer, "ReturnStack:")
+ for i := len(log.Stack) - 1; i >= 0; i-- {
+ fmt.Fprintf(writer, "%08d 0x%x (%d)\n", len(log.Stack)-i-1, log.ReturnStack[i], log.ReturnStack[i])
+ }
+ }
 if len(log.Memory) > 0 {
 fmt.Fprintln(writer, "Memory:")
 fmt.Fprint(writer, hex.Dump(log.Memory))
@@ -237,6 +264,10 @@ func WriteTrace(writer io.Writer, logs []StructLog) {
 fmt.Fprintf(writer, "%x: %x\n", h, item)
 }
 }
+ if len(log.ReturnData) > 0 {
+ fmt.Fprintln(writer, "ReturnData:")
+ fmt.Fprint(writer, hex.Dump(log.ReturnData))
+ }
 fmt.Fprintln(writer)
 }
 }
@@ -254,3 +285,79 @@ func WriteLogs(writer io.Writer, logs []*types.Log) {
 fmt.Fprintln(writer)
 }
 }
+
+type mdLogger struct {
+ out io.Writer
+ cfg *LogConfig
+}
+
+// NewMarkdownLogger creates a logger which outputs information in a format adapted
+// for human readability, and is also a valid markdown table
+func NewMarkdownLogger(cfg *LogConfig, writer io.Writer) *mdLogger {
+ l := &mdLogger{writer, cfg}
+ if l.cfg == nil {
+ l.cfg = &LogConfig{}
+ }
+ return l
+}
+
+func (t *mdLogger) CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error {
+ if !create {
+ fmt.Fprintf(t.out, "From: `%v`\nTo: `%v`\nData: `0x%x`\nGas: `%d`\nValue `%v` wei\n",
+ from.String(), to.String(),
+ input, gas, value)
+ } else {
+ fmt.Fprintf(t.out, "From: `%v`\nCreate at: `%v`\nData: `0x%x`\nGas: `%d`\nValue `%v` wei\n",
+ from.String(), to.String(),
+ input, gas, value)
+ }
+
+ fmt.Fprintf(t.out, `
+| Pc | Op | Cost | Stack | RStack |
+|-------|-------------|------|-----------|-----------|
+`)
+ return nil
+}
+
+func (t *mdLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error {
+ fmt.Fprintf(t.out, "| %4d | %10v | %3d |", pc, op, cost)
+
+ if !t.cfg.DisableStack { // format stack
+ var a []string
+ for _, elem := range stack.data {
+ a = append(a, fmt.Sprintf("%d", elem))
+ }
+ b := fmt.Sprintf("[%v]", strings.Join(a, ","))
+ fmt.Fprintf(t.out, "%10v |", b)
+ }
+ if !t.cfg.DisableStack { // format return stack
+ var a []string
+ for _, elem := range rStack.data {
+ a = append(a, fmt.Sprintf("%2d", elem))
+ }
+ b := fmt.Sprintf("[%v]", strings.Join(a, ","))
+ fmt.Fprintf(t.out, "%10v |", b)
+ }
+ fmt.Fprintln(t.out, "")
+ if err != nil {
+ fmt.Fprintf(t.out, "Error: %v\n", err)
+ }
+ return nil
+}
+
+func (t *mdLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, contract *Contract, depth int, err error) error {
+
+ fmt.Fprintf(t.out, "\nError: at pc=%d, op=%v: %v\n", pc, op, err)
+
+ return nil
+}
+
+func (t *mdLogger) CaptureEnd(output []byte, gasUsed uint64, tm time.Duration, err error) error {
+ fmt.Fprintf(t.out, `
+Output: 0x%x
+Consumed gas: %d
+Error: %v
+`,
+ output, gasUsed, err)
+ return nil
+}
diff --git a/core/vm/logger_json.go b/core/vm/logger_json.go
index 5068343..5f3f2c4 100644
--- a/core/vm/logger_json.go
+++ b/core/vm/logger_json.go
@@ -22,8 +22,8 @@ import (
 "math/big"
 "time"
 
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/math"
 )
 
 type JSONLogger struct {
@@ -46,7 +46,7 @@ func (l *JSONLogger) CaptureStart(from common.Address, to common.Address, create
 }
 
 // CaptureState outputs state information on the logger.
-func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error {
+func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, rData []byte, contract *Contract, depth int, err error) error {
 log := StructLog{
 Pc: pc,
 Op: op,
@@ -62,13 +62,22 @@ func (l *JSONLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint
 log.Memory = memory.Data()
 }
 if !l.cfg.DisableStack {
- log.Stack = stack.Data()
+ //TODO(@holiman) improve this
+ logstack := make([]*big.Int, len(stack.Data()))
+ for i, item := range stack.Data() {
+ logstack[i] = item.ToBig()
+ }
+ log.Stack = logstack
+ log.ReturnStack = rStack.data
+ }
+ if !l.cfg.DisableReturnData {
+ log.ReturnData = rData
 }
 return l.encoder.Encode(log)
 }
 
 // CaptureFault outputs state information on the logger.
-func (l *JSONLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error {
+func (l *JSONLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, rStack *ReturnStack, contract *Contract, depth int, err error) error {
 return nil
 }
 
diff --git a/core/vm/memory.go b/core/vm/memory.go
index 5408707..ba5f848 100644
--- a/core/vm/memory.go
+++ b/core/vm/memory.go
@@ -18,9 +18,8 @@ package vm
 
 import (
 "fmt"
- "math/big"
 
- "github.com/ava-labs/go-ethereum/common/math"
+ "github.com/holiman/uint256"
 )
 
 // Memory implements a simple memory model for the ethereum virtual machine.
@@ -50,7 +49,7 @@ func (m *Memory) Set(offset, size uint64, value []byte) {
 
 // Set32 sets the 32 bytes starting at offset to the value of val, left-padded with zeroes to
 // 32 bytes.
-func (m *Memory) Set32(offset uint64, val *big.Int) {
+func (m *Memory) Set32(offset uint64, val *uint256.Int) {
 // length of store may never be less than offset + size.
 // The store should be resized PRIOR to setting the memory
 if offset+32 > uint64(len(m.store)) {
@@ -59,7 +58,7 @@ func (m *Memory) Set32(offset uint64, val *big.Int) {
 // Zero the memory area
 copy(m.store[offset:offset+32], []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, 0})
 // Fill in relevant bits
- math.ReadBits(val, m.store[offset:offset+32])
+ val.WriteToSlice(m.store[offset:])
 }
 
 // Resize resizes the memory to size
@@ -70,7 +69,7 @@ func (m *Memory) Resize(size uint64) {
 }
 
 // Get returns offset + size as a new slice
-func (m *Memory) Get(offset, size int64) (cpy []byte) {
+func (m *Memory) GetCopy(offset, size int64) (cpy []byte) {
 if size == 0 {
 return nil
 }
diff --git a/core/vm/opcodes.go b/core/vm/opcodes.go
index 1a66ef8..99688b1 100644
--- a/core/vm/opcodes.go
+++ b/core/vm/opcodes.go
@@ -70,7 +70,7 @@ const (
 SHR
 SAR
 
- SHA3 = 0x20
+ SHA3 OpCode = 0x20
 )
 
 // 0x30 range - closure state.
@@ -101,26 +101,27 @@ const (
 NUMBER
 DIFFICULTY
 GASLIMIT
- CHAINID = 0x46
- SELFBALANCE = 0x47
+ CHAINID OpCode = 0x46
+ SELFBALANCE OpCode = 0x47
 )
 
 // 0x50 range - 'storage' and execution.
 const (
- POP OpCode = 0x50 + iota
- MLOAD
- MSTORE
- MSTORE8
- SLOAD
- SSTORE
- JUMP
- JUMPI
- PC
- MSIZE
- GAS
- JUMPDEST
- EMC = 0x5c
- BALANCEMC = 0x5d
+ POP OpCode = 0x50
+ MLOAD OpCode = 0x51
+ MSTORE OpCode = 0x52
+ MSTORE8 OpCode = 0x53
+ SLOAD OpCode = 0x54
+ SSTORE OpCode = 0x55
+ JUMP OpCode = 0x56
+ JUMPI OpCode = 0x57
+ PC OpCode = 0x58
+ MSIZE OpCode = 0x59
+ GAS OpCode = 0x5a
+ JUMPDEST OpCode = 0x5b
+ BEGINSUB OpCode = 0x5c
+ RETURNSUB OpCode = 0x5d
+ JUMPSUB OpCode = 0x5e
 )
 
 // 0x60 range.
@@ -207,6 +208,12 @@ const (
 SWAP
 )
 
+const (
+ BALANCEMC = 0xcd
+ EMC = 0xce
+ CALLEX = 0xcf
+)
+
 // 0xf0 range - closures.
 const (
 CREATE OpCode = 0xf0 + iota
@@ -215,11 +222,9 @@ const (
 RETURN
 DELEGATECALL
 CREATE2
- CALLEX = 0xf6
- STATICCALL = 0xfa
-
- REVERT = 0xfd
- SELFDESTRUCT = 0xff
+ STATICCALL OpCode = 0xfa
+ REVERT OpCode = 0xfd
+ SELFDESTRUCT OpCode = 0xff
 )
 
 // Since the opcodes aren't all in order we can't use a regular slice.
@@ -301,7 +306,10 @@ var opCodeToString = map[OpCode]string{
 MSIZE: "MSIZE",
 GAS: "GAS",
 JUMPDEST: "JUMPDEST",
- EMC: "EMC",
+
+ BEGINSUB: "BEGINSUB",
+ JUMPSUB: "JUMPSUB",
+ RETURNSUB: "RETURNSUB",
 
 // 0x60 range - push.
 PUSH1: "PUSH1",
@@ -379,6 +387,7 @@ var opCodeToString = map[OpCode]string{
 // 0xf0 range.
 CREATE: "CREATE",
 CALL: "CALL",
+ EMC: "EMC",
 CALLEX: "CALLEX",
 RETURN: "RETURN",
 CALLCODE: "CALLCODE",
@@ -396,7 +405,7 @@ var opCodeToString = map[OpCode]string{
 func (op OpCode) String() string {
 str := opCodeToString[op]
 if len(str) == 0 {
- return fmt.Sprintf("Missing opcode 0x%x", int(op))
+ return fmt.Sprintf("opcode 0x%x not defined", int(op))
 }
 
 return str
@@ -469,7 +478,9 @@ var stringToOp = map[string]OpCode{
 "MSIZE": MSIZE,
 "GAS": GAS,
 "JUMPDEST": JUMPDEST,
- "EMC": EMC,
+ "BEGINSUB": BEGINSUB,
+ "RETURNSUB": RETURNSUB,
+ "JUMPSUB": JUMPSUB,
 "PUSH1": PUSH1,
 "PUSH2": PUSH2,
 "PUSH3": PUSH3,
@@ -542,6 +553,7 @@ var stringToOp = map[string]OpCode{
 "CREATE": CREATE,
 "CREATE2": CREATE2,
 "CALL": CALL,
+ "EMC": EMC,
 "CALLEX": CALLEX,
 "RETURN": RETURN,
 "CALLCODE": CALLCODE,
diff --git a/core/vm/stack.go b/core/vm/stack.go
index 4c1b9e8..af27d65 100644
--- a/core/vm/stack.go
+++ b/core/vm/stack.go
@@ -18,36 +18,48 @@ package vm
 
 import (
 "fmt"
- "math/big"
+ "sync"
+
+ "github.com/holiman/uint256"
 )
 
+var stackPool = sync.Pool{
+ New: func() interface{} {
+ return &Stack{data: make([]uint256.Int, 0, 16)}
+ },
+}
+
 // Stack is an object for basic stack operations. Items popped to the stack are
 // expected to be changed and modified. stack does not take care of adding newly
 // initialised objects.
 type Stack struct {
- data []*big.Int
+ data []uint256.Int
 }
 
 func newstack() *Stack {
- return &Stack{data: make([]*big.Int, 0, 1024)}
+ return stackPool.Get().(*Stack)
 }
 
-// Data returns the underlying big.Int array.
-func (st *Stack) Data() []*big.Int {
+func returnStack(s *Stack) {
+ s.data = s.data[:0]
+ stackPool.Put(s)
+}
+
+// Data returns the underlying uint256.Int array.
+func (st *Stack) Data() []uint256.Int {
 return st.data
 }
 
-func (st *Stack) push(d *big.Int) {
+func (st *Stack) push(d *uint256.Int) {
 // NOTE push limit (1024) is checked in baseCheck
- //stackItem := new(big.Int).Set(d)
- //st.data = append(st.data, stackItem)
- st.data = append(st.data, d)
+ st.data = append(st.data, *d)
 }
-func (st *Stack) pushN(ds ...*big.Int) {
+func (st *Stack) pushN(ds ...uint256.Int) {
+ // FIXME: Is there a way to pass args by pointers.
 st.data = append(st.data, ds...)
 }
 
-func (st *Stack) pop() (ret *big.Int) {
+func (st *Stack) pop() (ret uint256.Int) {
 ret = st.data[len(st.data)-1]
 st.data = st.data[:len(st.data)-1]
 return
@@ -61,24 +73,17 @@ func (st *Stack) swap(n int) {
 st.data[st.len()-n], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-n]
 }
 
-func (st *Stack) dup(pool *intPool, n int) {
- st.push(pool.get().Set(st.data[st.len()-n]))
+func (st *Stack) dup(n int) {
+ st.push(&st.data[st.len()-n])
 }
 
-func (st *Stack) peek() *big.Int {
- return st.data[st.len()-1]
+func (st *Stack) peek() *uint256.Int {
+ return &st.data[st.len()-1]
 }
 
 // Back returns the n'th item in stack
-func (st *Stack) Back(n int) *big.Int {
- return st.data[st.len()-n-1]
-}
-
-func (st *Stack) require(n int) error {
- if st.len() < n {
- return fmt.Errorf("stack underflow (%d <=> %d)", len(st.data), n)
- }
- return nil
+func (st *Stack) Back(n int) *uint256.Int {
+ return &st.data[st.len()-n-1]
 }
 
 // Print dumps the content of the stack
@@ -93,3 +98,34 @@ func (st *Stack) Print() {
 }
 fmt.Println("#############")
 }
+
+var rStackPool = sync.Pool{
+ New: func() interface{} {
+ return &ReturnStack{data: make([]uint32, 0, 10)}
+ },
+}
+
+// ReturnStack is an object for basic return stack operations.
+type ReturnStack struct {
+ data []uint32
+}
+
+func newReturnStack() *ReturnStack {
+ return rStackPool.Get().(*ReturnStack)
+}
+
+func returnRStack(rs *ReturnStack) {
+ rs.data = rs.data[:0]
+ rStackPool.Put(rs)
+}
+
+func (st *ReturnStack) push(d uint32) {
+ st.data = append(st.data, d)
+}
+
+// A uint32 is sufficient as for code below 4.2G
+func (st *ReturnStack) pop() (ret uint32) {
+ ret = st.data[len(st.data)-1]
+ st.data = st.data[:len(st.data)-1]
+ return
+}