diff --git a/cmd/devp2p/internal/ethtest/chain_test.go b/cmd/devp2p/internal/ethtest/chain_test.go
index 74a181eede..7f5740e4bc 100644
--- a/cmd/devp2p/internal/ethtest/chain_test.go
+++ b/cmd/devp2p/internal/ethtest/chain_test.go
@@ -27,108 +27,100 @@ import (
"github.com/stretchr/testify/assert"
)
-// TestEthProtocolNegotiation tests whether the test suite
-// can negotiate the highest eth protocol in a status message exchange
+// TestEthProtocolNegotiation checks that version gaps do not create a common capability.
func TestEthProtocolNegotiation(t *testing.T) {
t.Parallel()
- var tests = []struct {
- conn *Conn
- caps []p2p.Cap
- expected uint32
+ for _, test := range []struct {
+ name string
+ local, remote []p2p.Cap
+ ethVersion, snapVersion uint
}{
{
- conn: &Conn{
- ourHighestProtoVersion: 65,
- },
- caps: []p2p.Cap{
- {Name: "eth", Version: 63},
- {Name: "eth", Version: 64},
- {Name: "eth", Version: 65},
- },
- expected: uint32(65),
+ name: "prefer71",
+ local: []p2p.Cap{{Name: "eth", Version: 71}, {Name: "eth", Version: 68}},
+ remote: []p2p.Cap{{Name: "eth", Version: 68}, {Name: "eth", Version: 71}},
+ ethVersion: 71,
},
{
- conn: &Conn{
- ourHighestProtoVersion: 65,
- },
- caps: []p2p.Cap{
- {Name: "eth", Version: 63},
- {Name: "eth", Version: 64},
- {Name: "eth", Version: 65},
- },
- expected: uint32(65),
+ name: "fallback68",
+ local: []p2p.Cap{{Name: "eth", Version: 71}, {Name: "eth", Version: 68}},
+ remote: []p2p.Cap{{Name: "eth", Version: 70}, {Name: "eth", Version: 68}},
+ ethVersion: 68,
},
{
- conn: &Conn{
- ourHighestProtoVersion: 65,
- },
- caps: []p2p.Cap{
- {Name: "eth", Version: 63},
- {Name: "eth", Version: 64},
- {Name: "eth", Version: 65},
- },
- expected: uint32(65),
+ name: "only71",
+ local: []p2p.Cap{{Name: "eth", Version: 71}},
+ remote: []p2p.Cap{{Name: "eth", Version: 70}, {Name: "eth", Version: 71}},
+ ethVersion: 71,
},
{
- conn: &Conn{
- ourHighestProtoVersion: 64,
- },
- caps: []p2p.Cap{
- {Name: "eth", Version: 63},
- {Name: "eth", Version: 64},
- {Name: "eth", Version: 65},
- },
- expected: 64,
+ name: "noCommonVersion",
+ local: []p2p.Cap{{Name: "eth", Version: 71}, {Name: "eth", Version: 68}},
+ remote: []p2p.Cap{{Name: "eth", Version: 70}},
},
{
- conn: &Conn{
- ourHighestProtoVersion: 65,
- },
- caps: []p2p.Cap{
- {Name: "eth", Version: 0},
- {Name: "eth", Version: 89},
- {Name: "eth", Version: 65},
- },
- expected: uint32(65),
+ name: "only71Rejects68",
+ local: []p2p.Cap{{Name: "eth", Version: 71}},
+ remote: []p2p.Cap{{Name: "eth", Version: 68}},
},
{
- conn: &Conn{
- ourHighestProtoVersion: 64,
- },
- caps: []p2p.Cap{
- {Name: "eth", Version: 63},
- {Name: "eth", Version: 64},
- {Name: "wrongProto", Version: 65},
- },
- expected: uint32(64),
+ name: "ignore72",
+ local: []p2p.Cap{{Name: "eth", Version: 71}, {Name: "eth", Version: 68}},
+ remote: []p2p.Cap{{Name: "eth", Version: 72}, {Name: "eth", Version: 68}},
+ ethVersion: 68,
},
{
- conn: &Conn{
- ourHighestProtoVersion: 65,
- },
- caps: []p2p.Cap{
- {Name: "eth", Version: 63},
- {Name: "eth", Version: 64},
- {Name: "wrongProto", Version: 65},
- },
- expected: uint32(64),
+ name: "eth70",
+ local: []p2p.Cap{{Name: "eth", Version: 70}, {Name: "eth", Version: 68}},
+ remote: []p2p.Cap{{Name: "eth", Version: 70}, {Name: "eth", Version: 68}},
+ ethVersion: 70,
},
{
- conn: &Conn{
- ourHighestProtoVersion: eth.ETH70,
- },
- caps: []p2p.Cap{
- {Name: "eth", Version: eth.ETH68},
- {Name: "eth", Version: eth.ETH70},
- },
- expected: eth.ETH70,
+ name: "snap1",
+ local: []p2p.Cap{{Name: "eth", Version: 71}, {Name: "snap", Version: 1}},
+ remote: []p2p.Cap{{Name: "snap", Version: 2}, {Name: "eth", Version: 71}, {Name: "snap", Version: 1}},
+ ethVersion: 71,
+ snapVersion: 1,
},
+ {
+ name: "snap2",
+ local: []p2p.Cap{{Name: "eth", Version: 71}, {Name: "snap", Version: 1}, {Name: "snap", Version: 2}},
+ remote: []p2p.Cap{{Name: "snap", Version: 2}, {Name: "eth", Version: 71}, {Name: "snap", Version: 1}},
+ ethVersion: 71,
+ snapVersion: 2,
+ },
+ {
+ name: "noCommonSnap",
+ local: []p2p.Cap{{Name: "eth", Version: 68}, {Name: "snap", Version: 2}},
+ remote: []p2p.Cap{{Name: "eth", Version: 68}, {Name: "snap", Version: 1}},
+ ethVersion: 68,
+ },
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ conn := &Conn{caps: test.local}
+ conn.negotiateEthProtocol(test.remote)
+ assert.Equal(t, test.ethVersion, conn.negotiatedProtoVersion)
+ assert.Equal(t, test.snapVersion, conn.negotiatedSnapProtoVersion)
+ })
}
+}
- for i, tt := range tests {
- t.Run(strconv.Itoa(i), func(t *testing.T) {
- tt.conn.negotiateEthProtocol(tt.caps)
- assert.Equal(t, tt.expected, uint32(tt.conn.negotiatedProtoVersion))
+func TestProtocolOffsets(t *testing.T) {
+ for _, test := range []struct {
+ version uint
+ length uint64
+ }{
+ {eth.ETH68, 17}, {eth.ETH70, 18}, {eth.ETH71, 20}, {eth.ETH72, 22},
+ } {
+ t.Run(strconv.Itoa(int(test.version)), func(t *testing.T) {
+ conn := &Conn{negotiatedProtoVersion: test.version}
+ assert.Equal(t, uint64(16), conn.protoOffset(ethProto))
+ assert.Equal(t, 16+test.length, conn.protoOffset(snapProto))
+ assert.Equal(t, baseProto, conn.getProto(15))
+ assert.Equal(t, ethProto, conn.getProto(16))
+ assert.Equal(t, ethProto, conn.getProto(15+test.length))
+ assert.Equal(t, snapProto, conn.getProto(16+test.length))
+ assert.Equal(t, snapProto, conn.getProto(25+test.length))
})
}
}
diff --git a/cmd/devp2p/internal/ethtest/conn.go b/cmd/devp2p/internal/ethtest/conn.go
index 5995ff4464..c9fb00e4d7 100644
--- a/cmd/devp2p/internal/ethtest/conn.go
+++ b/cmd/devp2p/internal/ethtest/conn.go
@@ -22,6 +22,7 @@ import (
"fmt"
"net"
"reflect"
+ "slices"
"time"
"github.com/davecgh/go-spew/spew"
@@ -66,15 +67,13 @@ func (s *Suite) dialAs(key *ecdsa.PrivateKey) (*Conn, error) {
conn.Close()
return nil, err
}
- // TODO(BSC): Enable ETH/71 after adapting the handshake and block propagation
- // handlers, and testing sync, v0 blob relay, unavailable BAL responses and
- // ETH/70 and ETH/68 fallback. Update the node's ProtocolVersions, these caps
- // and ourHighestProtoVersion together when enabling it.
conn.caps = []p2p.Cap{
- {Name: "eth", Version: eth.ETH70},
+ {Name: "eth", Version: eth.ETH71},
{Name: "eth", Version: eth.ETH68},
}
- conn.ourHighestProtoVersion = eth.ETH70
+ if s.ethVersion != 0 {
+ conn.caps = []p2p.Cap{{Name: "eth", Version: s.ethVersion}}
+ }
return &conn, nil
}
@@ -111,7 +110,6 @@ func (s *Suite) dialEth71() (*Conn, error) {
return nil, fmt.Errorf("dial failed: %v", err)
}
conn.caps = []p2p.Cap{{Name: "eth", Version: eth.ETH71}}
- conn.ourHighestProtoVersion = eth.ETH71
return conn, nil
}
@@ -121,7 +119,6 @@ type Conn struct {
ourKey *ecdsa.PrivateKey
negotiatedProtoVersion uint
negotiatedSnapProtoVersion uint
- ourHighestProtoVersion uint
ourHighestSnapProtoVersion uint
caps []p2p.Cap
@@ -148,7 +145,7 @@ func (c *Conn) ReadMsg(proto Proto, code uint64, msg any) error {
if err != nil {
return err
}
- if protoOffset(proto)+code == got {
+ if c.protoOffset(proto)+code == got {
return rlp.DecodeBytes(data, msg)
}
}
@@ -161,7 +158,7 @@ func (c *Conn) Write(proto Proto, code uint64, msg any) error {
if err != nil {
return err
}
- _, err = c.Conn.Write(protoOffset(proto)+code, payload)
+ _, err = c.Conn.Write(c.protoOffset(proto)+code, payload)
return err
}
@@ -192,7 +189,7 @@ func (c *Conn) ReadEth() (any, error) {
c.Write(baseProto, pongMsg, []byte{})
continue
}
- if getProto(code) != ethProto {
+ if c.getProto(code) != ethProto {
// Read until eth message.
continue
}
@@ -253,11 +250,20 @@ func (c *Conn) ReadSnap() (any, error) {
if err != nil {
return nil, err
}
- if getProto(code) != snapProto {
+ if code == discMsg {
+ return nil, errDisc
+ }
+ if code == pingMsg {
+ if err := c.Write(baseProto, pongMsg, []byte{}); err != nil {
+ return nil, err
+ }
+ continue
+ }
+ if c.getProto(code) != snapProto {
// Read until snap message.
continue
}
- code -= protoOffset(snapProto)
+ code -= c.protoOffset(snapProto)
var msg any
switch int(code) {
@@ -364,7 +370,7 @@ func (c *Conn) handshake() error {
}
c.negotiateEthProtocol(msg.Caps)
if c.negotiatedProtoVersion == 0 {
- return fmt.Errorf("could not negotiate eth protocol (remote caps: %v, local eth version: %v)", msg.Caps, c.ourHighestProtoVersion)
+ return fmt.Errorf("could not negotiate eth protocol (remote caps: %v, local caps: %v)", msg.Caps, c.caps)
}
// If we require snap, verify that it was negotiated.
if c.ourHighestSnapProtoVersion != c.negotiatedSnapProtoVersion {
@@ -376,25 +382,25 @@ func (c *Conn) handshake() error {
}
}
-// negotiateEthProtocol sets the Conn's eth protocol version to highest
-// advertised capability from peer.
+// negotiateEthProtocol selects the highest capability advertised by both peers.
func (c *Conn) negotiateEthProtocol(caps []p2p.Cap) {
- var highestEthVersion uint
- var highestSnapVersion uint
+ c.negotiatedProtoVersion = 0
+ c.negotiatedSnapProtoVersion = 0
for _, capability := range caps {
+ if !slices.Contains(c.caps, capability) {
+ continue
+ }
switch capability.Name {
case "eth":
- if capability.Version > highestEthVersion && capability.Version <= c.ourHighestProtoVersion {
- highestEthVersion = capability.Version
+ if capability.Version > c.negotiatedProtoVersion {
+ c.negotiatedProtoVersion = capability.Version
}
case "snap":
- if capability.Version > highestSnapVersion && capability.Version <= c.ourHighestSnapProtoVersion {
- highestSnapVersion = capability.Version
+ if capability.Version > c.negotiatedSnapProtoVersion {
+ c.negotiatedSnapProtoVersion = capability.Version
}
}
}
- c.negotiatedProtoVersion = highestEthVersion
- c.negotiatedSnapProtoVersion = highestSnapVersion
}
// statusExchange performs a `Status` message exchange with the given node.
@@ -405,13 +411,16 @@ func (c *Conn) statusExchange(chain *Chain, status *eth.StatusPacket) error {
return fmt.Errorf("failed to read from connection: %w", err)
}
switch code {
- case eth.StatusMsg + protoOffset(ethProto):
+ case eth.StatusMsg + c.protoOffset(ethProto):
if c.negotiatedProtoVersion == 0 {
return errors.New("eth protocol version must be set in Conn")
}
+ if c.negotiatedProtoVersion == eth.ETH68 {
+ return c.statusExchange68(chain, data, status)
+ }
msg := new(eth.StatusPacket)
if err := rlp.DecodeBytes(data, msg); err != nil {
- return fmt.Errorf("error decoding eth/70 status packet: %w", err)
+ return fmt.Errorf("error decoding status packet: %w", err)
}
if uint(msg.ProtocolVersion) != c.negotiatedProtoVersion {
return fmt.Errorf("mismatched eth protocol version: node %d, negotiated %d", msg.ProtocolVersion, c.negotiatedProtoVersion)
@@ -460,3 +469,41 @@ func (c *Conn) statusExchange(chain *Chain, status *eth.StatusPacket) error {
}
}
}
+
+// statusExchange68 retains the BSC UpgradeStatus exchange used by legacy peers.
+func (c *Conn) statusExchange68(chain *Chain, data []byte, status *eth.StatusPacket) error {
+ var remote eth.StatusPacket68
+ if err := rlp.DecodeBytes(data, &remote); err != nil {
+ return fmt.Errorf("error decoding eth/68 status packet: %w", err)
+ }
+ if remote.ProtocolVersion != eth.ETH68 || remote.NetworkID != chain.config.ChainID.Uint64() ||
+ remote.Genesis != chain.blocks[0].Hash() || remote.Head != chain.Head().Hash() ||
+ remote.TD == nil || remote.TD.Cmp(chain.TD()) != 0 || remote.ForkID != chain.ForkID() {
+ return fmt.Errorf("unexpected eth/68 status: %+v", remote)
+ }
+ local := eth.StatusPacket68{
+ ProtocolVersion: eth.ETH68,
+ NetworkID: chain.config.ChainID.Uint64(),
+ TD: chain.TD(),
+ Head: chain.Head().Hash(),
+ Genesis: chain.blocks[0].Hash(),
+ ForkID: chain.ForkID(),
+ }
+ if status != nil {
+ local = eth.StatusPacket68{
+ ProtocolVersion: status.ProtocolVersion, NetworkID: status.NetworkID,
+ TD: status.TD, Head: status.LatestBlockHash, Genesis: status.Genesis, ForkID: status.ForkID,
+ }
+ }
+ if err := c.Write(ethProto, eth.StatusMsg, &local); err != nil {
+ return err
+ }
+ var upgrade eth.UpgradeStatusPacket
+ if err := c.ReadMsg(ethProto, eth.UpgradeStatusMsg, &upgrade); err != nil {
+ return fmt.Errorf("read upgrade status: %w", err)
+ }
+ if _, err := upgrade.GetExtension(); err != nil {
+ return fmt.Errorf("decode upgrade status: %w", err)
+ }
+ return c.Write(ethProto, eth.UpgradeStatusMsg, ð.UpgradeStatusPacket{})
+}
diff --git a/cmd/devp2p/internal/ethtest/protocol.go b/cmd/devp2p/internal/ethtest/protocol.go
index 28c7767726..e93b958fbc 100644
--- a/cmd/devp2p/internal/ethtest/protocol.go
+++ b/cmd/devp2p/internal/ethtest/protocol.go
@@ -17,6 +17,7 @@
package ethtest
import (
+ "github.com/ethereum/go-ethereum/eth/protocols/eth"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/rlp"
)
@@ -32,7 +33,6 @@ const (
// Unexported devp2p protocol lengths from p2p package.
const (
baseProtoLen = 16
- ethProtoLen = 22
// snapProtoLen accommodates snap/2 (EIP-8189) which extends snap/1 with two
// additional message codes (GetBlockAccessLists=0x08, BlockAccessLists=0x09).
// Using 10 is safe for snap/1 connections because the extra codes are simply
@@ -63,10 +63,12 @@ const (
// getProto returns the protocol a certain message code is associated with
// (assuming the negotiated capabilities are exactly {eth,snap})
-func getProto(code uint64) Proto {
- switch {
- case code < baseProtoLen:
+func (c *Conn) getProto(code uint64) Proto {
+ if code < baseProtoLen {
return baseProto
+ }
+ ethProtoLen := c.ethProtoLen()
+ switch {
case code < baseProtoLen+ethProtoLen:
return ethProto
case code < baseProtoLen+ethProtoLen+snapProtoLen:
@@ -78,15 +80,31 @@ func getProto(code uint64) Proto {
// protoOffset will return the offset at which the specified protocol's messages
// begin.
-func protoOffset(proto Proto) uint64 {
+func (c *Conn) protoOffset(proto Proto) uint64 {
switch proto {
case baseProto:
return 0
case ethProto:
return baseProtoLen
case snapProto:
- return baseProtoLen + ethProtoLen
+ return baseProtoLen + c.ethProtoLen()
default:
panic("unhandled protocol")
}
}
+
+// ethProtoLen determines where snap messages begin for the negotiated eth version.
+func (c *Conn) ethProtoLen() uint64 {
+ switch c.negotiatedProtoVersion {
+ case eth.ETH68:
+ return 17
+ case eth.ETH70:
+ return 18
+ case eth.ETH71:
+ return 20
+ case eth.ETH72:
+ return 22
+ default:
+ panic("unsupported eth protocol version")
+ }
+}
diff --git a/cmd/devp2p/internal/ethtest/snap2.go b/cmd/devp2p/internal/ethtest/snap2.go
index 38e09024ee..f79989f6f4 100644
--- a/cmd/devp2p/internal/ethtest/snap2.go
+++ b/cmd/devp2p/internal/ethtest/snap2.go
@@ -17,7 +17,9 @@
package ethtest
import (
+ "errors"
"fmt"
+ "io"
"math/rand"
"github.com/ethereum/go-ethereum/common"
@@ -239,16 +241,15 @@ is removed in snap/2.`)
t.Fatalf("failed to write GetTrieNodes: %v", err)
}
- // We expect either a disconnect or a read error/timeout. We must NOT
- // receive a valid TrieNodes response. Loop a few times to consume any
- // incidental messages the peer might send (e.g. block updates) before
- // deciding.
+ // A timeout is not evidence that the peer rejected the removed message.
for i := 0; i < 5; i++ {
msg, err := conn.ReadSnap()
- if err != nil {
- // Disconnect or read error — the peer rejected the request.
+ if errors.Is(err, errDisc) || errors.Is(err, io.EOF) {
return
}
+ if err != nil {
+ t.Fatalf("expected disconnect after GetTrieNodes, got: %v", err)
+ }
if _, ok := msg.(*snap.TrieNodesPacket); ok {
t.Fatal("peer responded with TrieNodes over snap/2; GetTrieNodes must be unsupported")
}
diff --git a/cmd/devp2p/internal/ethtest/suite.go b/cmd/devp2p/internal/ethtest/suite.go
index c54d9d2c99..a021cbe2dd 100644
--- a/cmd/devp2p/internal/ethtest/suite.go
+++ b/cmd/devp2p/internal/ethtest/suite.go
@@ -21,6 +21,7 @@ import (
"crypto/rand"
"errors"
"fmt"
+ "io"
"os"
"reflect"
"slices"
@@ -48,6 +49,9 @@ type Suite struct {
chain *Chain
engine *EngineClient
+ // ethVersion forces a single eth capability for in-process protocol tests.
+ ethVersion uint
+
// requireAvailableBALs is enabled only by the in-process geth tests.
// External conformance runs must continue accepting unavailable BALs.
requireAvailableBALs bool
@@ -593,8 +597,11 @@ func (s *Suite) TestMaliciousHandshake(t *utesting.T) {
var (
key, _ = crypto.GenerateKey()
pub0 = crypto.FromECDSAPub(&key.PublicKey)[1:]
- version = eth.ProtocolVersions[0]
+ version = s.ethVersion
)
+ if version == 0 {
+ version = eth.ETH71
+ }
handshakes := []*protoHandshake{
{
Version: 5,
@@ -639,24 +646,32 @@ func (s *Suite) TestMaliciousHandshake(t *utesting.T) {
}
defer conn.Close()
- if err := conn.Write(ethProto, handshakeMsg, handshake); err != nil {
+ if err := conn.Write(baseProto, handshakeMsg, handshake); err != nil {
t.Fatalf("could not write to connection: %v", err)
}
- // Check that the peer disconnected
+ // Allow the concurrently sent Hello before the disconnect.
+ disconnected := false
for i := 0; i < 2; i++ {
code, _, err := conn.Read()
+ if errors.Is(err, io.EOF) {
+ disconnected = true
+ break
+ }
if err != nil {
- // Client may have disconnected without sending disconnect msg.
- continue
+ t.Fatalf("expected disconnect after malicious handshake: %v", err)
}
switch code {
case discMsg:
+ disconnected = true
case handshakeMsg:
- // Discard one hello as Hello's are sent concurrently
continue
default:
t.Fatalf("unexpected msg: code %d", code)
}
+ break
+ }
+ if !disconnected {
+ t.Fatal("peer did not reject malicious handshake")
}
}
}
@@ -1145,8 +1160,8 @@ func (s *Suite) TestBlobViolations(t *utesting.T) {
break
}
switch code {
- case protoOffset(ethProto) + eth.NewPooledTransactionHashesMsg,
- protoOffset(ethProto) + eth.GetCellsMsg:
+ case conn.protoOffset(ethProto) + eth.NewPooledTransactionHashesMsg,
+ conn.protoOffset(ethProto) + eth.GetCellsMsg:
continue
default:
t.Fatalf("expected disconnect on blob violation, got msg code: %d", code)
diff --git a/cmd/devp2p/internal/ethtest/suite_test.go b/cmd/devp2p/internal/ethtest/suite_test.go
index 393da50e8f..aa4a83a6be 100644
--- a/cmd/devp2p/internal/ethtest/suite_test.go
+++ b/cmd/devp2p/internal/ethtest/suite_test.go
@@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License
// along with go-ethereum. If not, see .
-package ethtest // TOFIX
+package ethtest
import (
crand "crypto/rand"
@@ -48,15 +48,20 @@ func makeJWTSecret(t *testing.T) (string, [32]byte, error) {
return jwtPath, secret, nil
}
-func TestEthSuite(t *testing.T) {
- testEthSuite(t, ethproto.ETH72)
-}
+var suiteEthVersions = []uint{ethproto.ETH71, ethproto.ETH68}
-func TestEthSuiteEth71(t *testing.T) {
- testEthSuite(t, ethproto.ETH71)
+func TestEthSuite(t *testing.T) {
+ for _, version := range suiteEthVersions {
+ t.Run(fmt.Sprintf("eth%d", version), func(t *testing.T) {
+ testEthSuite(t, version)
+ })
+ }
}
func testEthSuite(t *testing.T, ethVersion uint) {
+ if !slices.Contains(ethproto.ProtocolVersions, ethVersion) {
+ t.Fatalf("required protocol eth/%d is not enabled in the node", ethVersion)
+ }
jwtPath, secret, err := makeJWTSecret(t)
if err != nil {
t.Fatalf("could not make jwt secret: %v", err)
@@ -71,6 +76,7 @@ func testEthSuite(t *testing.T, ethVersion uint) {
if err != nil {
t.Fatalf("could not create new test suite: %v", err)
}
+ // The default capabilities must negotiate the requested version.
conn, err := suite.dialAndPeer(nil)
if err != nil {
t.Fatalf("could not peer with test node: %v", err)
@@ -79,9 +85,24 @@ func testEthSuite(t *testing.T, ethVersion uint) {
if conn.negotiatedProtoVersion != ethVersion {
t.Fatalf("negotiated eth/%d, want eth/%d", conn.negotiatedProtoVersion, ethVersion)
}
+ suite.ethVersion = ethVersion
suite.requireAvailableBALs = true
for _, test := range suite.EthTests() {
t.Run(test.Name, func(t *testing.T) {
+ switch test.Name {
+ case "GetBlockAccessLists":
+ if ethVersion < ethproto.ETH71 {
+ t.Skip("BAL exchange requires eth/71")
+ }
+ case "GetLargeReceipts":
+ if ethVersion < ethproto.ETH70 {
+ t.Skip("receipt pagination requires eth/70")
+ }
+ case "BlobTxAvailabilityFailure", "GetCells", "BlobTxWithInvalidCells":
+ if ethVersion < ethproto.ETH72 {
+ t.Skip("cell exchange requires eth/72")
+ }
+ }
if test.Slow && testing.Short() {
t.Skipf("%s: skipping in -short mode", test.Name)
}
@@ -94,47 +115,45 @@ func testEthSuite(t *testing.T, ethVersion uint) {
}
func TestSnapSuite(t *testing.T) {
- jwtPath, secret, err := makeJWTSecret(t)
- if err != nil {
- t.Fatalf("could not make jwt secret: %v", err)
- }
- geth, err := runGeth("./testdata", jwtPath, ethproto.ETH72)
- if err != nil {
- t.Fatalf("could not run geth: %v", err)
+ for _, version := range suiteEthVersions {
+ t.Run(fmt.Sprintf("eth%d", version), func(t *testing.T) {
+ testSnapSuite(t, version, false)
+ })
}
- defer geth.Close()
+}
- suite, err := NewSuite(geth.Server().Self(), "./testdata", geth.HTTPAuthEndpoint(), common.Bytes2Hex(secret[:]))
- if err != nil {
- t.Fatalf("could not create new test suite: %v", err)
- }
- for _, test := range suite.SnapTests() {
- t.Run(test.Name, func(t *testing.T) {
- result := utesting.RunTests([]utesting.Test{{Name: test.Name, Fn: test.Fn}}, os.Stdout)
- if result[0].Failed {
- t.Fatal()
- }
+func TestSnap2Suite(t *testing.T) {
+ for _, version := range suiteEthVersions {
+ t.Run(fmt.Sprintf("eth%d", version), func(t *testing.T) {
+ testSnapSuite(t, version, true)
})
}
}
-func TestSnap2Suite(t *testing.T) {
+func testSnapSuite(t *testing.T, ethVersion uint, snap2 bool) {
+ if !slices.Contains(ethproto.ProtocolVersions, ethVersion) {
+ t.Fatalf("required protocol eth/%d is not enabled in the node", ethVersion)
+ }
jwtPath, secret, err := makeJWTSecret(t)
if err != nil {
t.Fatalf("could not make jwt secret: %v", err)
}
- geth, err := runGeth("./testdata", jwtPath, ethproto.ETH72)
+ geth, err := runGeth("./testdata", jwtPath, ethVersion)
if err != nil {
t.Fatalf("could not run geth: %v", err)
}
defer geth.Close()
-
suite, err := NewSuite(geth.Server().Self(), "./testdata", geth.HTTPAuthEndpoint(), common.Bytes2Hex(secret[:]))
if err != nil {
t.Fatalf("could not create new test suite: %v", err)
}
- suite.requireAvailableBALs = true
- for _, test := range suite.Snap2Tests() {
+ suite.ethVersion = ethVersion
+ tests := suite.SnapTests()
+ if snap2 {
+ suite.requireAvailableBALs = true
+ tests = suite.Snap2Tests()
+ }
+ for _, test := range tests {
t.Run(test.Name, func(t *testing.T) {
result := utesting.RunTests([]utesting.Test{{Name: test.Name, Fn: test.Fn}}, os.Stdout)
if result[0].Failed {
@@ -168,7 +187,7 @@ func runGeth(dir string, jwtPath string, ethVersion uint) (*node.Node, error) {
return nil, err
}
stack.Server().Protocols = slices.DeleteFunc(stack.Server().Protocols, func(protocol p2p.Protocol) bool {
- return protocol.Name == "eth" && protocol.Version > ethVersion
+ return protocol.Name == "eth" && protocol.Version != ethVersion
})
if err = stack.Start(); err != nil {
stack.Close()
diff --git a/consensus/parlia/bal_test.go b/consensus/parlia/bal_test.go
new file mode 100644
index 0000000000..3047d70cfc
--- /dev/null
+++ b/consensus/parlia/bal_test.go
@@ -0,0 +1,296 @@
+package parlia
+
+import (
+ "context"
+ "math/big"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/accounts"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/consensus"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/rawdb"
+ "github.com/ethereum/go-ethereum/core/state"
+ "github.com/ethereum/go-ethereum/core/systemcontracts"
+ "github.com/ethereum/go-ethereum/core/tracing"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/types/bal"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/params"
+ "github.com/ethereum/go-ethereum/trie"
+ "github.com/ethereum/go-ethereum/triedb"
+ "github.com/holiman/uint256"
+)
+
+func TestParliaSystemTransactionBAL(t *testing.T) {
+ config := *params.ParliaTestChainConfig
+ config.Parlia = ¶ms.ParliaConfig{}
+ config.HaberTime, config.HaberFixTime, config.BohrTime, config.PascalTime = new(uint64), new(uint64), new(uint64), new(uint64)
+ config.PragueTime, config.LorentzTime, config.MaxwellTime, config.FermiTime = new(uint64), new(uint64), new(uint64), new(uint64)
+ config.OsakaTime, config.MendelTime, config.PasteurTime, config.AmsterdamTime = new(uint64), new(uint64), new(uint64), new(uint64)
+ config.BlobScheduleConfig = ¶ms.BlobScheduleConfig{Cancun: params.DefaultCancunBlobConfig, Prague: params.DefaultPragueBlobConfigBSC}
+ validatorContract := common.HexToAddress(systemcontracts.ValidatorContract)
+ slashContract := common.HexToAddress(systemcontracts.SlashContract)
+ code := []byte{byte(vm.PUSH1), 1, byte(vm.PUSH1), 0, byte(vm.SSTORE), byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.LOG0), byte(vm.STOP)}
+ db := rawdb.NewMemoryDatabase()
+ defer db.Close()
+ triedb := triedb.NewDatabase(db, nil)
+ defer triedb.Close()
+ gspec := &core.Genesis{Config: &config, GasLimit: 30_000_000, Alloc: types.GenesisAlloc{
+ consensus.SystemAddress: {Balance: big.NewInt(100)},
+ testAddr: {Balance: big.NewInt(1_000_000_000)},
+ validatorContract: {Code: code, Nonce: 1},
+ slashContract: {Code: code, Nonce: 1},
+ params.HistoryStorageAddress: {Code: params.HistoryStorageCode, Nonce: 1},
+ }}
+ genesis := gspec.MustCommit(db, triedb)
+ engine := New(&config, db, nil, genesis.Hash())
+ defer engine.Close()
+ engine.recentSnaps.Add(genesis.Hash(), newSnapshot(config.Parlia, engine.signatures, 0, genesis.Hash(), []common.Address{testAddr}, nil, nil))
+ chain, err := core.NewBlockChain(db, gspec, engine, core.DefaultConfig())
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer chain.Stop()
+
+ // Start after block one's contract-initialization transactions. The parent
+ // uses the committed prestate, and its snapshot supplies the validator set.
+ parent := genesis.Header()
+ parent.Number = big.NewInt(1)
+ parent.Coinbase, parent.Difficulty = testAddr, diffInTurn
+ rawdb.WriteHeader(db, parent)
+ engine.recentSnaps.Add(parent.Hash(), newSnapshot(config.Parlia, engine.signatures, 1, parent.Hash(), []common.Address{testAddr}, nil, nil))
+ header := &types.Header{
+ ParentHash: parent.Hash(), Number: big.NewInt(2), Time: 3,
+ Difficulty: diffInTurn, Coinbase: testAddr, GasLimit: 30_000_000,
+ BaseFee: common.Big0, ExcessBlobGas: new(uint64), BlobGasUsed: new(uint64),
+ SlotNumber: new(uint64),
+ }
+ *header.SlotNumber = header.Number.Uint64()
+ data, err := engine.validatorSetABI.Pack("deposit", testAddr)
+ if err != nil {
+ t.Fatal(err)
+ }
+ msg := engine.getSystemMessage(testAddr, validatorContract, data, big.NewInt(100))
+ tx := types.MustSignNewTx(testKey, engine.signer, &types.LegacyTx{To: &validatorContract, Gas: msg.GasLimit, GasPrice: common.Big0, Value: big.NewInt(100), Data: data})
+ body := types.Body{Transactions: []*types.Transaction{tx}}
+ block := types.NewBlockWithHeader(header).WithBody(body)
+ sdb, err := state.New(parent.Root, state.NewDatabase(triedb, nil))
+ if err != nil {
+ t.Fatal(err)
+ }
+ res, err := core.NewStateProcessor(chain.HeaderChain()).Process(context.Background(), block, sdb, nil, nil, vm.Config{}, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(res.Receipts) != 1 || res.Receipts[0].TransactionIndex != 0 || res.Receipts[0].TxHash != tx.Hash() || res.GasUsed == 0 {
+ t.Fatalf("unexpected system transaction result: %+v", res)
+ }
+ want := bal.NewConstructionBlockAccessList()
+ want.StorageWrite(0, params.HistoryStorageAddress, common.Hash{31: 1}, parent.Hash())
+ want.BalanceChange(1, consensus.SystemAddress, common.U2560)
+ want.NonceChange(testAddr, 1, 1)
+ want.BalanceChange(1, validatorContract, uint256.NewInt(100))
+ want.StorageWrite(1, validatorContract, common.Hash{}, common.Hash{31: 1})
+ list := want.ToEncodingObj()
+ replayed, _ := state.New(parent.Root, state.NewDatabase(triedb, nil))
+ if err := replayed.ApplyBlockAccessList(list); err != nil {
+ t.Fatal(err)
+ }
+ header.Root = replayed.IntermediateRoot(config.Rules(header.Number, false, header.Time))
+ header.GasUsed = res.GasUsed
+ header.ReceiptHash = types.DeriveSha(res.Receipts, trie.NewStackTrie(nil))
+ header.Bloom = types.MergeBloom(res.Receipts)
+ hash := list.Hash()
+ header.BlockAccessListHash = &hash
+ block = types.NewBlockWithHeader(header).WithBody(body)
+ if err := core.NewBlockValidator(&config, chain).ValidateState(block, sdb, res, false); err != nil {
+ t.Fatalf("Parlia execution differs from the expected BAL and post-state: %v", err)
+ }
+ engine.Authorize(testAddr, nil, func(_ accounts.Account, tx *types.Transaction, _ *big.Int) (*types.Transaction, error) {
+ return types.SignTx(tx, engine.signer, testKey)
+ })
+ t.Run("missing-bal", func(t *testing.T) {
+ for _, lists := range [][]*bal.ConstructionBlockAccessList{nil, {nil}} {
+ for _, packing := range []bool{false, true} {
+ sdb, err := state.New(parent.Root, state.NewDatabase(triedb, nil))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if packing {
+ _, _, err = engine.FinalizeAndAssembleBidBlock(chain, types.CopyHeader(header), sdb, &types.Body{}, nil, nil, lists...)
+ } else {
+ _, _, err = core.AssembleBlock(engine, chain, types.CopyHeader(header), sdb, &types.Body{}, nil, lists...)
+ }
+ if err == nil {
+ t.Fatal("assembled Amsterdam block without input BAL")
+ }
+ if sdb.GetNonce(testAddr) != 0 || sdb.GetBalance(consensus.SystemAddress).Uint64() != 100 {
+ t.Fatal("missing BAL changed finalization state")
+ }
+ }
+ }
+ })
+ for _, tc := range []struct {
+ name string
+ packing bool
+ user bool
+ traced bool
+ empty bool
+ slash bool
+ }{
+ {name: "signed"},
+ {name: "packing", packing: true},
+ {name: "user-and-system", user: true},
+ {name: "traced", traced: true},
+ {name: "no-system-transactions", empty: true},
+ {name: "multiple-system-transactions", slash: true},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ parent := types.CopyHeader(parent)
+ if tc.empty {
+ sdb, err := state.New(parent.Root, state.NewDatabase(triedb, nil))
+ if err != nil {
+ t.Fatal(err)
+ }
+ sdb.SetBalance(consensus.SystemAddress, common.U2560, tracing.BalanceChangeUnspecified)
+ parent.Root, err = sdb.Commit(config.Rules(parent.Number, false, parent.Time), parent.Number.Uint64())
+ if err != nil {
+ t.Fatal(err)
+ }
+ rawdb.WriteHeader(db, parent)
+ }
+ validators := []common.Address{testAddr}
+ if tc.slash {
+ validators = append(validators, common.HexToAddress("0x1234"))
+ }
+ engine.recentSnaps.Add(parent.Hash(), newSnapshot(config.Parlia, engine.signatures, 1, parent.Hash(), validators, nil, nil))
+ newState := func() *state.StateDB {
+ sdb, err := state.New(parent.Root, state.NewDatabase(triedb, nil))
+ if err != nil {
+ t.Fatal(err)
+ }
+ return sdb
+ }
+ miningState := newState()
+ miningHeader := types.CopyHeader(header)
+ miningHeader.ParentHash = parent.Hash()
+ miningHeader.GasUsed = 0
+ miningHeader.Bloom = types.Bloom{}
+ if tc.slash {
+ miningHeader.Difficulty = diffNoTurn
+ }
+ miningHeader.BlockAccessListHash = nil
+ var hooks *tracing.Hooks
+ var changes int
+ if tc.traced {
+ hooks = &tracing.Hooks{OnBalanceChange: func(common.Address, *big.Int, *big.Int, tracing.BalanceChangeReason) { changes++ }}
+ }
+ preEVM := vm.NewEVM(core.NewEVMBlockContext(miningHeader, chain, nil), miningState, &config, vm.Config{})
+ defer preEVM.Release()
+ list := core.PreExecution(context.Background(), nil, parent, &config, preEVM, header.Number, header.Time)
+ body := &types.Body{}
+ var receipts []*types.Receipt
+ if tc.user {
+ tx := types.MustSignNewTx(testKey, types.MakeSigner(&config, header.Number, header.Time), &types.LegacyTx{
+ To: &validatorContract, Gas: 100_000, GasPrice: common.Big1,
+ })
+ miningState.SetTxContext(tx.Hash(), 0, 1)
+ gp := core.NewGasPool(header.GasLimit)
+ receipt, txBAL, err := core.ApplyTransaction(context.Background(), preEVM, gp, miningState, miningHeader, tx)
+ if err != nil {
+ t.Fatal(err)
+ }
+ list.Merge(txBAL)
+ miningHeader.GasUsed = gp.Used()
+ body.Transactions = append(body.Transactions, tx)
+ receipts = append(receipts, receipt)
+ }
+ var produced *types.Block
+ var err error
+ if tc.packing {
+ produced, receipts, err = engine.FinalizeAndAssembleBidBlock(chain, miningHeader, miningState, body, receipts, hooks, list)
+ } else if tc.traced {
+ produced, receipts, err = engine.FinalizeAndAssemble(chain, miningHeader, miningState, body, receipts, hooks, list)
+ } else {
+ produced, receipts, err = core.AssembleBlock(engine, chain, miningHeader, miningState, body, receipts, list)
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ if produced.AccessList() == nil || produced.BlockAccessListHash() == nil || produced.AccessList().Hash() != *produced.BlockAccessListHash() {
+ t.Fatal("missing or inconsistent block access list")
+ }
+ if err := produced.AccessList().Validate(produced.GasLimit(), len(produced.Transactions())); err != nil {
+ t.Fatal(err)
+ }
+ if !tc.user && !tc.empty && !tc.slash && produced.AccessList().Hash() != hash {
+ t.Fatal("assembled BAL differs from expected system changes")
+ }
+ if tc.empty && len(produced.Transactions()) != 0 {
+ t.Fatal("empty reward balance produced a system transaction")
+ }
+ if tc.slash {
+ if len(produced.Transactions()) != 2 || list.Accounts[testAddr].NonceChanges[1] != 1 || list.Accounts[testAddr].NonceChanges[2] != 2 {
+ t.Fatal("system transaction indices do not follow block order")
+ }
+ }
+ if miningState.TxIndex() != len(produced.Transactions()) {
+ t.Fatal("post-execution did not follow system transactions")
+ }
+ if tc.traced && changes == 0 {
+ t.Fatal("finalization bypassed state tracing")
+ }
+ // Signing the packing template changes transaction hashes, not BAL indices or state.
+ if tc.packing {
+ body := produced.Body()
+ body.Transactions = append([]*types.Transaction(nil), body.Transactions...)
+ for i, tx := range body.Transactions {
+ body.Transactions[i], err = engine.SignSystemTx(tx, config.ChainID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ }
+ produced = types.NewBlock(produced.Header(), body, receipts, trie.NewStackTrie(nil)).WithAccessListUnsafe(produced.AccessList())
+ }
+ imported := newState()
+ res, err := core.NewStateProcessor(chain.HeaderChain()).Process(context.Background(), produced, imported, nil, nil, vm.Config{Tracer: hooks}, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := core.NewBlockValidator(&config, chain).ValidateState(produced, imported, res, false); err != nil {
+ t.Fatalf("independent import: %v", err)
+ }
+ for i, receipt := range res.Receipts {
+ if receipt.TxHash != produced.Transactions()[i].Hash() || receipt.TransactionIndex != uint(i) {
+ t.Fatal("imported receipt has an incorrect transaction index or hash")
+ }
+ if receipt.GasUsed != receipts[i].GasUsed || receipt.CumulativeGasUsed != receipts[i].CumulativeGasUsed || len(receipt.Logs) != len(receipts[i].Logs) {
+ t.Fatal("imported receipt differs from assembly")
+ }
+ for j, log := range receipt.Logs {
+ if log.Index != receipts[i].Logs[j].Index || log.TxIndex != uint(i) || log.TxHash != receipt.TxHash || log.BlockHash != produced.Hash() {
+ t.Fatal("imported log metadata does not follow block order")
+ }
+ }
+ }
+ applied := newState()
+ if err := applied.ApplyBlockAccessList(produced.AccessList()); err != nil {
+ t.Fatal(err)
+ }
+ if root := applied.IntermediateRoot(config.Rules(header.Number, false, header.Time)); root != produced.Root() {
+ t.Fatalf("BAL replay root %s differs from produced root %s", root, produced.Root())
+ }
+ for _, sdb := range []*state.StateDB{imported, applied} {
+ for _, addr := range []common.Address{testAddr, validatorContract, consensus.SystemAddress} {
+ if sdb.GetBalance(addr).Cmp(miningState.GetBalance(addr)) != 0 || sdb.GetNonce(addr) != miningState.GetNonce(addr) {
+ t.Fatalf("account state mismatch at %s", addr)
+ }
+ }
+ if sdb.GetState(validatorContract, common.Hash{}) != miningState.GetState(validatorContract, common.Hash{}) {
+ t.Fatal("system contract storage mismatch")
+ }
+ }
+ })
+ }
+}
diff --git a/consensus/parlia/bid_block.go b/consensus/parlia/bid_block.go
index 6fc6a7beca..108be94884 100644
--- a/consensus/parlia/bid_block.go
+++ b/consensus/parlia/bid_block.go
@@ -18,6 +18,7 @@ import (
"github.com/ethereum/go-ethereum/core/systemcontracts"
"github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/types/bal"
buildertypes "github.com/ethereum/go-ethereum/core/types/builder"
"github.com/ethereum/go-ethereum/internal/ethapi"
"github.com/ethereum/go-ethereum/rpc"
@@ -48,12 +49,8 @@ func (p *Parlia) PrepareForBidBlock(chain consensus.ChainHeaderReader, header *t
// FinalizeAndAssembleBidBlock assembles a BidBlock with unsigned system txs.
func (p *Parlia) FinalizeAndAssembleBidBlock(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB,
- body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks) (*types.Block, []*types.Receipt, error) {
- block, receipts, err := p.finalizeAndAssemble(chain, header, state, body, receipts, tracer, systemTxPacking)
- if err != nil {
- return nil, nil, err
- }
- return block, receipts, nil
+ body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks, blockAccessLists ...*bal.ConstructionBlockAccessList) (*types.Block, []*types.Receipt, error) {
+ return p.finalizeAndAssemble(chain, header, state, body, receipts, tracer, systemTxPacking, blockAccessLists...)
}
// SignSystemTx signs a BidBlock system tx with the validator key.
diff --git a/consensus/parlia/parlia.go b/consensus/parlia/parlia.go
index 212a98c0a7..013334de5f 100644
--- a/consensus/parlia/parlia.go
+++ b/consensus/parlia/parlia.go
@@ -36,6 +36,7 @@ import (
"github.com/ethereum/go-ethereum/core/systemcontracts"
"github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/types/bal"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethdb"
@@ -686,6 +687,9 @@ func (p *Parlia) VerifyUnsealedHeader(chain consensus.ChainHeaderReader, header
if header.SlotNumber == nil {
return errors.New("header has nil SlotNumber after Amsterdam")
}
+ if *header.SlotNumber != number {
+ return fmt.Errorf("invalid SlotNumber: have %d, want %d", *header.SlotNumber, number)
+ }
}
// All basic checks passed, verify cascading fields
@@ -1541,13 +1545,25 @@ const (
)
func (p *Parlia) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB,
- body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks) (*types.Block, []*types.Receipt, error) {
- return p.finalizeAndAssemble(chain, header, state, body, receipts, tracer, systemTxMining)
+ body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks, blockAccessLists ...*bal.ConstructionBlockAccessList) (*types.Block, []*types.Receipt, error) {
+ return p.finalizeAndAssemble(chain, header, state, body, receipts, tracer, systemTxMining, blockAccessLists...)
}
-func (p *Parlia) finalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB,
- body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks, mode systemTxMode) (*types.Block, []*types.Receipt, error) {
- // No block rewards in PoA, so the state remains as is and uncles are dropped
+func (p *Parlia) finalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, statedb *state.StateDB,
+ body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks, mode systemTxMode, blockAccessLists ...*bal.ConstructionBlockAccessList) (*types.Block, []*types.Receipt, error) {
+ var accessList *bal.ConstructionBlockAccessList
+ var tracingState vm.StateDB = statedb
+ var finalizationState vm.StateDB = statedb
+ if p.chainConfig.IsAmsterdam(header.Number, header.Time) {
+ if len(blockAccessLists) != 1 || blockAccessLists[0] == nil {
+ return nil, nil, errors.New("missing block access list for Amsterdam assembly")
+ }
+ accessList = blockAccessLists[0]
+ if tracer != nil {
+ tracingState = state.NewHookedState(statedb, tracer)
+ }
+ finalizationState = core.NewSystemTxStateDB(tracingState, accessList)
+ }
cx := chainContext{ChainHeaderReader: chain, parlia: p}
if body.Transactions == nil {
@@ -1562,17 +1578,17 @@ func (p *Parlia) finalizeAndAssemble(chain consensus.ChainHeaderReader, header *
return nil, nil, errors.New("parent not found")
}
- systemcontracts.TryUpdateBuildInSystemContract(p.chainConfig, header.Number, parent.Time, header.Time, state, false)
+ systemcontracts.TryUpdateBuildInSystemContract(p.chainConfig, header.Number, parent.Time, header.Time, finalizationState, false)
if p.chainConfig.IsOnFeynman(header.Number, parent.Time, header.Time) {
- err := p.initializeFeynmanContract(state, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer)
+ err := p.initializeFeynmanContract(finalizationState, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer)
if err != nil {
return nil, nil, fmt.Errorf("init feynman contract failed: %v", err)
}
}
if header.Number.Cmp(common.Big1) == 0 {
- err := p.initContract(state, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer)
+ err := p.initContract(finalizationState, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer)
if err != nil {
return nil, nil, errors.New("init contract failed")
}
@@ -1596,20 +1612,20 @@ func (p *Parlia) finalizeAndAssemble(chain consensus.ChainHeaderReader, header *
}
}
if !signedRecently {
- err = p.slash(spoiledVal, state, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer)
+ err = p.slash(spoiledVal, finalizationState, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer)
if err != nil {
log.Error("slash validator failed", "block hash", header.Hash(), "address", spoiledVal)
}
}
}
- err := p.distributeIncoming(header.Coinbase, state, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer)
+ err := p.distributeIncoming(header.Coinbase, finalizationState, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer)
if err != nil {
return nil, nil, err
}
if p.chainConfig.IsPlato(header.Number) {
- if err := p.distributeFinalityReward(chain, state, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer); err != nil {
+ if err := p.distributeFinalityReward(chain, finalizationState, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer); err != nil {
return nil, nil, err
}
}
@@ -1618,23 +1634,43 @@ func (p *Parlia) finalizeAndAssemble(chain consensus.ChainHeaderReader, header *
if p.chainConfig.IsFeynman(header.Number, header.Time) && isBreatheBlock(parent.Time, header.Time) {
// we should avoid update validators in the Feynman upgrade block
if !p.chainConfig.IsOnFeynman(header.Number, parent.Time, header.Time) {
- if err := p.updateValidatorSetV2(state, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer); err != nil {
+ if err := p.updateValidatorSetV2(finalizationState, header, cx, &body.Transactions, &receipts, nil, &header.GasUsed, mode, tracer); err != nil {
return nil, nil, err
}
}
}
+ if p.chainConfig.IsAmsterdam(header.Number, header.Time) {
+ var allLogs []*types.Log
+ for _, receipt := range receipts {
+ allLogs = append(allLogs, receipt.Logs...)
+ }
+ evm := vm.NewEVM(core.NewEVMBlockContext(header, cx, nil), tracingState, p.chainConfig, vm.Config{Tracer: tracer})
+ _, postBAL, err := core.PostExecution(context.Background(), p.chainConfig, header.Number, header.Time, allLogs, body.Withdrawals, evm, uint32(len(body.Transactions)+1))
+ evm.Release()
+ if err != nil {
+ return nil, nil, err
+ }
+ accessList.Merge(postBAL)
+ }
// should not happen. Once happen, stop the node is better than broadcast the block
if header.GasLimit < header.GasUsed {
return nil, nil, errors.New("gas consumption of system txs exceed the gas limit")
}
header.UncleHash = types.EmptyUncleHash
+ if accessList != nil {
+ header.Root = statedb.IntermediateRoot(chain.Config().Rules(header.Number, false, header.Time))
+ list := accessList.ToEncodingObj()
+ hash := list.Hash()
+ header.BlockAccessListHash = &hash
+ return types.NewBlock(header, body, receipts, trie.NewStackTrie(nil)).WithAccessListUnsafe(list), receipts, nil
+ }
var blk *types.Block
var rootHash common.Hash
wg := sync.WaitGroup{}
wg.Add(2)
go func() {
- rootHash = state.IntermediateRoot(chain.Config().Rules(header.Number, false, header.Time))
+ rootHash = statedb.IntermediateRoot(chain.Config().Rules(header.Number, false, header.Time))
wg.Done()
}()
go func() {
diff --git a/consensus/parlia/parlia_test.go b/consensus/parlia/parlia_test.go
index b5f67e6d23..a345334bf7 100644
--- a/consensus/parlia/parlia_test.go
+++ b/consensus/parlia/parlia_test.go
@@ -24,6 +24,7 @@ import (
"github.com/ethereum/go-ethereum/core/systemcontracts"
"github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/types/bal"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto/kzg4844"
@@ -1458,7 +1459,7 @@ func (c *mockParlia) Finalize(chain consensus.ChainHeaderReader, header *types.H
return
}
-func (c *mockParlia) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks) (*types.Block, []*types.Receipt, error) {
+func (c *mockParlia) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks, _ ...*bal.ConstructionBlockAccessList) (*types.Block, []*types.Receipt, error) {
// Finalize block
c.Finalize(chain, header, state, body, nil, nil, nil, tracer)
@@ -1472,3 +1473,44 @@ func (c *mockParlia) FinalizeAndAssemble(chain consensus.ChainHeaderReader, head
func (c *mockParlia) CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, parent *types.Header) *big.Int {
return big.NewInt(1)
}
+
+func TestVerifyHeaderAmsterdamSlotNumber(t *testing.T) {
+ fork := uint64(3)
+ cfg := ¶ms.ChainConfig{ChainID: big.NewInt(56), Parlia: ¶ms.ParliaConfig{}, LondonBlock: big.NewInt(0), AmsterdamTime: &fork}
+ parent := &types.Header{Number: big.NewInt(0), GasLimit: 30_000_000, Time: 1, BaseFee: big.NewInt(0)}
+ chain := &finalizedHeaderChain{cfg: cfg, byHash: map[common.Hash]*types.Header{parent.Hash(): parent}}
+ engine := New(cfg, nil, nil, parent.Hash())
+ engine.recentSnaps.Add(parent.Hash(), newSnapshot(cfg.Parlia, engine.signatures, 0, parent.Hash(), []common.Address{testAddr}, nil, nil))
+ slot := uint64(1)
+ balHash := types.EmptyBlockAccessListHash
+ header := &types.Header{ParentHash: parent.Hash(), Number: big.NewInt(1), Coinbase: testAddr,
+ UncleHash: types.EmptyUncleHash, Difficulty: new(big.Int).Set(diffInTurn), GasLimit: parent.GasLimit,
+ Time: 4, Extra: make([]byte, extraVanity+extraSeal), BaseFee: big.NewInt(0),
+ SlotNumber: &slot, BlockAccessListHash: &balHash}
+ seal := types.SealHash(header, cfg.ChainID)
+ sig, err := crypto.Sign(seal[:], testKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+ copy(header.Extra[len(header.Extra)-extraSeal:], sig)
+ if err := engine.VerifyHeader(chain, header); err != nil {
+ t.Fatalf("valid slot rejected: %v", err)
+ }
+ for _, invalidSlot := range []uint64{0, 2, ^uint64(0)} {
+ invalid := types.CopyHeader(header)
+ invalid.SlotNumber = &invalidSlot
+ if types.SealHash(invalid, cfg.ChainID) != seal {
+ t.Fatal("slot changed seal hash")
+ }
+ if err := engine.VerifyHeader(chain, invalid); err == nil || !strings.HasPrefix(err.Error(), "invalid SlotNumber") {
+ t.Fatalf("slot %d: expected rejection, got %v", invalidSlot, err)
+ }
+ if err := engine.VerifyUnsealedHeader(chain, invalid, nil); err == nil {
+ t.Fatalf("unsealed slot %d accepted", invalidSlot)
+ }
+ }
+ header.SlotNumber = nil
+ if err := engine.VerifyHeader(chain, header); err == nil {
+ t.Fatal("nil slot accepted")
+ }
+}
diff --git a/core/blockchain_test.go b/core/blockchain_test.go
index ecfa377af1..15f73ec4eb 100644
--- a/core/blockchain_test.go
+++ b/core/blockchain_test.go
@@ -46,6 +46,7 @@ import (
"github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/types/bal"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/core/vm/program"
"github.com/ethereum/go-ethereum/crypto"
@@ -4105,6 +4106,8 @@ type mockParlia struct {
consensus.Engine
}
+var _ blockAssembler = (*mockParlia)(nil)
+
func (c *mockParlia) Author(header *types.Header) (common.Address, error) {
return header.Coinbase, nil
}
@@ -4135,7 +4138,7 @@ func (c *mockParlia) Finalize(chain consensus.ChainHeaderReader, header *types.H
return
}
-func (c *mockParlia) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks) (*types.Block, []*types.Receipt, error) {
+func (c *mockParlia) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks, _ ...*bal.ConstructionBlockAccessList) (*types.Block, []*types.Receipt, error) {
// Finalize block
c.Finalize(chain, header, state, body, nil, nil, nil, tracer)
diff --git a/core/chain_makers.go b/core/chain_makers.go
index 68aa3a0267..f4fdde9a38 100644
--- a/core/chain_makers.go
+++ b/core/chain_makers.go
@@ -125,7 +125,7 @@ func (b *BlockGen) addTx(bc *BlockChain, vmConfig vm.Config, tx *types.Transacti
evm = vm.NewEVM(blockContext, b.statedb, b.cm.config, vmConfig)
)
laneType := b.lane.Classify(tx)
- usedBefore := b.gasPool.Used()
+ usedBefore := b.gasPool.Snapshot()
b.statedb.SetTxContext(tx.Hash(), len(b.txs), uint32(len(b.txs)+1))
receipt, bal, err := ApplyTransaction(context.Background(), evm, b.gasPool, b.statedb, b.header, tx)
if err != nil {
@@ -338,6 +338,9 @@ func (b *BlockGen) ConsensusLayerRequests() [][]byte {
}
func (b *BlockGen) collectRequests(readonly bool) (requests [][]byte, bal *bal.ConstructionBlockAccessList) {
+ if b.cm.config.IsInBSC() {
+ return nil, nil
+ }
statedb := b.statedb
if readonly {
// The system contracts clear themselves on a system-initiated read.
@@ -478,8 +481,13 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
panic(fmt.Sprintf("failed to assemble block: %v", err))
}
+ // Empty generated blocks have no transaction gas pool.
+ if b.gasPool == nil {
+ b.gasPool = NewGasPool(b.header.GasLimit)
+ }
+
// The same self-check the miner runs.
- if err := b.lane.Verify(block.GasUsed()); err != nil {
+ if err := b.lane.Verify(block.GasUsed(), b.gasPool); err != nil {
panic(fmt.Sprintf("payment lane check failed: %v", err))
}
if config.IsCancun(block.Number(), block.Time()) {
@@ -603,7 +611,9 @@ func (cm *chainMaker) makeHeader(parent *types.Block, engine consensus.Engine) *
}
if cm.config.IsAmsterdam(header.Number, header.Time) {
var slot uint64
- if parentHeader.SlotNumber != nil {
+ if cm.config.IsInBSC() {
+ slot = header.Number.Uint64()
+ } else if parentHeader.SlotNumber != nil {
slot = *parentHeader.SlotNumber + 1
}
header.SlotNumber = &slot
diff --git a/core/chain_makers_test.go b/core/chain_makers_test.go
index 7f8f4b933e..3fe780a4b8 100644
--- a/core/chain_makers_test.go
+++ b/core/chain_makers_test.go
@@ -251,3 +251,35 @@ func ExampleGenerateChain() {
// balance of addr2: 10000
// balance of addr3: 19687500000000001000
}
+
+func TestChainMakerSlotNumber(t *testing.T) {
+ slot := func(v uint64) *uint64 { return &v }
+ for _, test := range []struct {
+ name string
+ bsc bool
+ parentTime uint64
+ parentSlot *uint64
+ want *uint64
+ }{
+ {name: "bsc-before-fork", bsc: true, parentTime: 1},
+ {name: "bsc-first-fork", bsc: true, parentTime: 10, want: slot(101)},
+ {name: "bsc-next", bsc: true, parentTime: 20, parentSlot: slot(100), want: slot(101)},
+ {name: "eth-first-fork", parentTime: 10, want: slot(0)},
+ {name: "eth-next", parentTime: 20, parentSlot: slot(500), want: slot(501)},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ fork := uint64(20)
+ cfg := ¶ms.ChainConfig{LondonBlock: big.NewInt(0), AmsterdamTime: &fork}
+ if test.bsc {
+ cfg.Parlia = ¶ms.ParliaConfig{}
+ }
+ parent := types.NewBlockWithHeader(&types.Header{Number: big.NewInt(100), Time: test.parentTime,
+ GasLimit: 30_000_000, Difficulty: big.NewInt(2), BaseFee: big.NewInt(0), SlotNumber: test.parentSlot})
+ engine := ethash.NewFaker()
+ header := newChainMaker(parent, cfg, engine).makeHeader(parent, engine)
+ if !reflect.DeepEqual(header.SlotNumber, test.want) {
+ t.Fatalf("slot: have %v, want %v", header.SlotNumber, test.want)
+ }
+ })
+ }
+}
diff --git a/core/gaspool.go b/core/gaspool.go
index ec5aa38ba9..dcf0c54bf8 100644
--- a/core/gaspool.go
+++ b/core/gaspool.go
@@ -38,6 +38,10 @@ type GasPool struct {
// the larger of the two.
cumulativeExecution uint64
cumulativeState uint64
+
+ // Local reservations leave room for transactions appended later.
+ reservedExecution uint64
+ reservedState uint64
}
// NewGasPool initializes the gasPool with the given amount.
@@ -70,15 +74,35 @@ func (gp *GasPool) CheckGasLegacy(amount uint64) error {
// the worst-case execution contribution must fit in the execution dimension and
// the worst-case state contribution must fit in the state dimension
func (gp *GasPool) CheckGasAmsterdam(executionReservation, stateReservation uint64) error {
- if gp.initial-gp.cumulativeExecution < executionReservation {
+ if gp.initial-gp.cumulativeExecution-gp.reservedExecution < executionReservation {
return ErrGasLimitReached
}
- if gp.initial-gp.cumulativeState < stateReservation {
+ if gp.initial-gp.cumulativeState-gp.reservedState < stateReservation {
return ErrGasLimitReached
}
return nil
}
+// ReserveGasAmsterdam leaves room for a later transaction without charging gas used.
+func (gp *GasPool) ReserveGasAmsterdam(execution, state uint64) error {
+ if err := gp.CheckGasAmsterdam(execution, state); err != nil {
+ return err
+ }
+ gp.reservedExecution += execution
+ gp.reservedState += state
+ return nil
+}
+
+// ReleaseGasAmsterdam returns a reservation without changing cumulative gas used.
+func (gp *GasPool) ReleaseGasAmsterdam(execution, state uint64) error {
+ if execution > gp.reservedExecution || state > gp.reservedState {
+ return fmt.Errorf("gas reservation underflow: execution %d, state %d", execution, state)
+ }
+ gp.reservedExecution -= execution
+ gp.reservedState -= state
+ return nil
+}
+
// ChargeGasLegacy adds the refunded gas back to the pool and updates
// the cumulative gas usage accordingly. Used before Amsterdam.
func (gp *GasPool) ChargeGasLegacy(returned uint64, gasUsed uint64) error {
@@ -101,7 +125,7 @@ func (gp *GasPool) ChargeGasAmsterdam(txExecution, txState, receiptGasUsed uint6
cumulativeExecution := gp.cumulativeExecution + txExecution
cumulativeState := gp.cumulativeState + txState
blockUsed := max(cumulativeExecution, cumulativeState)
- if gp.initial < blockUsed {
+ if gp.initial-gp.reservedExecution < cumulativeExecution || gp.initial-gp.reservedState < cumulativeState {
return fmt.Errorf("%w: block gas overflow: initial %d, used %d (execution: %d, state: %d)",
ErrGasLimitReached, gp.initial, blockUsed, cumulativeExecution, cumulativeState)
}
@@ -119,8 +143,8 @@ func (gp *GasPool) Available(amsterdam bool) uint64 {
if !amsterdam {
return gp.remaining
}
- exec := gp.initial - gp.cumulativeExecution
- state := gp.initial - gp.cumulativeState
+ exec := gp.initial - gp.cumulativeExecution - gp.reservedExecution
+ state := gp.initial - gp.cumulativeState - gp.reservedState
if exec >= params.MaxTxGas {
return state
}
@@ -166,6 +190,8 @@ func (gp *GasPool) Snapshot() *GasPool {
cumulativeUsed: gp.cumulativeUsed,
cumulativeExecution: gp.cumulativeExecution,
cumulativeState: gp.cumulativeState,
+ reservedExecution: gp.reservedExecution,
+ reservedState: gp.reservedState,
}
}
@@ -176,6 +202,8 @@ func (gp *GasPool) Set(other *GasPool) {
gp.cumulativeUsed = other.cumulativeUsed
gp.cumulativeExecution = other.cumulativeExecution
gp.cumulativeState = other.cumulativeState
+ gp.reservedExecution = other.reservedExecution
+ gp.reservedState = other.reservedState
}
func (gp *GasPool) String() string {
diff --git a/core/gaspool_test.go b/core/gaspool_test.go
index 67b5aa8ea1..d3a1cae50b 100644
--- a/core/gaspool_test.go
+++ b/core/gaspool_test.go
@@ -17,6 +17,9 @@
package core
import (
+ "errors"
+ "fmt"
+ "math"
"testing"
"github.com/ethereum/go-ethereum/params"
@@ -72,3 +75,64 @@ func TestGasPoolAvailable(t *testing.T) {
}
}
}
+
+func TestGasPoolAmsterdamReservation(t *testing.T) {
+ const limit uint64 = 60_000_000
+ for _, gas := range []uint64{25_000, 300_000, params.MaxTxGas + 1, 30_000_000} {
+ t.Run(fmt.Sprint(gas), func(t *testing.T) {
+ gp := NewGasPool(limit)
+ execution, state := min(gas, params.MaxTxGas), gas
+ if err := gp.ReserveGasAmsterdam(execution, state); err != nil {
+ t.Fatal(err)
+ }
+ if gp.Used() != 0 || gp.CumulativeUsed() != 0 {
+ t.Fatal("reservation counted as consumption")
+ }
+ if gp.Available(false) != limit {
+ t.Fatal("reservation changed legacy budget")
+ }
+ for _, usage := range [][2]uint64{{limit - execution + 1, 0}, {0, limit - state + 1}} {
+ if err := gp.ChargeGasAmsterdam(usage[0], usage[1], 1); !errors.Is(err, ErrGasLimitReached) {
+ t.Fatalf("reserved budget consumed: %v", err)
+ }
+ }
+ before := gp.Snapshot()
+ if err := gp.ReserveGasAmsterdam(math.MaxUint64, 0); !errors.Is(err, ErrGasLimitReached) {
+ t.Fatal(err)
+ }
+ if *gp != *before {
+ t.Fatal("failed reservation changed pool")
+ }
+ if err := gp.ReleaseGasAmsterdam(execution+1, state); err == nil {
+ t.Fatal("invalid release succeeded")
+ }
+ if *gp != *before {
+ t.Fatal("failed release changed pool")
+ }
+ gp.Set(NewGasPool(limit))
+ gp.Set(before)
+ if err := gp.ChargeGasAmsterdam(limit-execution, limit-state, 123); err != nil {
+ t.Fatal(err)
+ }
+ if gp.Available(true) != 0 {
+ t.Fatal("reserved capacity exposed")
+ }
+ consumed := gp.Snapshot()
+ if err := gp.ReleaseGasAmsterdam(execution, state); err != nil {
+ t.Fatal(err)
+ }
+ if gp.Used() != consumed.Used() || gp.CumulativeUsed() != 123 {
+ t.Fatal("release changed consumption")
+ }
+ if err := gp.CheckGasAmsterdam(execution, state); err != nil {
+ t.Fatalf("payment does not fit: %v", err)
+ }
+ if err := gp.ChargeGasAmsterdam(execution, state, 456); err != nil {
+ t.Fatal(err)
+ }
+ if gp.CumulativeExecution() != limit || gp.CumulativeState() != limit || gp.CumulativeUsed() != 579 {
+ t.Fatal("incorrect cumulative accounting")
+ }
+ })
+ }
+}
diff --git a/core/payment_lane.go b/core/payment_lane.go
index e3c03dde36..e383e217be 100644
--- a/core/payment_lane.go
+++ b/core/payment_lane.go
@@ -3,6 +3,7 @@ package core
import (
"errors"
"fmt"
+ "math/bits"
"github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/core/paymentlane"
@@ -35,10 +36,13 @@ func laneReject(err error) error {
// LaneState is one block's lane: the quota derived from the parent post-state, plus the payment
// total accumulated as the block executes.
type LaneState struct {
- Budget paymentlane.Budget
- classifier *paymentlane.Classifier
- state laneStateDB
- gasLimit uint64
+ Budget paymentlane.Budget // quota and pre-Amsterdam usage
+ classifier *paymentlane.Classifier
+ state laneStateDB
+ gasLimit uint64
+ amsterdam bool
+ paymentExecution uint64
+ paymentState uint64
}
// laneStateDB is the live state: what the classifier reads, and whether reading it worked.
@@ -62,6 +66,7 @@ func ResolveLaneState(config *params.ChainConfig, engine consensus.Engine, paren
classifier: meta.NewClassifier(systemTxOracle(engine, header), statedb),
state: statedb,
gasLimit: header.GasLimit,
+ amsterdam: config.IsAmsterdam(header.Number, header.Time),
}, nil
}
@@ -87,27 +92,81 @@ func (ls *LaneState) Classify(tx *types.Transaction) paymentlane.LaneType {
return ls.classifier.Classify(tx)
}
-// RecordUsedFrom books the gas the pool consumed since usedBefore.
-func (ls *LaneState) RecordUsedFrom(laneType paymentlane.LaneType, gp *GasPool, usedBefore uint64) {
- if used := gp.Used(); ls.On() && used > usedBefore {
- ls.Budget.RecordUsed(laneType, used-usedBefore)
+// RecordUsedFrom books payment resources consumed since the pool snapshot.
+func (ls *LaneState) RecordUsedFrom(laneType paymentlane.LaneType, gp, before *GasPool) {
+ if !ls.On() || laneType != paymentlane.PaymentLane {
+ return
+ }
+ if !ls.amsterdam {
+ if used, previous := gp.Used(), before.Used(); used > previous {
+ ls.Budget.RecordUsed(laneType, used-previous)
+ }
+ return
+ }
+ execution, state := gp.CumulativeExecution(), gp.CumulativeState()
+ if execution < before.CumulativeExecution() || state < before.CumulativeState() {
+ return
+ }
+ ls.paymentExecution += execution - before.CumulativeExecution()
+ ls.paymentState += state - before.CumulativeState()
+}
+
+func (ls *LaneState) idle() (execution, state uint64) {
+ budget := ls.Budget
+ if !ls.amsterdam {
+ idle := budget.IdleLane()
+ return idle, idle
+ }
+ budget.PaymentLaneUsed = ls.paymentExecution
+ execution = budget.IdleLane()
+ budget.PaymentLaneUsed = ls.paymentState
+ return execution, budget.IdleLane()
+}
+
+// PaymentGasUsed returns the larger payment resource total after Amsterdam.
+func (ls *LaneState) PaymentGasUsed() uint64 {
+ if ls.amsterdam {
+ return max(ls.paymentExecution, ls.paymentState)
}
+ return ls.Budget.PaymentLaneUsed
}
-// Admits takes shared as the shared remainder, i.e. gasPool.Gas().
-func (ls *LaneState) Admits(shared uint64, laneType paymentlane.LaneType, txGasLimit uint64) bool {
+// IdleGas reports the larger unused reservation; validation checks both dimensions.
+func (ls *LaneState) IdleGas() uint64 {
+ execution, state := ls.idle()
+ return max(execution, state)
+}
+
+// Admits leaves each resource's unused payment quota available for payments.
+func (ls *LaneState) Admits(gp *GasPool, laneType paymentlane.LaneType, txGasLimit uint64) bool {
if !ls.On() {
return true
}
- return ls.Budget.Admits(shared, laneType, txGasLimit)
+ if !ls.amsterdam {
+ return ls.Budget.Admits(gp.Available(false), laneType, txGasLimit)
+ }
+ var idleExecution, idleState uint64
+ if laneType != paymentlane.PaymentLane {
+ idleExecution, idleState = ls.idle()
+ }
+ execution, executionCarry := bits.Add64(min(txGasLimit, params.MaxTxGas), idleExecution, 0)
+ state, stateCarry := bits.Add64(txGasLimit, idleState, 0)
+ return executionCarry == 0 && stateCarry == 0 && gp.CheckGasAmsterdam(execution, state) == nil
}
-// VerifyPackedBid is the bid path's verdict on an environment it did not pack itself.
-func (ls *LaneState) VerifyPackedBid(shared uint64) error {
+// VerifyPackedBid checks that the re-executed bid leaves the unused quota in the pool.
+func (ls *LaneState) VerifyPackedBid(gp *GasPool) error {
if !ls.On() {
return nil
}
- if idle := ls.Budget.IdleLane(); idle > shared {
+ if ls.amsterdam {
+ execution, state := ls.idle()
+ if err := gp.CheckGasAmsterdam(execution, state); err != nil {
+ return fmt.Errorf("%w: idle payment quota (execution %d, state %d): %v", paymentlane.ErrViolated, execution, state, err)
+ }
+ return nil
+ }
+ if idle, shared := ls.Budget.IdleLane(), gp.Available(false); idle > shared {
return fmt.Errorf("%w: idle lane %d exceeds the %d gas left in the pool", paymentlane.ErrViolated, idle, shared)
}
return nil
@@ -117,14 +176,32 @@ func (ls *LaneState) VerifyPackedBid(shared uint64) error {
// verdict alike. A failed state read is the local fault it is, not the peer's: StateDB answers
// such a read with the zero code hash - which classifies as payment - and holds the error until
// Commit, after every verdict here.
-func (ls *LaneState) Verify(totalGasUsed uint64) error {
+func (ls *LaneState) Verify(totalGasUsed uint64, gp *GasPool) error {
if !ls.On() {
return nil
}
if err := ls.state.Error(); err != nil {
return fmt.Errorf("%w: %w", paymentlane.ErrStateUnavailable, err)
}
- return ls.Budget.Verify(ls.gasLimit, totalGasUsed)
+ if !ls.amsterdam {
+ return ls.Budget.Verify(ls.gasLimit, totalGasUsed)
+ }
+ userGas := max(gp.CumulativeExecution(), gp.CumulativeState())
+ if totalGasUsed < userGas || totalGasUsed > ls.gasLimit {
+ return fmt.Errorf("%w: total gas %d user gas %d limit %d", paymentlane.ErrViolated, totalGasUsed, userGas, ls.gasLimit)
+ }
+ // Parlia adds system gas after the user pool's maximum, so it reduces both budgets.
+ limit := ls.gasLimit - (totalGasUsed - userGas)
+ budget := ls.Budget
+ budget.PaymentLaneUsed = ls.paymentExecution
+ if err := budget.Verify(limit, gp.CumulativeExecution()); err != nil {
+ return fmt.Errorf("execution: %w", err)
+ }
+ budget.PaymentLaneUsed = ls.paymentState
+ if err := budget.Verify(limit, gp.CumulativeState()); err != nil {
+ return fmt.Errorf("state: %w", err)
+ }
+ return nil
}
func (ls *LaneState) recordImported() {
@@ -132,6 +209,6 @@ func (ls *LaneState) recordImported() {
return
}
paymentLaneImportedQuotaGauge.Update(int64(ls.Budget.PaymentLaneQuota))
- paymentLaneImportedGasUsedGauge.Update(int64(ls.Budget.PaymentLaneUsed))
- paymentLaneImportedIdleGauge.Update(int64(ls.Budget.IdleLane()))
+ paymentLaneImportedGasUsedGauge.Update(int64(ls.PaymentGasUsed()))
+ paymentLaneImportedIdleGauge.Update(int64(ls.IdleGas()))
}
diff --git a/core/payment_lane_test.go b/core/payment_lane_test.go
index dc8081d4c6..96d70102bb 100644
--- a/core/payment_lane_test.go
+++ b/core/payment_lane_test.go
@@ -4,6 +4,7 @@ import (
"crypto/ecdsa"
"encoding/hex"
"errors"
+ "math"
"math/big"
"strings"
"testing"
@@ -14,7 +15,9 @@ import (
"github.com/ethereum/go-ethereum/core/paymentlane"
"github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/core/systemcontracts/jenner"
+ "github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
@@ -83,7 +86,7 @@ func recordLanes(into map[uint64]laneRecord, gen func(int, *BlockGen)) func(int,
into[b.header.Number.Uint64()] = laneRecord{
on: b.lane.On(),
quota: b.lane.Budget.PaymentLaneQuota,
- paymentGas: b.lane.Budget.PaymentLaneUsed,
+ paymentGas: b.lane.PaymentGasUsed(),
}
}
}
@@ -291,12 +294,12 @@ func TestPaymentLaneVerifyPackedBidChecksTheIdleQuota(t *testing.T) {
ls := &LaneState{classifier: paymentlane.NewClassifier(paymentlane.NoSystemTxs, liveState{}, nil), state: liveState{}}
ls.Budget.PaymentLaneQuota = 100
- require.NoError(t, ls.VerifyPackedBid(100), "a quota that exactly fits is the accepting case")
- require.ErrorIs(t, ls.VerifyPackedBid(99), paymentlane.ErrViolated,
+ require.NoError(t, ls.VerifyPackedBid(NewGasPool(100)), "a quota that exactly fits is the accepting case")
+ require.ErrorIs(t, ls.VerifyPackedBid(NewGasPool(99)), paymentlane.ErrViolated,
"a bid that leaves less than the idle quota must be rejected")
ls.Budget.PaymentLaneUsed = 40
- require.NoError(t, ls.VerifyPackedBid(60), "payment gas already booked shrinks the idle quota one for one")
+ require.NoError(t, ls.VerifyPackedBid(NewGasPool(60)), "payment gas already booked shrinks the idle quota one for one")
}
// TestPaymentLaneReportsAFailedReadAsLocal pins the error category, not the rejection: a failed
@@ -312,7 +315,7 @@ func TestPaymentLaneReportsAFailedReadAsLocal(t *testing.T) {
gasLimit: laneTestGasLimit,
}
- err := ls.Verify(params.TxGas)
+ err := ls.Verify(params.TxGas, NewGasPool(laneTestGasLimit))
require.ErrorIs(t, err, paymentlane.ErrStateUnavailable, "a failed read is this node's fault, not the block's")
require.ErrorIs(t, err, broken, "the cause has to survive for whoever reads the log")
require.NotErrorIs(t, err, paymentlane.ErrViolated, "calling a good block invalid is what costs peers")
@@ -389,7 +392,7 @@ func TestRecordUsedFromIgnoresARolledBackPool(t *testing.T) {
snapshot := *gp
require.NoError(t, gp.CheckGasLegacy(100))
require.NoError(t, gp.ChargeGasLegacy(0, 100))
- usedBefore := gp.Used()
+ usedBefore := gp.Snapshot()
require.NoError(t, gp.CheckGasLegacy(40))
require.NoError(t, gp.ChargeGasLegacy(0, 40))
@@ -397,7 +400,261 @@ func TestRecordUsedFromIgnoresARolledBackPool(t *testing.T) {
require.EqualValues(t, 40, ls.Budget.PaymentLaneUsed)
*gp = snapshot // back past usedBefore
- require.Less(t, gp.Used(), usedBefore)
+ require.Less(t, gp.Used(), usedBefore.Used())
ls.RecordUsedFrom(paymentlane.PaymentLane, gp, usedBefore)
require.EqualValues(t, 40, ls.Budget.PaymentLaneUsed, "a rolled-back pool books nothing rather than wrapping")
}
+
+func TestPaymentLaneAmsterdamAccounting(t *testing.T) {
+ for name, paymentFirst := range map[string]bool{"payment-first": true, "general-first": false} {
+ t.Run(name, func(t *testing.T) {
+ ls := &LaneState{amsterdam: true, Budget: paymentlane.Budget{PaymentLaneQuota: 10}, classifier: paymentlane.NewClassifier(paymentlane.NoSystemTxs, liveState{}, nil), state: liveState{}}
+ gp := NewGasPool(100)
+ charge := func(lane paymentlane.LaneType, e, s uint64) {
+ before := gp.Snapshot()
+ require.NoError(t, gp.ChargeGasAmsterdam(e, s, 1))
+ ls.RecordUsedFrom(lane, gp, before)
+ }
+ if paymentFirst {
+ charge(paymentlane.PaymentLane, 3, 7)
+ charge(paymentlane.GeneralLane, 6, 0)
+ } else {
+ charge(paymentlane.GeneralLane, 6, 0)
+ charge(paymentlane.PaymentLane, 3, 7)
+ }
+ require.EqualValues(t, 3, ls.paymentExecution)
+ require.EqualValues(t, 7, ls.paymentState)
+ require.EqualValues(t, 7, ls.PaymentGasUsed())
+ e, s := ls.idle()
+ require.EqualValues(t, 7, e)
+ require.EqualValues(t, 3, s)
+ before := gp.Snapshot()
+ require.NoError(t, gp.ChargeGasAmsterdam(4, 2, 1))
+ gp.Set(before)
+ ls.RecordUsedFrom(paymentlane.PaymentLane, gp, before)
+ require.EqualValues(t, 3, ls.paymentExecution)
+ require.EqualValues(t, 7, ls.paymentState)
+ gp.Set(NewGasPool(100)) // Rewind past the snapshot as well.
+ ls.RecordUsedFrom(paymentlane.PaymentLane, gp, before)
+ require.EqualValues(t, 3, ls.paymentExecution)
+ require.EqualValues(t, 7, ls.paymentState)
+ })
+ }
+}
+
+func TestPaymentLaneAmsterdamAdmission(t *testing.T) {
+ const limit, quota = 55_000_000, 2_750_000
+ ls := &LaneState{amsterdam: true, Budget: paymentlane.Budget{PaymentLaneQuota: quota}, classifier: paymentlane.NewClassifier(paymentlane.NoSystemTxs, liveState{}, nil)}
+ gp := NewGasPool(limit)
+ require.NoError(t, gp.ChargeGasAmsterdam(38_000_000, quota, 0))
+ require.Greater(t, gp.Available(true), uint64(30_000_000))
+ require.False(t, ls.Admits(gp, paymentlane.GeneralLane, 30_000_000), "execution must retain its idle quota despite ample state budget")
+ require.True(t, ls.Admits(gp, paymentlane.PaymentLane, 30_000_000))
+ ls.paymentState = quota
+ require.False(t, ls.Admits(gp, paymentlane.GeneralLane, 30_000_000), "state payments cannot release execution quota")
+ ls.paymentState = 0
+ ls.paymentExecution = quota
+ require.True(t, ls.Admits(gp, paymentlane.GeneralLane, 30_000_000))
+ gp = NewGasPool(limit)
+ require.NoError(t, gp.ChargeGasAmsterdam(quota, 38_000_000, 0))
+ require.False(t, ls.Admits(gp, paymentlane.GeneralLane, 15_000_000), "execution payments cannot release state quota")
+ require.True(t, ls.Admits(gp, paymentlane.PaymentLane, 15_000_000))
+ ls.paymentState = quota
+ require.True(t, ls.Admits(gp, paymentlane.GeneralLane, 15_000_000))
+ for _, statePaid := range []uint64{0, math.MaxUint64} {
+ ls.Budget.PaymentLaneQuota = math.MaxUint64
+ ls.paymentExecution = 0
+ ls.paymentState = statePaid
+ require.False(t, ls.Admits(NewGasPool(math.MaxUint64), paymentlane.GeneralLane, 1), "each reservation addition must reject overflow")
+ }
+}
+
+func TestPaymentLaneAmsterdamVerify(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ e, s, pe, ps, system uint64
+ reject bool
+ }{
+ {"empty", 0, 0, 0, 0, 0, false},
+ {"execution boundary", 90, 0, 0, 0, 0, false},
+ {"state boundary", 0, 90, 0, 0, 0, false},
+ {"one dimension cannot pay both quotas", 100, 100, 5, 5, 0, true},
+ {"both quotas paid", 100, 100, 10, 10, 0, false},
+ {"payments can exceed quota", 100, 100, 100, 100, 0, false},
+ {"execution system boundary", 85, 0, 0, 0, 5, false},
+ {"execution system overflow", 85, 0, 0, 0, 6, true},
+ {"state system boundary", 0, 85, 0, 0, 5, false},
+ {"state system overflow", 0, 85, 0, 0, 6, true},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ ls := &LaneState{amsterdam: true, gasLimit: 100, Budget: paymentlane.Budget{PaymentLaneQuota: 10}, paymentExecution: tc.pe, paymentState: tc.ps, classifier: paymentlane.NewClassifier(paymentlane.NoSystemTxs, liveState{}, nil), state: liveState{}}
+ gp := NewGasPool(100)
+ require.NoError(t, gp.ChargeGasAmsterdam(tc.e, tc.s, 0))
+ err := ls.Verify(gp.Used()+tc.system, gp)
+ if tc.reject {
+ require.ErrorIs(t, err, paymentlane.ErrViolated)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+ ls := &LaneState{amsterdam: true, gasLimit: 100, classifier: paymentlane.NewClassifier(paymentlane.NoSystemTxs, liveState{}, nil), state: liveState{}}
+ gp := NewGasPool(100)
+ require.NoError(t, gp.ChargeGasAmsterdam(50, 0, 0))
+ require.ErrorIs(t, ls.Verify(49, gp), paymentlane.ErrViolated)
+ require.ErrorIs(t, ls.Verify(101, gp), paymentlane.ErrViolated)
+}
+
+func TestPaymentLaneAmsterdamPackedBid(t *testing.T) {
+ ls := &LaneState{amsterdam: true, Budget: paymentlane.Budget{PaymentLaneQuota: 20_000_000}, classifier: paymentlane.NewClassifier(paymentlane.NoSystemTxs, liveState{}, nil)}
+ gp := NewGasPool(400_000_000)
+ require.NoError(t, gp.ChargeGasAmsterdam(382_000_000, 20_000_000, 0))
+ require.EqualValues(t, 380_000_000, gp.Available(true))
+ require.ErrorIs(t, ls.VerifyPackedBid(gp), paymentlane.ErrViolated)
+ ls.paymentState = 20_000_000
+ require.ErrorIs(t, ls.VerifyPackedBid(gp), paymentlane.ErrViolated)
+ ls.paymentExecution = 2_000_000
+ require.NoError(t, ls.VerifyPackedBid(gp))
+ gp = NewGasPool(400_000_000)
+ require.NoError(t, gp.ChargeGasAmsterdam(20_000_000, 382_000_000, 0))
+ ls.paymentExecution = 20_000_000
+ ls.paymentState = 0
+ require.ErrorIs(t, ls.VerifyPackedBid(gp), paymentlane.ErrViolated)
+ ls.paymentState = 2_000_000
+ require.NoError(t, ls.VerifyPackedBid(gp))
+}
+
+// laneTestEngine omits PoW rewards from the BSC chain fixture.
+type laneTestEngine struct{ consensus.Engine }
+
+func (*laneTestEngine) Finalize(consensus.ChainHeaderReader, *types.Header, vm.StateDB, *types.Body, *[]*types.Receipt, *[]*types.Transaction, *uint64, *tracing.Hooks) error {
+ return nil
+}
+
+func TestPaymentLaneAmsterdamImport(t *testing.T) {
+ config, gspec, key := laneGenesis(t, laneTestGasLimit)
+ amsterdam := uint64(25)
+ config.AmsterdamTime = &amsterdam
+ require.NoError(t, config.CheckConfigForkOrder())
+ clear, revert, create, floor, refill := common.Address{0xc1}, common.Address{0xc2}, common.Address{0xc3}, common.Address{0xc4}, common.Address{0xc5}
+ gspec.Alloc[clear] = types.Account{Code: common.FromHex("0x600060005500"), Storage: map[common.Hash]common.Hash{{}: common.BigToHash(common.Big1)}, Balance: common.Big0}
+ gspec.Alloc[revert] = types.Account{Code: common.FromHex("0x600060005560006000fd"), Storage: map[common.Hash]common.Hash{{}: common.BigToHash(common.Big1)}, Balance: common.Big0}
+ gspec.Alloc[create] = types.Account{Code: common.FromHex("0x600160005500"), Balance: common.Big0}
+ gspec.Alloc[floor] = types.Account{Code: common.FromHex("0x600160005500"), Balance: common.Big0}
+ token := common.Address{0: 0xca, 1: 0x52, 19: 1}
+ gspec.Alloc[token] = types.Account{Code: vm.CAS20MarkerCode, Balance: common.Big0}
+ gspec.Alloc[refill] = types.Account{Code: common.FromHex("0x6001600055600060005500"), Balance: common.Big0}
+ contract := gspec.Alloc[paymentlane.ContractAddress]
+ contract.Storage = map[common.Hash]common.Hash{laneListedLenSlot: common.BigToHash(big.NewInt(6))}
+ for i, addr := range []common.Address{clear, revert, create, floor, refill, token} {
+ contract.Storage[enumerableSetSlot(laneListedLenSlot, uint64(i))] = common.BytesToHash(addr[:])
+ }
+ gspec.Alloc[paymentlane.ContractAddress] = contract
+ engine := &laneTestEngine{ethash.NewFullFaker()}
+ signer := types.LatestSigner(config)
+ approve := func(spender common.Address) []byte {
+ data := append(common.FromHex("0x095ea7b3"), common.LeftPadBytes(spender[:], 32)...)
+ return append(data, common.LeftPadBytes([]byte{1}, 32)...)
+ }
+ _, blocks, _ := GenerateChainWithGenesis(gspec, engine, 4, func(i int, b *BlockGen) {
+ if i == 1 {
+ require.True(t, config.IsJenner(b.header.Number, b.header.Time))
+ require.False(t, config.IsAmsterdam(b.header.Number, b.header.Time))
+ b.AddTx(key.sign(t, signer, 0, token, common.Big0, 400_000, approve(common.Address{0xcd})))
+ require.EqualValues(t, types.ReceiptStatusSuccessful, b.receipts[0].Status)
+ require.Zero(t, b.gasPool.CumulativeState())
+ return
+ }
+ if i != 2 {
+ return
+ }
+ require.True(t, b.lane.On())
+ require.True(t, b.lane.amsterdam)
+ b.SetCoinbase(common.Address{})
+ for n, addr := range []common.Address{clear, revert, create, floor, refill, token} {
+ before := b.gasPool.Snapshot()
+ var data []byte
+ if n == 3 {
+ data = make([]byte, 4096)
+ } else if n == 5 {
+ data = approve(common.Address{0xcc})
+ }
+ b.AddTx(key.sign(t, signer, uint64(n+1), addr, common.Big0, 400_000, data))
+ receipt := b.receipts[n]
+ execution := b.gasPool.CumulativeExecution() - before.CumulativeExecution()
+ switch n {
+ case 0:
+ require.Less(t, receipt.GasUsed, execution, "refund reduces fees, not the lane's execution contribution")
+ case 1:
+ require.EqualValues(t, types.ReceiptStatusFailed, receipt.Status)
+ require.Positive(t, execution)
+ case 2:
+ require.Positive(t, b.gasPool.CumulativeState()-before.CumulativeState())
+ case 3:
+ rules := config.Rules(b.header.Number, false, b.header.Time)
+ floorGas, err := FloorDataGas(rules, key.addr, &addr, new(uint256.Int), data, nil)
+ require.NoError(t, err)
+ require.Equal(t, floorGas, execution)
+ require.Positive(t, b.gasPool.CumulativeState()-before.CumulativeState())
+ case 4:
+ require.EqualValues(t, types.ReceiptStatusSuccessful, receipt.Status)
+ require.Zero(t, b.gasPool.CumulativeState()-before.CumulativeState(), "state refill reverses temporary creation, unlike a transaction refund")
+ require.Equal(t, common.Hash{}, b.statedb.GetState(addr, common.Hash{}))
+ case 5:
+ stateGas := b.gasPool.CumulativeState() - before.CumulativeState()
+ require.EqualValues(t, types.ReceiptStatusSuccessful, receipt.Status)
+ require.EqualValues(t, params.StorageCreationSize*params.CostPerStateByte, stateGas)
+ require.Equal(t, execution+stateGas, receipt.GasUsed)
+ }
+ }
+ require.Equal(t, b.gasPool.CumulativeExecution(), b.lane.paymentExecution)
+ require.Equal(t, b.gasPool.CumulativeState(), b.lane.paymentState)
+ })
+ chain, err := NewBlockChain(rawdb.NewMemoryDatabase(), gspec, engine, DefaultConfig())
+ require.NoError(t, err)
+ defer chain.Stop()
+ n, err := chain.InsertChain(blocks)
+ require.NoError(t, err, "block index %d", n)
+ require.Empty(t, blocks[3].Transactions())
+ require.Equal(t, blocks[3].Root(), chain.CurrentBlock().Root)
+ header := chain.CurrentBlock()
+ st, err := chain.StateAt(header.Root, header.Number, header.Time)
+ require.NoError(t, err)
+ evm := vm.NewEVM(NewEVMBlockContext(header, chain, nil), st, config, vm.Config{})
+ defer evm.Release()
+ for _, spender := range []common.Address{{0xcd}, {0xcc}} {
+ input := append(common.FromHex("0xdd62ed3e"), common.LeftPadBytes(key.addr[:], 32)...)
+ input = append(input, common.LeftPadBytes(spender[:], 32)...)
+ ret, _, err := evm.StaticCall(key.addr, token, input, vm.NewGasBudget(100_000, 0))
+ require.NoError(t, err)
+ require.Equal(t, common.Big1, new(big.Int).SetBytes(ret), "allowance must survive the fork")
+ }
+}
+
+func TestPaymentLaneAmsterdamRejectsStateOverflow(t *testing.T) {
+ const gasLimit = 2_000_000
+ config, gspec, key := laneGenesis(t, gasLimit)
+ amsterdam := uint64(25)
+ config.AmsterdamTime = &amsterdam
+ contract := common.Address{0xc1}
+ gspec.Alloc[contract] = types.Account{Code: common.FromHex("0x60016000355500"), Balance: common.Big0}
+ engine := &laneTestEngine{ethash.NewFullFaker()}
+ signer := types.LatestSigner(config)
+ _, blocks, _ := GenerateChainWithGenesis(gspec, engine, 3, func(i int, b *BlockGen) {
+ if i != 2 {
+ return
+ }
+ // Build a block that ignores the quota, but still obeys the ordinary gas limits.
+ b.lane = &LaneState{}
+ for n := uint64(0); n < 20; n++ {
+ b.AddTx(key.sign(t, signer, n, contract, common.Big0, 130_000, []byte{byte(n)}))
+ }
+ })
+ require.Greater(t, blocks[2].GasUsed(), gasLimit-paymentlane.Quota(500, gasLimit))
+ require.LessOrEqual(t, blocks[2].GasUsed(), uint64(gasLimit))
+ chain, err := NewBlockChain(rawdb.NewMemoryDatabase(), gspec, engine, DefaultConfig())
+ require.NoError(t, err)
+ defer chain.Stop()
+ _, err = chain.InsertChain(blocks)
+ require.ErrorIs(t, err, paymentlane.ErrViolated)
+}
diff --git a/core/paymentlane/paymentlane.go b/core/paymentlane/paymentlane.go
index 71114f198b..beac4e7ea6 100644
--- a/core/paymentlane/paymentlane.go
+++ b/core/paymentlane/paymentlane.go
@@ -1,9 +1,9 @@
-// Package paymentlane implements the BEP-703 payment lane rules. One inequality per block:
+// Package paymentlane implements the BEP-703 scalar payment lane budget:
//
-// header.GasUsed + max(0, paymentLaneQuota - paymentGasUsed) <= GasLimit
+// gasUsed + max(0, paymentLaneQuota - paymentGasUsed) <= gasLimit
//
-// Section 3.3's rule with generalGasUsed as the header residual, so Parlia's system transactions
-// count as general gas. Nothing is committed to the block: the quota is a pure function of the
+// Before Amsterdam this applies to the block total; afterwards it applies to each resource.
+// Parlia system transactions count as general gas. The quota is a pure function of the
// parent post-state's ratio and this block's gas limit, so every node derives it independently.
package paymentlane
diff --git a/core/state_processor.go b/core/state_processor.go
index d9db3daa09..c294d89989 100644
--- a/core/state_processor.go
+++ b/core/state_processor.go
@@ -118,8 +118,7 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated
}
}
- // Handle upgrade built-in system contract code
- systemcontracts.TryUpdateBuildInSystemContract(p.chain.Config(), blockNumber, parent.Time, block.Time(), statedb, true)
+ recordSystemBAL := config.IsInBSC() && config.IsAmsterdam(blockNumber, block.Time())
var (
context = NewEVMBlockContext(header, p.chain, nil)
@@ -171,7 +170,7 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated
return nil, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)
}
laneType := lane.Classify(tx)
- usedBefore := gp.Used()
+ usedBefore := gp.Snapshot()
statedb.SetTxContext(tx.Hash(), i, uint32(i+1))
receipt, bal, err := applyTransactionWithEVM(ctx, msg, gp, statedb, blockNumber, blockHash, context.Time, tx, evm, eagerBloom)
if err != nil {
@@ -185,18 +184,24 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated
blockAccessList.Merge(bal)
}
numUserReceipts := len(receipts)
- requests, bal, err := PostExecution(ctx, config, block.Number(), block.Time(), allLogs, block.Withdrawals(), evm, uint32(len(block.Transactions())+1))
- if err != nil {
- return nil, err
+ var requests [][]byte
+ if config.IsNotInBSC() {
+ var postBAL *bal.ConstructionBlockAccessList
+ requests, postBAL, err = PostExecution(ctx, config, block.Number(), block.Time(), allLogs, block.Withdrawals(), evm, uint32(len(block.Transactions())+1))
+ if err != nil {
+ return nil, err
+ }
+ blockAccessList.Merge(postBAL)
}
- blockAccessList.Merge(bal)
gasUsed := gp.Used()
// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
body := &types.Body{Transactions: commonTxs, Uncles: block.Uncles(), Withdrawals: block.Withdrawals()}
- // TODO: Include Parlia system transactions and system-contract upgrades in
- // the block access list before enabling Amsterdam on BSC.
- err = p.chain.Engine().Finalize(p.chain, header, tracingStateDB, body, &receipts, &systemTxs, &gasUsed, cfg.Tracer)
+ finalizeState := tracingStateDB
+ if recordSystemBAL {
+ finalizeState = NewSystemTxStateDB(tracingStateDB, blockAccessList)
+ }
+ err = p.chain.Engine().Finalize(p.chain, header, finalizeState, body, &receipts, &systemTxs, &gasUsed, cfg.Tracer)
if err != nil {
return nil, err
}
@@ -208,8 +213,16 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated
pipeline.feedReceipt(receipt)
allLogs = append(allLogs, receipt.Logs...)
}
+ if config.IsInBSC() {
+ var postBAL *bal.ConstructionBlockAccessList
+ requests, postBAL, err = PostExecution(ctx, config, block.Number(), block.Time(), allLogs, block.Withdrawals(), evm, uint32(len(block.Transactions())+1))
+ if err != nil {
+ return nil, err
+ }
+ blockAccessList.Merge(postBAL)
+ }
- if err := lane.Verify(gasUsed); err != nil {
+ if err := lane.Verify(gasUsed, gp); err != nil {
return nil, laneReject(err)
}
lane.recordImported()
@@ -242,6 +255,10 @@ func PreExecution(ctx context.Context, beaconRoot *common.Hash, parent *types.He
if config.IsAmsterdam(number, time) {
blockAccessList = bal.NewConstructionBlockAccessList()
}
+ systemcontracts.TryUpdateBuildInSystemContract(config, number, parent.Time, time, evm.StateDB, true)
+ if config.IsInBSC() && config.IsAmsterdam(number, time) {
+ blockAccessList.Merge(finaliseProtocolChanges(evm.StateDB, evm.GetRules(), 0))
+ }
// EIP-4788
if beaconRoot != nil {
ProcessBeaconBlockRoot(*beaconRoot, evm, blockAccessList)
@@ -256,6 +273,7 @@ func PreExecution(ctx context.Context, beaconRoot *common.Hash, parent *types.He
// PostExecution processes the withdrawals and then the post-execution system
// calls when Prague is enabled. If Prague is not activated, it returns null
// requests to differentiate from empty requests.
+// On BSC, it collects remaining protocol changes after all system transactions.
func PostExecution(ctx context.Context, config *params.ChainConfig, number *big.Int, time uint64, allLogs []*types.Log, withdrawals types.Withdrawals, evm *vm.EVM, blockAccessIndex uint32) (requests [][]byte, blockAccessList *bal.ConstructionBlockAccessList, err error) {
_, _, spanEnd := telemetry.StartSpan(ctx, "core.postExecution")
defer spanEnd(&err)
@@ -263,6 +281,12 @@ func PostExecution(ctx context.Context, config *params.ChainConfig, number *big.
if config.IsAmsterdam(number, time) {
blockAccessList = bal.NewConstructionBlockAccessList()
}
+ if config.IsInBSC() {
+ if config.IsAmsterdam(number, time) {
+ blockAccessList.Merge(finaliseProtocolChanges(evm.StateDB, evm.GetRules(), blockAccessIndex))
+ }
+ return nil, blockAccessList, nil
+ }
rules := config.Rules(number, true, time) // IsMerge is always true
// Withdrawals are applied before the system calls
@@ -632,20 +656,14 @@ func onSystemCallStart(tracer *tracing.Hooks, ctx *tracing.VMContext) {
// blockAssembler is implemented by consensus engines that support FinalizeAndAssemble.
type blockAssembler interface {
- FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks) (*types.Block, []*types.Receipt, error)
+ FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks, blockAccessLists ...*bal.ConstructionBlockAccessList) (*types.Block, []*types.Receipt, error)
}
// AssembleBlock finalizes the state and assembles the block with provided
// body and receipts.
func AssembleBlock(engine consensus.Engine, chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt, blockAccessLists ...*bal.ConstructionBlockAccessList) (*types.Block, []*types.Receipt, error) {
if p, ok := engine.(blockAssembler); ok {
- // TODO: Include Parlia finalization in BAL construction and attach the
- // completed access list here before enabling Amsterdam on BSC.
- block, receipts, err := p.FinalizeAndAssemble(chain, header, state, body, receipts, nil)
- if err != nil {
- return nil, nil, err
- }
- return block, receipts, nil
+ return p.FinalizeAndAssemble(chain, header, state, body, receipts, nil, blockAccessLists...)
}
if err := engine.Finalize(chain, header, state, body, &receipts, nil, &header.GasUsed, nil); err != nil {
return nil, nil, err
diff --git a/core/state_processor_bsc.go b/core/state_processor_bsc.go
new file mode 100644
index 0000000000..b0d8fe8167
--- /dev/null
+++ b/core/state_processor_bsc.go
@@ -0,0 +1,52 @@
+// Copyright 2026 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 .
+
+package core
+
+import (
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types/bal"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/params"
+)
+
+// systemTxStateDB collects the BALs finalized by Parlia without changing the
+// consensus engine interface. Pending protocol mutations share the next system
+// transaction's scope, so their combined net changes are recorded together.
+type systemTxStateDB struct {
+ vm.StateDB
+ accessList *bal.ConstructionBlockAccessList
+}
+
+// NewSystemTxStateDB collects the BALs returned by Parlia system transactions.
+func NewSystemTxStateDB(statedb vm.StateDB, accessList *bal.ConstructionBlockAccessList) vm.StateDB {
+ return &systemTxStateDB{StateDB: statedb, accessList: accessList}
+}
+
+func (s *systemTxStateDB) Finalise(rules params.Rules) *bal.ConstructionBlockAccessList {
+ list := s.StateDB.Finalise(rules)
+ s.accessList.Merge(list)
+ return list
+}
+
+// finaliseProtocolChanges records only pending mutations. Prepare runs after
+// the protocol operations so their read-only accesses, including any omitted
+// system transaction attempt, do not enter the BAL.
+func finaliseProtocolChanges(statedb vm.StateDB, rules params.Rules, index uint32) *bal.ConstructionBlockAccessList {
+ statedb.Prepare(rules, common.Address{}, common.Address{}, nil, nil, nil)
+ statedb.SetTxContext(common.Hash{}, max(0, int(index)-1), index)
+ return statedb.Finalise(rules)
+}
diff --git a/core/state_processor_bsc_test.go b/core/state_processor_bsc_test.go
new file mode 100644
index 0000000000..b782c7f781
--- /dev/null
+++ b/core/state_processor_bsc_test.go
@@ -0,0 +1,197 @@
+package core
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "math/big"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/consensus"
+ "github.com/ethereum/go-ethereum/consensus/ethash"
+ "github.com/ethereum/go-ethereum/core/rawdb"
+ "github.com/ethereum/go-ethereum/core/state"
+ "github.com/ethereum/go-ethereum/core/systemcontracts"
+ "github.com/ethereum/go-ethereum/core/tracing"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/types/bal"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/params"
+ "github.com/ethereum/go-ethereum/triedb"
+ "github.com/holiman/uint256"
+)
+
+func TestBSCSystemContractUpgradePhases(t *testing.T) {
+ genesisHash := systemcontracts.GenesisHash
+ systemcontracts.GenesisHash = params.BSCGenesisHash
+ t.Cleanup(func() { systemcontracts.GenesisHash = genesisHash })
+ for _, active := range []bool{false, true} {
+ t.Run(map[bool]string{false: "pre-amsterdam", true: "amsterdam"}[active], func(t *testing.T) {
+ config := *params.ParliaTestChainConfig
+ config.JennerTime = u64(2)
+ if active {
+ config.AmsterdamTime = u64(2)
+ }
+ parent := &types.Header{Time: 1}
+ number := big.NewInt(2)
+ db := state.NewDatabaseForTesting()
+ sdb, _ := state.New(types.EmptyRootHash, db)
+ evm := vm.NewEVM(vm.BlockContext{BlockNumber: number, Time: 2}, sdb, &config, vm.Config{})
+ defer evm.Release()
+ list := bal.NewConstructionBlockAccessList()
+ list.Merge(PreExecution(context.Background(), nil, parent, &config, evm, number, 2))
+ for _, addr := range []common.Address{vm.CAS20ActivationRegistryAddress, vm.CAS20PolicyRegistryAddress} {
+ if code := sdb.GetCode(addr); !bytes.Equal(code, vm.CAS20MarkerCode) {
+ t.Fatalf("missing pre-execution sentinel at %s", addr)
+ }
+ }
+ paymentLane := common.HexToAddress(systemcontracts.PaymentLaneContract)
+ if len(sdb.GetCode(paymentLane)) != 0 {
+ t.Fatal("payment-lane contract upgraded before normal transactions")
+ }
+ systemcontracts.TryUpdateBuildInSystemContract(&config, number, parent.Time, 2, sdb, false)
+ code := sdb.GetCode(paymentLane)
+ if len(code) == 0 {
+ t.Fatal("payment-lane contract not upgraded before system transactions")
+ }
+ coinbase := common.HexToAddress("0xbeef")
+ systemState := &systemTxStateDB{StateDB: sdb, accessList: list}
+ systemState.Prepare(evm.GetRules(), coinbase, coinbase, nil, nil, nil)
+ systemState.SetTxContext(common.Hash{1}, 0, 1)
+ systemState.SetNonce(coinbase, 1, tracing.NonceChangeEoACall)
+ systemState.Finalise(evm.GetRules())
+ requests, postBAL, err := PostExecution(context.Background(), &config, number, 2, nil, nil, evm, 2)
+ if err != nil || requests != nil {
+ t.Fatalf("post-execution: requests %v, err %v", requests, err)
+ }
+ list.Merge(postBAL)
+
+ want := bal.NewConstructionBlockAccessList()
+ if active {
+ want.CodeChange(vm.CAS20ActivationRegistryAddress, 0, vm.CAS20MarkerCode)
+ want.CodeChange(vm.CAS20PolicyRegistryAddress, 0, vm.CAS20MarkerCode)
+ want.CodeChange(paymentLane, 1, code)
+ want.NonceChange(coinbase, 1, 1)
+ }
+ if list.ToEncodingObj().Hash() != want.ToEncodingObj().Hash() {
+ t.Fatalf("unexpected upgrade BAL:\n%s\nwant:\n%s", list.PrettyPrint(), want.PrettyPrint())
+ }
+ })
+ }
+}
+
+func TestSystemTransactionAccessList(t *testing.T) {
+ config := *params.ParliaTestChainConfig
+ config.AmsterdamTime = new(uint64)
+ rules := config.Rules(common.Big1, false, 1)
+ coinbase := common.HexToAddress("0xbeef")
+ contract := common.HexToAddress("0xcafe")
+ upgrade := common.HexToAddress("0xaaaa")
+ omitted := common.HexToAddress("0xbbbb")
+ readOnly := common.HexToAddress("0xcccc")
+ tail := common.HexToAddress("0xdddd")
+ code := []byte{byte(vm.PUSH1), 1, byte(vm.PUSH1), 0, byte(vm.SSTORE), byte(vm.STOP)}
+ codeChange := []byte{byte(vm.STOP)}
+ db := state.NewDatabaseForTesting()
+ sdb, _ := state.New(types.EmptyRootHash, db)
+ sdb.SetBalance(consensus.SystemAddress, uint256.NewInt(100), tracing.BalanceChangeUnspecified)
+ sdb.SetCode(contract, code, tracing.CodeChangeUnspecified)
+ sdb.SetCode(omitted, []byte{byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.REVERT)}, tracing.CodeChangeUnspecified)
+ sdb.Finalise(params.Rules{})
+ inner := state.NewHookedState(sdb, &tracing.Hooks{OnBalanceChange: func(common.Address, *big.Int, *big.Int, tracing.BalanceChangeReason) {}})
+ list := bal.NewConstructionBlockAccessList()
+ systemState := &systemTxStateDB{StateDB: inner, accessList: list}
+ // Finalize's direct reads are excluded; the transfer and upgrade
+ // share the following system transaction's net-change baseline.
+ systemState.GetBalance(readOnly)
+ systemState.SetBalance(consensus.SystemAddress, common.U2560, tracing.BalanceChangeUnspecified)
+ systemState.AddBalance(coinbase, uint256.NewInt(100), tracing.BalanceChangeUnspecified)
+ systemState.SetCode(upgrade, codeChange, tracing.CodeChangeSystemContractUpgrade)
+ systemState.Prepare(rules, coinbase, coinbase, &contract, vm.ActivePrecompiles(rules), nil)
+ systemState.SetTxContext(common.Hash{1}, 0, 1)
+ evm := vm.NewEVM(vm.BlockContext{BlockNumber: common.Big1, Time: 1, CanTransfer: CanTransfer, Transfer: Transfer}, systemState, &config, vm.Config{})
+ defer evm.Release()
+ if _, _, err := evm.Call(coinbase, contract, nil, vm.NewGasBudget(1_000_000, 0), uint256.NewInt(100)); err != nil {
+ t.Fatal(err)
+ }
+ systemState.SetNonce(coinbase, 1, tracing.NonceChangeEoACall)
+ systemState.Finalise(rules)
+
+ // A failed, omitted attempt contributes no accesses. Its preceding
+ // protocol write remains and belongs to n+1 because no tx follows.
+ systemState.SetCode(tail, codeChange, tracing.CodeChangeSystemContractUpgrade)
+ systemState.Prepare(rules, coinbase, coinbase, &omitted, vm.ActivePrecompiles(rules), nil)
+ systemState.SetTxContext(common.Hash{2}, 1, 2)
+ if _, _, err := evm.Call(coinbase, omitted, nil, vm.NewGasBudget(1_000_000, 0), common.U2560); !errors.Is(err, vm.ErrExecutionReverted) {
+ t.Fatalf("omitted transaction: %v", err)
+ }
+ list.Merge(finaliseProtocolChanges(inner, rules, 2))
+
+ want := bal.NewConstructionBlockAccessList()
+ want.BalanceChange(1, consensus.SystemAddress, common.U2560)
+ want.NonceChange(coinbase, 1, 1)
+ want.BalanceChange(1, contract, uint256.NewInt(100))
+ want.StorageWrite(1, contract, common.Hash{}, common.Hash{31: 1})
+ want.CodeChange(upgrade, 1, codeChange)
+ want.CodeChange(tail, 2, codeChange)
+ if got := list.ToEncodingObj(); got.Hash() != want.ToEncodingObj().Hash() {
+ t.Fatalf("unexpected BAL:\n%s\nwant:\n%s", list.PrettyPrint(), want.PrettyPrint())
+ }
+}
+
+type protocolBALTestEngine struct{ consensus.Engine }
+
+func (e *protocolBALTestEngine) Finalize(_ consensus.ChainHeaderReader, _ *types.Header, s vm.StateDB, _ *types.Body, _ *[]*types.Receipt, _ *[]*types.Transaction, _ *uint64, _ *tracing.Hooks) error {
+ s.GetBalance(common.HexToAddress("0xcccc"))
+ s.SetCode(common.HexToAddress("0xdddd"), []byte{byte(vm.STOP)}, tracing.CodeChangeSystemContractUpgrade)
+ return nil
+}
+
+func TestStateProcessorProtocolAccessList(t *testing.T) {
+ for _, active := range []bool{false, true} {
+ t.Run(map[bool]string{false: "pre-fork", true: "active"}[active], func(t *testing.T) {
+ config := *params.ParliaTestChainConfig
+ config.HaberTime, config.HaberFixTime, config.BohrTime, config.PascalTime = new(uint64), new(uint64), new(uint64), new(uint64)
+ config.PragueTime = u64(1)
+ config.LorentzTime, config.MaxwellTime, config.FermiTime = u64(1), u64(1), u64(1)
+ config.OsakaTime, config.MendelTime, config.PasteurTime = u64(1), u64(1), u64(1)
+ config.BlobScheduleConfig = ¶ms.BlobScheduleConfig{Cancun: params.DefaultCancunBlobConfig, Prague: params.DefaultPragueBlobConfigBSC}
+ if active {
+ config.AmsterdamTime = u64(1)
+ }
+ db := rawdb.NewMemoryDatabase()
+ defer db.Close()
+ triedb := triedb.NewDatabase(db, nil)
+ defer triedb.Close()
+ genesis := (&Genesis{Config: &config}).MustCommit(db, triedb)
+ engine := &protocolBALTestEngine{Engine: ethash.NewFaker()}
+ defer engine.Close()
+ chain, err := NewHeaderChain(db, &config, engine, func() bool { return false })
+ if err != nil {
+ t.Fatal(err)
+ }
+ sdb, _ := state.New(genesis.Root(), state.NewDatabase(triedb, nil))
+ header := &types.Header{ParentHash: genesis.Hash(), Number: common.Big1, Time: 1, Difficulty: common.Big1, GasLimit: 30_000_000}
+ block := types.NewBlockWithHeader(header)
+ res, err := NewStateProcessor(chain).Process(context.Background(), block, sdb, nil, nil, vm.Config{}, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ list, hash := res.encodedAccessList()
+ want := bal.NewConstructionBlockAccessList()
+ if active {
+ want.CodeChange(params.HistoryStorageAddress, 0, params.HistoryStorageCode)
+ want.NonceChange(params.HistoryStorageAddress, 0, 1)
+ want.StorageWrite(0, params.HistoryStorageAddress, common.Hash{}, genesis.Hash())
+ want.CodeChange(common.HexToAddress("0xdddd"), 1, []byte{byte(vm.STOP)})
+ }
+ if hash != want.ToEncodingObj().Hash() {
+ t.Fatalf("unexpected BAL:\n%s\nwant:\n%s", list.PrettyPrint(), want.PrettyPrint())
+ }
+ if res.GasUsed != 0 || len(res.Receipts) != 0 {
+ t.Fatalf("protocol operations changed gas or receipts: %+v", res)
+ }
+ })
+ }
+}
diff --git a/core/vm/cas20_access_gas_bytecode_test.go b/core/vm/cas20_access_gas_bytecode_test.go
index 075efb7b5c..822b98c55a 100644
--- a/core/vm/cas20_access_gas_bytecode_test.go
+++ b/core/vm/cas20_access_gas_bytecode_test.go
@@ -79,6 +79,22 @@ func (p cas20AccessProgram) RunStateful(ctx *PrecompileContext, _ []byte) ([]byt
}
func TestCAS20AccessGasAgainstBytecode(t *testing.T) {
+ for _, amsterdam := range []bool{false, true} {
+ for _, table := range []bool{false, true} {
+ t.Run(fmt.Sprintf("amsterdam=%t/table=%t", amsterdam, table), func(t *testing.T) {
+ testCAS20AccessGasAgainstBytecode(t, cas20GasChainConfig(amsterdam), table)
+ })
+ }
+ }
+}
+
+func testCAS20AccessGasAgainstBytecode(t *testing.T, cfg *params.ChainConfig, table bool) {
+ if err := cfg.CheckConfigForkOrder(); err != nil {
+ t.Fatal(err)
+ }
+ bc := cas20BlockContext(1)
+ bc.CostPerStateByte = params.CostPerStateByte
+
self := common.HexToAddress("0x1234")
slot := common.Hash{31: 1}
for _, target := range []struct {
@@ -143,7 +159,8 @@ func TestCAS20AccessGasAgainstBytecode(t *testing.T) {
}
run := func(native bool, budget uint64) result {
sdb := initial.Copy()
- evm := NewEVM(cas20BlockContext(1), sdb, cas20TestChainConfig(), Config{})
+ evm := NewEVM(bc, sdb, cfg, Config{})
+ evm.forceTableLoop = table
defer evm.Release()
callee := self
if native {
diff --git a/core/vm/cas20_factory_test.go b/core/vm/cas20_factory_test.go
index 5977d83ddb..d725c46647 100644
--- a/core/vm/cas20_factory_test.go
+++ b/core/vm/cas20_factory_test.go
@@ -3,11 +3,14 @@ package vm
import (
"bytes"
"errors"
+ "fmt"
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/state"
+ "github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
)
@@ -489,3 +492,96 @@ func TestCAS20BootstrapReachesTheVariant(t *testing.T) {
t.Errorf("totalSupply = %d, want 30", got)
}
}
+
+func TestCAS20CodeWriteGas(t *testing.T) {
+ for _, amsterdam := range []bool{false, true} {
+ for _, prefunded := range []bool{false, true} {
+ t.Run(fmt.Sprintf("amsterdam=%t/prefunded=%t", amsterdam, prefunded), func(t *testing.T) {
+ st, _ := state.New(types.EmptyRootHash, state.NewDatabaseForTesting())
+ addr := cas20Addr(cas20VariantAsset, 1)
+ if prefunded {
+ st.SetBalance(addr, uint256.NewInt(1), tracing.BalanceChangeUnspecified)
+ }
+ bc := cas20BlockContext(1)
+ bc.CostPerStateByte = params.CostPerStateByte
+ evm := NewEVM(bc, st, cas20GasChainConfig(amsterdam), Config{})
+ defer evm.Release()
+ gas := NewGasBudget(1_000_000, 1_000_000)
+ ctx := &PrecompileContext{evm: evm, StateDB: st, Self: CAS20FactoryAddress, gas: &gas}
+ if !ctx.chargeCodeWrite(addr, CAS20MarkerCode) {
+ t.Fatal("code write charge failed")
+ }
+ size := uint64(len(CAS20MarkerCode))
+ execution := params.CreateGas + size*params.CreateDataGas
+ var stateGas uint64
+ if amsterdam {
+ execution = params.CreateAccessAmsterdam
+ stateGas = (params.AccountCreationSize + size) * params.CostPerStateByte
+ }
+ execution += params.Keccak256Gas + toWordSize(size)*params.Keccak256WordGas
+ if gas.UsedExecutionGas != execution || gas.UsedStateGas != int64(stateGas) {
+ t.Fatalf("charged %v, want execution=%d state=%d", gas, execution, stateGas)
+ }
+ })
+ }
+ }
+}
+
+func TestCAS20FactoryGas(t *testing.T) {
+ for _, variant := range []byte{cas20VariantAsset, cas20VariantStablecoin} {
+ for _, amsterdam := range []bool{false, true} {
+ for _, prefunded := range []bool{false, true} {
+ for _, reservoir := range []uint64{0, 1_000_000} {
+ t.Run(fmt.Sprintf("variant=%d/amsterdam=%t/prefunded=%t/state=%d", variant, amsterdam, prefunded, reservoir), func(t *testing.T) {
+ cfg := cas20GasChainConfig(amsterdam)
+ bc := cas20BlockContext(1)
+ bc.CostPerStateByte = params.CostPerStateByte
+ st, _ := state.New(types.EmptyRootHash, state.NewDatabaseForTesting())
+ seedActivation(st, cas20TestCaller)
+ creator, salt := cas20Alice, common.Hash{31: 1}
+ token := cas20DeriveAddress(variant, creator, salt)
+ if prefunded {
+ st.SetBalance(token, uint256.NewInt(1), tracing.BalanceChangeUnspecified)
+ }
+ rules := cfg.Rules(bc.BlockNumber, true, bc.Time)
+ before := st.IntermediateRoot(rules)
+ evm := NewEVM(bc, st, cfg, Config{})
+ defer evm.Release()
+ input := encodeCreateCAS20(variant, salt, creator, nil)
+ ret, left, err := evm.Call(creator, CAS20FactoryAddress, input, NewGasBudget(300_000, reservoir), new(uint256.Int))
+ if amsterdam && reservoir == 0 {
+ if !errors.Is(err, ErrOutOfGas) || left.UsedStateGas != 0 || st.IntermediateRoot(rules) != before {
+ t.Fatalf("failed factory did not restore state: gas=%v err=%v", left, err)
+ }
+ return
+ }
+ if err != nil || common.BytesToAddress(ret) != token || !bytes.Equal(st.GetCode(token), CAS20MarkerCode) {
+ t.Fatalf("factory failed: gas=%v err=%v", left, err)
+ }
+ if amsterdam {
+ if left.UsedStateGas <= int64((params.AccountCreationSize+len(CAS20MarkerCode))*params.CostPerStateByte) {
+ t.Fatalf("factory storage was not charged: %v", left)
+ }
+ } else if left.UsedStateGas != 0 {
+ t.Fatalf("state gas charged before Amsterdam: %v", left)
+ }
+ if prefunded && st.GetBalance(token).Uint64() != 1 {
+ t.Fatal("factory changed the prefunded balance")
+ }
+ root := st.IntermediateRoot(rules)
+ _, _, err = evm.Call(creator, CAS20FactoryAddress, input, NewGasBudget(1_000_000, 1_000_000), new(uint256.Int))
+ if !errors.Is(err, ErrExecutionReverted) || st.IntermediateRoot(rules) != root {
+ t.Fatalf("duplicate creation did not preserve the token: %v", err)
+ }
+ // A failing init call must also undo the code and state already created.
+ input = encodeCreateCAS20(variant, common.Hash{31: 2}, creator, [][]byte{{0xff, 0xff, 0xff, 0xff}})
+ _, left, err = evm.Call(creator, CAS20FactoryAddress, input, NewGasBudget(1_000_000, 2_000_000), new(uint256.Int))
+ if !errors.Is(err, ErrExecutionReverted) || left.UsedStateGas != 0 || left.StateGas != 2_000_000 || st.IntermediateRoot(rules) != root {
+ t.Fatalf("failed bootstrap did not restore state and reservoir: gas=%v err=%v", left, err)
+ }
+ })
+ }
+ }
+ }
+ }
+}
diff --git a/core/vm/cas20_gas.go b/core/vm/cas20_gas.go
index 2439df22ec..a16a160669 100644
--- a/core/vm/cas20_gas.go
+++ b/core/vm/cas20_gas.go
@@ -2,6 +2,7 @@ package vm
import (
"github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/params"
)
@@ -50,6 +51,9 @@ func (ctx *PrecompileContext) chargeAccountAccess(addr common.Address) bool {
}
// Warmed before the charge, in the interpreter's order; the addition is journalled.
ctx.StateDB.AddAddressToAccessList(addr)
+ if ctx.evm != nil && ctx.evm.chainRules.IsAmsterdam {
+ return ctx.chargeGas(params.ColdAccountAccessAmsterdam)
+ }
return ctx.chargeGas(params.ColdAccountAccessCostEIP2929)
}
@@ -60,6 +64,15 @@ func (ctx *PrecompileContext) chargeCodeWrite(addr common.Address, code []byte)
ctx.markWriteProtected()
return false
}
+ if ctx.evm != nil && ctx.evm.chainRules.IsAmsterdam {
+ cost := GasCosts{StateGas: uint64(len(code)) * ctx.evm.Context.CostPerStateByte}
+ if hadNoCode(ctx.StateDB, addr) {
+ cost.ExecutionGas = params.CreateAccessAmsterdam
+ cost.StateGas += params.AccountCreationSize * ctx.evm.Context.CostPerStateByte
+ }
+ // Code hashing keeps its existing explicit keccak charge.
+ return ctx.chargeCosts(cost) && ctx.chargeKeccak(len(code))
+ }
cost := params.CreateDataGas * uint64(len(code))
if hadNoCode(ctx.StateDB, addr) {
cost += params.CreateGas
@@ -73,7 +86,7 @@ func (ctx *PrecompileContext) sstoreSentry() bool {
return ctx.gas.ExecutionGas > params.SstoreSentryGasEIP2200
}
-// Mirrors makeGasSStoreFunc, arms in the same order with the same clause numbers.
+// chargeStorageWrite follows the active SSTORE schedule, including refunds and refills.
func (s cas20Storage) chargeStorageWrite(slot, value common.Hash) bool {
if s.ctx == nil {
return true
@@ -87,6 +100,19 @@ func (s cas20Storage) chargeStorageWrite(slot, value common.Hash) bool {
return false
}
s.ctx.traceStorageRead(s.token, slot)
+ if s.ctx.evm != nil && s.ctx.evm.chainRules.IsAmsterdam {
+ // Cost calculation can refill state gas before the next charge.
+ prior := s.ctx.gas.AsTracing()
+ cost, err := gasSStoreCostAmsterdam(s.ctx.evm, s.ctx.gas, s.token, slot, value)
+ if err != nil {
+ s.ctx.markOutOfGas()
+ return false
+ }
+ if hooks := s.ctx.evm.Config.Tracer; hooks.HasGasHook() && prior != s.ctx.gas.AsTracing() {
+ hooks.EmitGasChange(prior, s.ctx.gas.AsTracing(), tracing.GasChangeCallPrecompiledContract)
+ }
+ return s.ctx.chargeCosts(cost)
+ }
var (
current, original = s.state.GetStateAndCommittedState(s.token, slot)
clearingRefund = params.SstoreClearsScheduleRefundEIP3529
diff --git a/core/vm/cas20_gas_bytecode_test.go b/core/vm/cas20_gas_bytecode_test.go
index a07696d399..e5ca90e964 100644
--- a/core/vm/cas20_gas_bytecode_test.go
+++ b/core/vm/cas20_gas_bytecode_test.go
@@ -1,6 +1,7 @@
package vm
import (
+ "bytes"
"errors"
"fmt"
"testing"
@@ -13,8 +14,7 @@ import (
"github.com/holiman/uint256"
)
-// Each operation accesses slot 1. Values fit PUSH1 so the reference needs only
-// PUSH1, SLOAD, SSTORE and POP, with no Solidity compiler or ABI overhead.
+// Storage operations use slot 1, without Solidity compiler or ABI overhead.
type cas20StorageOp struct {
write bool
value byte
@@ -22,7 +22,9 @@ type cas20StorageOp struct {
type cas20StorageProgram struct {
cas20StatefulBase
- ops []cas20StorageOp
+ ops []cas20StorageOp
+ valueFromInput bool
+ revert bool
}
func (p cas20StorageProgram) Name() string { return "CAS20 storage test" }
@@ -31,15 +33,23 @@ func (p cas20StorageProgram) bytecode() []byte {
var code []byte
for _, op := range p.ops {
if op.write {
- code = append(code, byte(PUSH1), op.value, byte(PUSH1), 1, byte(SSTORE))
+ if p.valueFromInput {
+ code = append(code, byte(PUSH1), 0, byte(CALLDATALOAD))
+ } else {
+ code = append(code, byte(PUSH1), op.value)
+ }
+ code = append(code, byte(PUSH1), 1, byte(SSTORE))
} else {
code = append(code, byte(PUSH1), 1, byte(SLOAD), byte(POP))
}
}
+ if p.revert {
+ code = append(code, byte(PUSH1), 0, byte(PUSH1), 0, byte(REVERT))
+ }
return code
}
-func (p cas20StorageProgram) RunStateful(ctx *PrecompileContext, _ []byte) ([]byte, error) {
+func (p cas20StorageProgram) RunStateful(ctx *PrecompileContext, input []byte) ([]byte, error) {
s := newMeteredCAS20Storage(ctx)
for _, op := range p.ops {
// Pay only the reference's stack scaffolding here. Storage gas and refunds
@@ -53,7 +63,15 @@ func (p cas20StorageProgram) RunStateful(ctx *PrecompileContext, _ []byte) ([]by
return nil, ErrOutOfGas
}
if op.write {
- if !s.setWord(common.Hash{31: 1}, common.Hash{31: op.value}) {
+ value := common.Hash{31: op.value}
+ if p.valueFromInput {
+ if !ctx.chargeGas(ctx.evm.table[CALLDATALOAD].constantGas) {
+ return nil, ErrOutOfGas
+ }
+ value = common.Hash{}
+ copy(value[:], input)
+ }
+ if !s.setWord(common.Hash{31: 1}, value) {
return nil, ErrOutOfGas
}
} else {
@@ -65,13 +83,49 @@ func (p cas20StorageProgram) RunStateful(ctx *PrecompileContext, _ []byte) ([]by
}
}
}
+ if p.revert {
+ if !ctx.chargeGas(2 * ctx.evm.table[PUSH1].constantGas) {
+ return nil, ErrOutOfGas
+ }
+ return finishCAS20Metered(ctx, nil, ErrExecutionReverted)
+ }
return finishCAS20Metered(ctx, nil, nil)
}
+func cas20GasChainConfig(amsterdam bool) *params.ChainConfig {
+ cfg := *params.ParliaTestChainConfig
+ cfg.HaberTime, cfg.HaberFixTime, cfg.BohrTime, cfg.PascalTime = new(uint64), new(uint64), new(uint64), new(uint64)
+ cfg.PragueTime, cfg.LorentzTime, cfg.MaxwellTime, cfg.FermiTime = new(uint64), new(uint64), new(uint64), new(uint64)
+ cfg.OsakaTime, cfg.MendelTime, cfg.PasteurTime = new(uint64), new(uint64), new(uint64)
+ cfg.JennerTime = new(uint64)
+ cfg.AmsterdamTime = nil
+ if amsterdam {
+ cfg.AmsterdamTime = new(uint64)
+ }
+ cfg.BlobScheduleConfig = ¶ms.BlobScheduleConfig{Cancun: params.DefaultCancunBlobConfig, Prague: params.DefaultPragueBlobConfigBSC}
+ return &cfg
+}
+
// Compare the native storage layer against the fork-selected bytecode engine,
// including refunds and EVM.Call rollback. Both paths start with identical code
// and state at the same address, so their complete state roots are comparable.
func TestCAS20StorageGasAgainstBytecode(t *testing.T) {
+ for _, amsterdam := range []bool{false, true} {
+ for _, table := range []bool{false, true} {
+ t.Run(fmt.Sprintf("amsterdam=%t/table=%t", amsterdam, table), func(t *testing.T) {
+ testCAS20StorageGasAgainstBytecode(t, cas20GasChainConfig(amsterdam), table)
+ })
+ }
+ }
+}
+
+func testCAS20StorageGasAgainstBytecode(t *testing.T, cfg *params.ChainConfig, table bool) {
+ if err := cfg.CheckConfigForkOrder(); err != nil {
+ t.Fatal(err)
+ }
+ bc := cas20BlockContext(1)
+ bc.CostPerStateByte = params.CostPerStateByte
+
read := cas20StorageOp{}
write := func(v byte) cas20StorageOp { return cas20StorageOp{write: true, value: v} }
for _, tc := range []struct {
@@ -122,28 +176,33 @@ func TestCAS20StorageGasAgainstBytecode(t *testing.T) {
root common.Hash
err error
}
- run := func(native bool, budget uint64) result {
+ run := func(native bool, budget GasBudget) result {
sdb := initial.Copy()
- evm := NewEVM(cas20BlockContext(1), sdb, cas20TestChainConfig(), Config{})
+ evm := NewEVM(bc, sdb, cfg, Config{})
+ evm.forceTableLoop = table
defer evm.Release()
if native {
evm.SetPrecompiles(PrecompiledContracts{addr: program})
}
- _, left, err := evm.Call(cas20Alice, addr, nil, NewGasBudget(budget, 0), new(uint256.Int))
+ _, left, err := evm.Call(cas20Alice, addr, nil, budget, new(uint256.Int))
refund := sdb.GetRefund() // IntermediateRoot finalises and clears refunds.
return result{left, refund, sdb.IntermediateRoot(params.Rules{IsEIP158: true}), err}
}
- const ample = uint64(1_000_000)
+ ample := NewGasBudget(1_000_000, 0)
oracle := run(false, ample)
if oracle.err != nil {
t.Fatalf("reference execution failed: %v", oracle.err)
}
- used := ample - oracle.gas.ExecutionGas
- // The last three budgets leave 2299, 2300 and 2301 gas after
+ used := ample.ExecutionGas - oracle.gas.ExecutionGas
+ // Budgets 2305-2307 leave 2299, 2300 and 2301 gas after
// the two PUSH1s preceding a first SSTORE. Exact/short budgets
// also exercise failures after earlier writes and refund changes.
- for _, budget := range []uint64{ample, used, used - 1, 2305, 2306, 2307} {
- t.Run(fmt.Sprintf("gas=%d", budget), func(t *testing.T) {
+ budgets := []GasBudget{ample, NewGasBudget(used, 0), NewGasBudget(used-1, 0), NewGasBudget(2305, 0), NewGasBudget(2306, 0), NewGasBudget(2307, 0)}
+ if cfg.IsAmsterdam(bc.BlockNumber, bc.Time) {
+ budgets = append(budgets, NewGasBudget(20_000, 100_000), NewGasBudget(30_000, 0), NewGasBudget(1_000_000, 100_000), NewGasBudget(20_000, 10_000))
+ }
+ for _, budget := range budgets {
+ t.Run(fmt.Sprintf("execution=%d/state=%d", budget.ExecutionGas, budget.StateGas), func(t *testing.T) {
want, got := run(false, budget), run(true, budget)
for _, err := range []error{want.err, got.err} {
if err != nil && !errors.Is(err, ErrOutOfGas) {
@@ -160,3 +219,104 @@ func TestCAS20StorageGasAgainstBytecode(t *testing.T) {
}
}
}
+
+func TestCAS20StorageFramesAgainstBytecode(t *testing.T) {
+ for _, amsterdam := range []bool{false, true} {
+ for _, table := range []bool{false, true} {
+ for _, tc := range []struct {
+ name string
+ values []byte
+ forward, state uint64
+ revert bool
+ }{
+ {"limited-forward", []byte{1}, 20_000, 100_000, false},
+ {"refill", []byte{1, 0}, 200_000, 200_000, false},
+ {"spill-refill", []byte{1, 0}, 200_000, 0, false},
+ {"revert", []byte{1}, 200_000, 100_000, true},
+ {"oog", []byte{1}, 3_000, 100_000, false},
+ } {
+ t.Run(fmt.Sprintf("amsterdam=%t/table=%t/%s", amsterdam, table, tc.name), func(t *testing.T) {
+ cfg := cas20GasChainConfig(amsterdam)
+ bc := cas20BlockContext(1)
+ bc.CostPerStateByte = params.CostPerStateByte
+ target, wrapper := common.HexToAddress("0x1234"), common.HexToAddress("0x5678")
+ program := cas20StorageProgram{ops: []cas20StorageOp{{write: true}}, valueFromInput: true, revert: tc.revert}
+ var code []byte
+ for i, v := range tc.values {
+ code = append(code, byte(PUSH1), v, byte(PUSH1), 0, byte(MSTORE))
+ code = append(code, byte(PUSH1), 0, byte(PUSH1), 0, byte(PUSH1), 32, byte(PUSH1), 0, byte(PUSH1), 0, byte(PUSH20))
+ code = append(code, target[:]...)
+ code = append(code, byte(PUSH3), byte(tc.forward>>16), byte(tc.forward>>8), byte(tc.forward), byte(CALL), byte(PUSH1), byte((i+1)*32), byte(MSTORE))
+ }
+ code = append(code, byte(PUSH1), byte(len(tc.values)*32), byte(PUSH1), 32, byte(RETURN))
+ initial, _ := state.New(types.EmptyRootHash, state.NewDatabaseForTesting())
+ initial.SetCode(target, program.bytecode(), tracing.CodeChangeUnspecified)
+ initial.SetCode(wrapper, code, tracing.CodeChangeUnspecified)
+ initial.Finalise(cfg.Rules(bc.BlockNumber, true, bc.Time))
+ type result struct {
+ output []byte
+ gas GasBudget
+ refund uint64
+ root common.Hash
+ }
+ run := func(native bool) result {
+ st := initial.Copy()
+ evm := NewEVM(bc, st, cfg, Config{})
+ defer evm.Release()
+ evm.forceTableLoop = table
+ if native {
+ evm.SetPrecompiles(PrecompiledContracts{target: program})
+ }
+ reservoir := tc.state
+ if !amsterdam {
+ reservoir = 0
+ }
+ ret, left, err := evm.Call(cas20Alice, wrapper, nil, NewGasBudget(1_000_000, reservoir), new(uint256.Int))
+ if err != nil {
+ t.Fatal(err)
+ }
+ refund := st.GetRefund()
+ return result{ret, left, refund, st.IntermediateRoot(evm.GetRules())}
+ }
+ want, got := run(false), run(true)
+ if !bytes.Equal(want.output, got.output) || want.gas != got.gas || want.refund != got.refund || want.root != got.root {
+ t.Fatalf("native %+v; bytecode %+v", got, want)
+ }
+ if amsterdam && tc.name == "limited-forward" && got.output[31] != 1 {
+ t.Fatal("state reservoir did not fund the forwarded call")
+ }
+ })
+ }
+ }
+ }
+}
+
+func TestCAS20StateRefillGasTrace(t *testing.T) {
+ for _, reservoir := range []uint64{0, 200_000} {
+ cfg := cas20GasChainConfig(true)
+ bc := cas20BlockContext(1)
+ bc.CostPerStateByte = params.CostPerStateByte
+ st, _ := state.New(types.EmptyRootHash, state.NewDatabaseForTesting())
+ addr := common.HexToAddress("0x1234")
+ program := cas20StorageProgram{ops: []cas20StorageOp{{write: true, value: 1}, {write: true, value: 0}}}
+ st.SetCode(addr, program.bytecode(), tracing.CodeChangeUnspecified)
+ st.Finalise(cfg.Rules(bc.BlockNumber, true, bc.Time))
+ gas := NewGasBudget(200_000, reservoir)
+ last := gas.AsTracing()
+ hooks := &tracing.Hooks{OnGasChangeV2: func(before, after tracing.Gas, _ tracing.GasChangeReason) {
+ if before != last {
+ t.Errorf("gas event gap: previous %v, next %v", last, before)
+ }
+ last = after
+ }}
+ evm := NewEVM(bc, st, cfg, Config{Tracer: hooks})
+ defer evm.Release()
+ ctx := &PrecompileContext{evm: evm, StateDB: st, Self: addr, gas: &gas}
+ if _, err := program.RunStateful(ctx, nil); err != nil {
+ t.Fatal(err)
+ }
+ if gas.UsedStateGas != 0 || last != gas.AsTracing() {
+ t.Fatalf("refill gas=%v, final event=%v", gas, last)
+ }
+ }
+}
diff --git a/core/vm/contracts_stateful.go b/core/vm/contracts_stateful.go
index 032503ca82..34ed4ca73c 100644
--- a/core/vm/contracts_stateful.go
+++ b/core/vm/contracts_stateful.go
@@ -108,13 +108,16 @@ func (ctx *PrecompileContext) traceAccountRead(addr common.Address) {
}
}
-// chargeGas is where every CAS20 charge arrives. False means stop before the
-// operation the charge pays for, as the interpreter checks gas before an opcode.
func (ctx *PrecompileContext) chargeGas(cost uint64) bool {
+ return ctx.chargeCosts(GasCosts{ExecutionGas: cost})
+}
+
+// chargeCosts stops the frame before an operation whose cost it cannot cover.
+func (ctx *PrecompileContext) chargeCosts(cost GasCosts) bool {
if ctx.OutOfGas() {
return false
}
- if !ctx.UseGas(GasCosts{ExecutionGas: cost}) {
+ if !ctx.UseGas(cost) {
ctx.markOutOfGas()
return false
}
diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go
index e8590814d3..3ce1fafde7 100644
--- a/core/vm/gas_table.go
+++ b/core/vm/gas_table.go
@@ -685,29 +685,27 @@ func gasSStore8037And8038(evm *EVM, contract *Contract, stack *Stack, mem *Memor
if contract.Gas.ExecutionGas <= params.SstoreSentryGasEIP2200 {
return GasCosts{}, errors.New("not enough gas for reentrancy sentry")
}
- var (
- y, x = stack.back(1), stack.peek()
- slot = common.Hash(x.Bytes32())
- stateSet = params.StorageCreationSize * evm.Context.CostPerStateByte
- )
+ return gasSStoreCostAmsterdam(evm, &contract.Gas, contract.Address(), stack.peek().Bytes32(), stack.back(1).Bytes32())
+}
+
+// gasSStoreCostAmsterdam also prices native writes; callers enforce write protection and the sentry.
+func gasSStoreCostAmsterdam(evm *EVM, budget *GasBudget, addr common.Address, slot, value common.Hash) (GasCosts, error) {
+ stateSet := params.StorageCreationSize * evm.Context.CostPerStateByte
// Check slot presence in the access list
access := params.WarmStorageAccessAmsterdam
- _, slotPresent := evm.StateDB.SlotInAccessList(contract.Address(), slot)
+ _, slotPresent := evm.StateDB.SlotInAccessList(addr, slot)
if !slotPresent {
access = params.ColdStorageAccessAmsterdam
}
// Check access cost affordability before reading slot
- if contract.Gas.ExecutionGas < access {
+ if budget.ExecutionGas < access {
return GasCosts{}, errors.New("not enough gas for slot access")
}
if !slotPresent {
- evm.StateDB.AddSlotToAccessList(contract.Address(), slot)
+ evm.StateDB.AddSlotToAccessList(addr, slot)
}
// Read the slot value for gas cost measurement
- var (
- value = common.Hash(y.Bytes32())
- current, original = evm.StateDB.GetStateAndCommittedState(contract.Address(), slot)
- )
+ current, original := evm.StateDB.GetStateAndCommittedState(addr, slot)
if current == value { // noop (1)
return GasCosts{ExecutionGas: access}, nil
}
@@ -732,7 +730,7 @@ func gasSStore8037And8038(evm *EVM, contract *Contract, stack *Stack, mem *Memor
}
if original == value { // reset to original value (2.2.2)
if original == (common.Hash{}) { // reset to original inexistent slot (2.2.2.1)
- contract.Gas.RefundState(stateSet)
+ budget.RefundState(stateSet)
}
evm.StateDB.AddRefund(params.StorageWriteAmsterdam)
}
diff --git a/eth/api_backend_test.go b/eth/api_backend_test.go
index aa0539511b..57c2793d73 100644
--- a/eth/api_backend_test.go
+++ b/eth/api_backend_test.go
@@ -28,6 +28,7 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus/beacon"
"github.com/ethereum/go-ethereum/consensus/ethash"
+ "github.com/ethereum/go-ethereum/consensus/parlia"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/core/txpool"
@@ -180,3 +181,56 @@ func testSendTx(t *testing.T, withLocal bool) {
}
}
}
+
+func TestStateAtSystemTransactionGasBudget(t *testing.T) {
+ config := *params.ParliaTestChainConfig
+ config.Parlia = ¶ms.ParliaConfig{}
+ config.HaberTime, config.HaberFixTime, config.BohrTime, config.PascalTime = new(uint64), new(uint64), new(uint64), new(uint64)
+ config.PragueTime, config.LorentzTime, config.MaxwellTime, config.FermiTime = new(uint64), new(uint64), new(uint64), new(uint64)
+ config.OsakaTime, config.MendelTime, config.PasteurTime = new(uint64), new(uint64), new(uint64)
+ forkTime := uint64(2)
+ config.AmsterdamTime = &forkTime
+ config.BlobScheduleConfig = params.BSCChainConfig.BlobScheduleConfig
+ to := common.HexToAddress("0x1000")
+ genesis := &core.Genesis{Config: &config, Alloc: types.GenesisAlloc{
+ address: {Balance: big.NewInt(100)},
+ // The first transaction records whether more than 16M execution gas is available.
+ to: {Code: common.FromHex("0x63010000005a1160005500")},
+ }}
+ chain := newTestBlockChain(t, 0, genesis, nil)
+ defer chain.Stop()
+ parent := chain.GetBlockByNumber(0)
+ engine := parlia.New(&config, nil, nil, parent.Hash())
+ defer engine.Close()
+ backend := &Ethereum{blockchain: chain, engine: engine}
+ var txs []*types.Transaction
+ for nonce := uint64(0); nonce < 2; nonce++ {
+ txs = append(txs, types.MustSignNewTx(key, types.LatestSigner(&config), &types.LegacyTx{
+ Nonce: nonce, To: &to, Gas: math.MaxUint64 / 2, GasPrice: common.Big0,
+ }))
+ }
+ for _, timestamp := range []uint64{1, 2} {
+ t.Run(new(big.Int).SetUint64(timestamp).String(), func(t *testing.T) {
+ header := parent.Header()
+ header.Number, header.ParentHash = big.NewInt(1), parent.Hash()
+ header.Time, header.Coinbase, header.GasLimit = timestamp, address, 30_000_000
+ header.BaseFee, header.Difficulty = common.Big0, common.Big1
+ if timestamp >= forkTime {
+ slot := uint64(1)
+ header.SlotNumber = &slot
+ }
+ block := types.NewBlockWithHeader(header).WithBody(types.Body{Transactions: txs})
+ tx, _, statedb, release, err := backend.stateAtTransaction(context.Background(), block, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer release()
+ if tx.Hash() != txs[1].Hash() || statedb.GetNonce(address) != 1 {
+ t.Fatal("incorrect transaction or nonce after system transaction replay")
+ }
+ if have := statedb.GetState(to, common.Hash{}); have != common.BigToHash(common.Big1) {
+ t.Fatalf("incorrect system transaction prestate: have %s, want 1", have)
+ }
+ })
+ }
+}
diff --git a/eth/downloader/downloader_test.go b/eth/downloader/downloader_test.go
index 51b036e0c7..7a52a2d2e7 100644
--- a/eth/downloader/downloader_test.go
+++ b/eth/downloader/downloader_test.go
@@ -624,8 +624,10 @@ func assertOwnChain(t *testing.T, tester *downloadTester, length int) {
}
}
-func TestCanonicalSynchronisationFull(t *testing.T) { testCanonSync(t, eth.ETH70, FullSync, false) }
-func TestCanonicalSynchronisationSnap(t *testing.T) { testCanonSync(t, eth.ETH70, SnapSync, false) }
+func TestCanonicalSynchronisationFull(t *testing.T) { testCanonSync(t, eth.ETH70, FullSync, false) }
+func TestCanonicalSynchronisationSnap(t *testing.T) { testCanonSync(t, eth.ETH70, SnapSync, false) }
+func TestCanonicalSynchronisationFull71(t *testing.T) { testCanonSync(t, eth.ETH71, FullSync, false) }
+func TestCanonicalSynchronisationSnap71(t *testing.T) { testCanonSync(t, eth.ETH71, SnapSync, false) }
func testCanonSync(t *testing.T, protocol uint, mode SyncMode, snapV2 bool) {
success := make(chan struct{})
@@ -756,9 +758,10 @@ func makeBALChain(n int) (*core.Genesis, []*types.Block) {
// and end up attached to the imported blocks; and that syncing against peers
// which cannot (or do not) serve access lists still completes, importing the
// blocks without them.
-func TestBALSynchronisationFull(t *testing.T) { testBALSync(t, FullSync, eth.ETH71) }
-func TestBALSynchronisationSnap(t *testing.T) { testBALSync(t, SnapSync, eth.ETH71) }
-func TestBALSynchronisationLegacyPeer(t *testing.T) { testBALSync(t, FullSync, eth.ETH70) }
+func TestBALSynchronisationFull(t *testing.T) { testBALSync(t, FullSync, eth.ETH71) }
+func TestBALSynchronisationSnap(t *testing.T) { testBALSync(t, SnapSync, eth.ETH71) }
+func TestBALSynchronisationLegacyPeer(t *testing.T) { testBALSync(t, FullSync, eth.ETH70) }
+func TestBALSynchronisationLegacyPeer68(t *testing.T) { testBALSync(t, FullSync, eth.ETH68) }
func testBALSync(t *testing.T, mode SyncMode, protocol uint) {
gspec, blocks := makeBALChain(96) // long enough for a snap sync pivot below the head
diff --git a/eth/handler_eth_test.go b/eth/handler_eth_test.go
index cdf8cd60de..a58d94e84b 100644
--- a/eth/handler_eth_test.go
+++ b/eth/handler_eth_test.go
@@ -89,6 +89,7 @@ func (h *testEthHandler) Handle(peer *eth.Peer, packet eth.Packet) error {
// Tests that peers are correctly accepted (or rejected) based on the advertised
// fork IDs in the protocol handshake.
func TestForkIDSplit68(t *testing.T) { testForkIDSplit(t, eth.ETH68) }
+func TestForkIDSplit71(t *testing.T) { testForkIDSplit(t, eth.ETH71) }
func testForkIDSplit(t *testing.T, protocol uint) {
t.Parallel()
@@ -468,6 +469,7 @@ func testSendTransactions(t *testing.T, protocol uint) {
// Tests that transactions get propagated to all attached peers, either via direct
// broadcasts or via announcements/retrievals.
func TestTransactionPropagation68(t *testing.T) { testTransactionPropagation(t, eth.ETH68) }
+func TestTransactionPropagation71(t *testing.T) { testTransactionPropagation(t, eth.ETH71) }
func testTransactionPropagation(t *testing.T, protocol uint) {
t.Parallel()
@@ -546,7 +548,13 @@ func TestBroadcastBlock16Peers(t *testing.T) { testBroadcastBlock(t, 16, 4) }
func TestBroadcastBloc26Peers(t *testing.T) { testBroadcastBlock(t, 26, 5) }
func TestBroadcastBlock100Peers(t *testing.T) { testBroadcastBlock(t, 100, 10) }
+func TestBroadcastBlock71(t *testing.T) { testBroadcastBlockProtocol(t, eth.ETH71, 1, 1) }
+
func testBroadcastBlock(t *testing.T, peers, bcasts int) {
+ testBroadcastBlockProtocol(t, eth.ETH68, peers, bcasts)
+}
+
+func testBroadcastBlockProtocol(t *testing.T, protocol uint, peers, bcasts int) {
t.Parallel()
// Create a source handler to broadcast blocks from and a number of sinks
@@ -568,8 +576,8 @@ func testBroadcastBlock(t *testing.T, peers, bcasts int) {
defer sourcePipe.Close()
defer sinkPipe.Close()
- sourcePeer := eth.NewPeer(eth.ETH68, p2p.NewPeerPipe(enode.ID{byte(i)}, "", nil, sourcePipe), sourcePipe, nil, nil, nil)
- sinkPeer := eth.NewPeer(eth.ETH68, p2p.NewPeerPipe(enode.ID{0}, "", nil, sinkPipe), sinkPipe, nil, nil, nil)
+ sourcePeer := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{byte(i)}, "", nil, sourcePipe), sourcePipe, nil, nil, nil)
+ sinkPeer := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{0}, "", nil, sinkPipe), sinkPipe, nil, nil, nil)
defer sourcePeer.Close()
defer sinkPeer.Close()
@@ -579,7 +587,7 @@ func testBroadcastBlock(t *testing.T, peers, bcasts int) {
// Wait a bit for the above handlers to start
time.Sleep(100 * time.Millisecond)
- if err := sinkPeer.Handshake(1, source.chain, eth.BlockRangeUpdatePacket{}, td, nil); err != nil {
+ if err := sinkPeer.Handshake(1, source.chain, eth.BlockRangeUpdatePacket{LatestBlockHash: genesis.Hash()}, td, nil); err != nil {
t.Fatalf("failed to run protocol handshake")
}
go eth.Handle(sink, sinkPeer)
@@ -624,6 +632,7 @@ func testBroadcastBlock(t *testing.T, peers, bcasts int) {
// Tests that a propagated malformed block (uncles or transactions don't match
// with the hashes in the header) gets discarded and not broadcast forward.
func TestBroadcastMalformedBlock68(t *testing.T) { testBroadcastMalformedBlock(t, eth.ETH68) }
+func TestBroadcastMalformedBlock71(t *testing.T) { testBroadcastMalformedBlock(t, eth.ETH71) }
func testBroadcastMalformedBlock(t *testing.T, protocol uint) {
t.Parallel()
@@ -651,7 +660,7 @@ func testBroadcastMalformedBlock(t *testing.T, protocol uint) {
genesis = source.chain.Genesis()
td = source.chain.GetTd(genesis.Hash(), genesis.NumberU64())
)
- if err := sink.Handshake(1, source.chain, eth.BlockRangeUpdatePacket{}, td, nil); err != nil {
+ if err := sink.Handshake(1, source.chain, eth.BlockRangeUpdatePacket{LatestBlockHash: genesis.Hash()}, td, nil); err != nil {
t.Fatalf("failed to run protocol handshake")
}
// After the handshake completes, the source handler should stream the sink
diff --git a/eth/handler_test.go b/eth/handler_test.go
index 487558cd77..50c26ae9d3 100644
--- a/eth/handler_test.go
+++ b/eth/handler_test.go
@@ -36,6 +36,7 @@ import (
"github.com/ethereum/go-ethereum/core/txpool"
"github.com/ethereum/go-ethereum/core/txpool/blobpool"
"github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/types/bal"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto/kzg4844"
@@ -376,7 +377,7 @@ func (c *mockParlia) Finalize(chain consensus.ChainHeaderReader, header *types.H
return
}
-func (c *mockParlia) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks) (*types.Block, []*types.Receipt, error) {
+func (c *mockParlia) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt, tracer *tracing.Hooks, _ ...*bal.ConstructionBlockAccessList) (*types.Block, []*types.Receipt, error) {
// Finalize block
c.Finalize(chain, header, state, body, nil, nil, nil, tracer)
diff --git a/eth/protocols/eth/handler.go b/eth/protocols/eth/handler.go
index 21717b9f60..87e5d5c089 100644
--- a/eth/protocols/eth/handler.go
+++ b/eth/protocols/eth/handler.go
@@ -233,6 +233,9 @@ var eth70 = map[uint64]msgHandler{
}
var eth71 = map[uint64]msgHandler{
+ // Parlia retains block propagation alongside BAL exchange.
+ NewBlockHashesMsg: handleNewBlockhashes,
+ NewBlockMsg: handleNewBlock,
TransactionsMsg: handleTransactions,
NewPooledTransactionHashesMsg: handleNewPooledTransactionHashes,
GetBlockHeadersMsg: handleGetBlockHeaders,
diff --git a/eth/protocols/eth/handler_test.go b/eth/protocols/eth/handler_test.go
index e979c2f429..9281acbc58 100644
--- a/eth/protocols/eth/handler_test.go
+++ b/eth/protocols/eth/handler_test.go
@@ -184,6 +184,7 @@ func (b *testBackend) Handle(*Peer, Packet) error {
// Tests that block headers can be retrieved from a remote chain based on user queries.
func TestGetBlockHeaders68(t *testing.T) { testGetBlockHeaders(t, ETH68) }
+func TestGetBlockHeaders71(t *testing.T) { testGetBlockHeaders(t, ETH71) }
func testGetBlockHeaders(t *testing.T, protocol uint) {
t.Parallel()
@@ -397,6 +398,7 @@ func testGetBlockHeaders(t *testing.T, protocol uint) {
// Tests that block contents can be retrieved from a remote chain based on their hashes.
func TestGetBlockBodies68(t *testing.T) { testGetBlockBodies(t, ETH68) }
+func TestGetBlockBodies71(t *testing.T) { testGetBlockBodies(t, ETH71) }
func testGetBlockBodies(t *testing.T, protocol uint) {
t.Parallel()
@@ -697,7 +699,8 @@ func testGetBlockReceipts(t *testing.T, protocol uint) {
}
}
-func TestGetBlockPartialReceipts(t *testing.T) { testGetBlockPartialReceipts(t, ETH70) }
+func TestGetBlockPartialReceipts(t *testing.T) { testGetBlockPartialReceipts(t, ETH70) }
+func TestGetBlockPartialReceipts71(t *testing.T) { testGetBlockPartialReceipts(t, ETH71) }
func testGetBlockPartialReceipts(t *testing.T, protocol int) {
// First, generate the chain and overwrite the receipts.
@@ -964,7 +967,10 @@ func FuzzEthProtocolHandlers(f *testing.F) {
})
}
-func TestHandleNewBlock(t *testing.T) {
+func TestHandleNewBlock(t *testing.T) { testHandleNewBlock(t, ETH68) }
+func TestHandleNewBlock71(t *testing.T) { testHandleNewBlock(t, ETH71) }
+
+func testHandleNewBlock(t *testing.T, protocol uint) {
t.Parallel()
gen := func(n int, g *core.BlockGen) {
@@ -980,11 +986,6 @@ func TestHandleNewBlock(t *testing.T) {
backend := newTestBackendWithGenerator(maxBodiesServe+15, true, false, gen)
defer backend.close()
- peer, _ := newTestPeer("peer", ETH68, backend)
- defer peer.close()
-
- v := new(uint32)
- *v = 1
genBlobs := makeBlkBlobs(1, 2)
tx1 := types.NewTx(&types.BlobTx{
ChainID: new(uint256.Int).SetUint64(1),
@@ -1034,7 +1035,7 @@ func TestHandleNewBlock(t *testing.T) {
{
name: "Valid block",
msg: p2p.Msg{
- Code: 1,
+ Code: NewBlockMsg,
Size: uint32(sizeNonNil),
Payload: rNonNil,
},
@@ -1043,7 +1044,7 @@ func TestHandleNewBlock(t *testing.T) {
{
name: "Nil sidecars",
msg: p2p.Msg{
- Code: 2,
+ Code: NewBlockMsg,
Size: uint32(sizeNil),
Payload: rNil,
},
@@ -1054,7 +1055,7 @@ func TestHandleNewBlock(t *testing.T) {
protos := []p2p.Protocol{
{
Name: "eth",
- Version: ETH68,
+ Version: protocol,
},
{
Name: "bsc",
@@ -1064,7 +1065,7 @@ func TestHandleNewBlock(t *testing.T) {
caps := []p2p.Cap{
{
Name: "eth",
- Version: ETH68,
+ Version: protocol,
},
{
Name: "bsc",
@@ -1076,12 +1077,14 @@ func TestHandleNewBlock(t *testing.T) {
defer p2pEthSrc.Close()
defer p2pEthSink.Close()
- localEth := NewPeer(ETH68, p2p.NewPeerWithProtocols(enode.ID{1}, protos, "", caps), p2pEthSrc, nil, nil, backend.chain.Config())
+ localEth := NewPeer(protocol, p2p.NewPeerWithProtocols(enode.ID{1}, protos, "", caps), p2pEthSrc, nil, nil, backend.chain.Config())
+ defer localEth.Close()
// Run the tests
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
- err := handleNewBlock(backend, tc.msg, localEth)
+ go p2pEthSink.WriteMsg(tc.msg)
+ err := handleMessage(backend, localEth)
if err != tc.err {
t.Errorf("expected error %v, got %v", tc.err, err)
}
@@ -1089,13 +1092,20 @@ func TestHandleNewBlock(t *testing.T) {
}
}
-func TestHandleNewBlockhashes(t *testing.T) {
+func TestHandleNewBlockhashes(t *testing.T) { testHandleNewBlockhashes(t, ETH68) }
+func TestHandleNewBlockhashes71(t *testing.T) { testHandleNewBlockhashes(t, ETH71) }
+
+func testHandleNewBlockhashes(t *testing.T, protocol uint) {
t.Parallel()
backend := newTestBackendWithGenerator(1, false, false, nil)
defer backend.close()
- localEth := NewPeer(ETH68, p2p.NewPeer(enode.ID{1}, "peer", nil), nil, nil, nil, backend.chain.Config())
+ app, net := p2p.MsgPipe()
+ defer app.Close()
+ defer net.Close()
+ localEth := NewPeer(protocol, p2p.NewPeer(enode.ID{1}, "peer", nil), net, nil, nil, backend.chain.Config())
+ defer localEth.Close()
newPacket := func(n int) NewBlockHashesPacket {
ann := make(NewBlockHashesPacket, n)
@@ -1120,7 +1130,8 @@ func TestHandleNewBlockhashes(t *testing.T) {
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
- err := handleNewBlockhashes(backend, msgFor(newPacket(tc.count)), localEth)
+ go app.WriteMsg(msgFor(newPacket(tc.count)))
+ err := handleMessage(backend, localEth)
if tc.wantErr && err == nil {
t.Fatalf("expected error for %d announcements, got nil", tc.count)
}
diff --git a/eth/protocols/eth/handshake.go b/eth/protocols/eth/handshake.go
index 1a7f3aebcc..48a8ff419b 100644
--- a/eth/protocols/eth/handshake.go
+++ b/eth/protocols/eth/handshake.go
@@ -39,7 +39,7 @@ const (
// network IDs, difficulties, head and genesis blocks.
func (p *Peer) Handshake(networkID uint64, chain forkid.Blockchain, rangeMsg BlockRangeUpdatePacket, td *big.Int, extension *UpgradeStatusExtension) error {
switch p.version {
- case ETH70:
+ case ETH70, ETH71:
return p.handshake70(networkID, chain, rangeMsg, td)
case ETH68:
return p.handshake68(networkID, chain, td, extension)
diff --git a/eth/protocols/eth/handshake_test.go b/eth/protocols/eth/handshake_test.go
index 27b9ea022b..3d3c981188 100644
--- a/eth/protocols/eth/handshake_test.go
+++ b/eth/protocols/eth/handshake_test.go
@@ -19,6 +19,8 @@ package eth
import (
"errors"
"fmt"
+ "math/big"
+ "strings"
"testing"
"github.com/ethereum/go-ethereum/common"
@@ -30,6 +32,7 @@ import (
// Tests that handshake failures are detected and reported correctly.
func TestHandshake68(t *testing.T) { testHandshake(t, ETH68) }
func TestHandshake70(t *testing.T) { testHandshake(t, ETH70) }
+func TestHandshake71(t *testing.T) { testHandshake(t, ETH71) }
func testHandshake(t *testing.T, protocol uint) {
t.Parallel()
@@ -128,7 +131,7 @@ func testHandshake(t *testing.T, protocol uint) {
}
func TestHandshakeSuccess(t *testing.T) {
- for _, protocol := range []uint{ETH68, ETH70} {
+ for _, protocol := range []uint{ETH68, ETH70, ETH71} {
t.Run(fmt.Sprintf("eth/%d", protocol), func(t *testing.T) {
backend := newTestBackend(3)
defer backend.close()
@@ -163,9 +166,9 @@ func TestHandshakeSuccess(t *testing.T) {
if gotHead != head.Hash() || gotTD.Cmp(td) != 0 {
t.Fatalf("peer head mismatch: have (%s, %s), want (%s, %s)", gotHead, gotTD, head.Hash(), td)
}
- if protocol == ETH70 {
+ if protocol >= ETH70 {
if peer.statusExtension != nil {
- t.Fatal("eth/70 negotiated an upgrade status extension")
+ t.Fatalf("eth/%d negotiated an upgrade status extension", protocol)
}
if got := peer.BlockRange(); got == nil || *got != blockRange {
t.Fatalf("peer block range mismatch: have %+v, want %+v", got, blockRange)
@@ -177,3 +180,29 @@ func TestHandshakeSuccess(t *testing.T) {
})
}
}
+
+func TestHandshake71LargeTD(t *testing.T) {
+ backend := newTestBackend(1)
+ defer backend.close()
+ head := backend.chain.CurrentBlock()
+ td := backend.chain.GetTd(head.Hash(), head.Number.Uint64())
+ app, net := p2p.MsgPipe()
+ defer app.Close()
+ defer net.Close()
+ peer := NewPeer(ETH71, p2p.NewPeer(enode.ID{}, "peer", nil), net, nil, nil, backend.chain.Config())
+ defer peer.Close()
+ status := StatusPacket{
+ ProtocolVersion: ETH71,
+ NetworkID: 1,
+ TD: new(big.Int).Lsh(big.NewInt(1), 100),
+ Genesis: backend.chain.Genesis().Hash(),
+ ForkID: forkid.NewID(backend.chain.Config(), backend.chain.Genesis(), head.Number.Uint64(), head.Time),
+ LatestBlock: head.Number.Uint64(),
+ LatestBlockHash: head.Hash(),
+ }
+ go p2p.Send(app, StatusMsg, &status)
+ err := peer.Handshake(1, backend.chain, BlockRangeUpdatePacket{}, td, nil)
+ if err == nil || !strings.Contains(err.Error(), "too large total difficulty") {
+ t.Fatalf("expected oversized TD rejection, got %v", err)
+ }
+}
diff --git a/eth/protocols/eth/protocol.go b/eth/protocols/eth/protocol.go
index 2cbc031c08..cbb6240d6c 100644
--- a/eth/protocols/eth/protocol.go
+++ b/eth/protocols/eth/protocol.go
@@ -43,7 +43,7 @@ const ProtocolName = "eth"
// ProtocolVersions are the supported versions of the `eth` protocol (first
// is primary).
-var ProtocolVersions = []uint{ETH70, ETH68}
+var ProtocolVersions = []uint{ETH71, ETH68}
// protocolLengths are the number of implemented message corresponding to
// different protocol versions.
@@ -141,9 +141,8 @@ func (p *UpgradeStatusPacket) GetExtension() (*UpgradeStatusExtension, error) {
return extension, nil
}
-// StatusPacket is the network packet for the eth/70 status message. It follows
-// upstream eth/70, except that BSC retains TD for Parlia chain synchronization.
-// Unlike eth/68, eth/70 does not exchange UpgradeStatusMsg.
+// StatusPacket is the eth/70+ status message, retaining TD for Parlia synchronization.
+// Unlike eth/68, these versions do not exchange UpgradeStatusMsg.
type StatusPacket struct {
ProtocolVersion uint32
NetworkID uint64
diff --git a/eth/state_accessor.go b/eth/state_accessor.go
index e4497ef54f..ff212281ca 100644
--- a/eth/state_accessor.go
+++ b/eth/state_accessor.go
@@ -252,8 +252,6 @@ func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block,
if err != nil {
return nil, vm.BlockContext{}, nil, nil, err
}
- // upgrade built-in system contract before normal txs if Feynman is not enabled
- systemcontracts.TryUpdateBuildInSystemContract(eth.blockchain.Config(), block.Number(), parent.Time(), block.Time(), statedb, true)
// Insert parent beacon block root in the state as per EIP-4788.
context := core.NewEVMBlockContext(block.Header(), eth.blockchain, nil)
evm := vm.NewEVM(context, statedb, eth.blockchain.Config(), vm.Config{})
@@ -293,7 +291,7 @@ func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block,
// Assemble the transaction call message and return if the requested offset
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
if !beforeSystemTx {
- msg.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck()
+ msg.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck().SkipExecutionGasCapCheck()
}
// Not yet the searched for transaction, execute on top of the current state
diff --git a/eth/sync_test.go b/eth/sync_test.go
index 6e2bc59cb0..5739d0b731 100644
--- a/eth/sync_test.go
+++ b/eth/sync_test.go
@@ -106,14 +106,22 @@ func testSnapSyncDisabling(t *testing.T, ethVer uint, snapVer uint) {
}
func TestFullSyncWithBlobs(t *testing.T) {
- testChainSyncWithBlobs(t, ethconfig.FullSync, 128, 128)
+ testChainSyncWithBlobs(t, eth.ETH68, ethconfig.FullSync, 128, 128)
}
func TestSnapSyncWithBlobs(t *testing.T) {
- testChainSyncWithBlobs(t, ethconfig.SnapSync, 128, 128)
+ testChainSyncWithBlobs(t, eth.ETH68, ethconfig.SnapSync, 128, 128)
}
-func testChainSyncWithBlobs(t *testing.T, mode downloader.SyncMode, preCancunBlks, postCancunBlks uint64) {
+func TestFullSyncWithBlobs71(t *testing.T) {
+ testChainSyncWithBlobs(t, eth.ETH71, ethconfig.FullSync, 128, 128)
+}
+
+func TestSnapSyncWithBlobs71(t *testing.T) {
+ testChainSyncWithBlobs(t, eth.ETH71, ethconfig.SnapSync, 128, 128)
+}
+
+func testChainSyncWithBlobs(t *testing.T, ethVer uint, mode downloader.SyncMode, preCancunBlks, postCancunBlks uint64) {
t.Parallel()
config := *params.ParliaTestChainConfig
cancunTime := (preCancunBlks + 1) * 10
@@ -137,7 +145,6 @@ func testChainSyncWithBlobs(t *testing.T, mode downloader.SyncMode, preCancunBlk
checkChainWithBlobs(t, full.chain, preCancunBlks, postCancunBlks)
// Sync up the two handlers via both `eth` and `snap`
- ethVer := uint(eth.ETH68)
snapVer := uint(snap.SNAP1)
// Sync up the two handlers via both `eth` and `snap`
diff --git a/eth/tracers/api.go b/eth/tracers/api.go
index 9d05533148..b95c20b541 100644
--- a/eth/tracers/api.go
+++ b/eth/tracers/api.go
@@ -393,9 +393,6 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed
break
}
- // upgrade built-in system contract before normal txs if Feynman is not enabled
- systemcontracts.TryUpdateBuildInSystemContract(api.backend.ChainConfig(), next.Number(), block.Time(), next.Time(), statedb, true)
-
// Insert block's parent beacon block root in the state
// as per EIP-4788.
context := core.NewEVMBlockContext(next.Header(), api.chainContext(ctx), nil)
@@ -541,9 +538,6 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config
}
defer release()
- // upgrade built-in system contract before normal txs if Feynman is not enabled
- systemcontracts.TryUpdateBuildInSystemContract(api.backend.ChainConfig(), block.Number(), parent.Time(), block.Time(), statedb, true)
-
var (
roots []common.Hash
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
@@ -578,7 +572,7 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
if !beforeSystemTx {
- msg.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck()
+ msg.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck().SkipExecutionGasCapCheck()
}
statedb.SetTxContext(tx.Hash(), i, uint32(i+1))
if _, err := core.ApplyMessage(evm, msg, nil); err != nil {
@@ -627,8 +621,6 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
}
defer release()
- // upgrade built-in system contract before normal txs if Feynman is not enabled
- systemcontracts.TryUpdateBuildInSystemContract(api.backend.ChainConfig(), block.Number(), parent.Time(), block.Time(), statedb, true)
blockCtx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
evm := vm.NewEVM(blockCtx, statedb, api.backend.ChainConfig(), vm.Config{})
defer evm.Release()
@@ -776,7 +768,7 @@ txloop:
// Generate the next state snapshot fast without tracing
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
if !beforeSystemTx {
- msg.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck()
+ msg.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck().SkipExecutionGasCapCheck()
}
statedb.SetTxContext(tx.Hash(), i, uint32(i+1))
if _, err := core.ApplyMessage(evm, msg, nil); err != nil {
@@ -820,9 +812,6 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
}
defer release()
- // upgrade built-in system contract before normal txs if Feynman is not enabled
- systemcontracts.TryUpdateBuildInSystemContract(api.backend.ChainConfig(), block.Number(), parent.Time(), block.Time(), statedb, true)
-
// Retrieve the tracing configurations, or use default values
var (
logConfig logger.Config
@@ -877,7 +866,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
// Prepare the transaction for un-traced execution
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
if !beforeSystemTx {
- msg.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck()
+ msg.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck().SkipExecutionGasCapCheck()
}
if txHash != (common.Hash{}) && tx.Hash() != txHash {
// Process the tx to update state, but don't trace it.
@@ -1160,7 +1149,8 @@ func (api *API) traceTx(ctx context.Context, tx *types.Transaction, message *cor
// Run the transaction with tracing enabled.
if isSystemTx {
intrinsicGas, _ = core.IntrinsicGas(message.Data, message.AccessList, message.SetCodeAuthorizations, message.From, message.To, message.Value, evm.GetRules())
- message.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck()
+ // Parlia system transactions are not subject to the execution gas cap.
+ message.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck().SkipExecutionGasCapCheck()
}
// Call Prepare to clear out the statedb access list
diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go
index e32af4a899..34b79c5670 100644
--- a/eth/tracers/api_test.go
+++ b/eth/tracers/api_test.go
@@ -23,6 +23,7 @@ import (
"encoding/json"
"errors"
"fmt"
+ "math"
"math/big"
"os"
"reflect"
@@ -49,6 +50,7 @@ import (
"github.com/ethereum/go-ethereum/internal/ethapi/override"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rpc"
+ "github.com/holiman/uint256"
)
var (
@@ -1990,3 +1992,91 @@ func TestTraceCallDefaultsToLatest(t *testing.T) {
t.Errorf("omitted-block result %s != latest result %s", omitted, latest)
}
}
+
+func TestTraceSystemTransactionGasBudget(t *testing.T) {
+ config := *params.MergedTestChainConfig
+ config.Parlia = ¶ms.ParliaConfig{}
+ config.Ethash = nil
+ forkTime := uint64(2)
+ config.AmsterdamTime = &forkTime
+ accounts := newAccounts(1)
+ from, to := accounts[0].addr, common.HexToAddress("0x1000")
+ for _, timestamp := range []uint64{1, 2} {
+ for _, tc := range []struct {
+ name string
+ code []byte
+ system bool
+ }{
+ // Memory expansion needs more gas than an ordinary transaction can execute with.
+ {"system-memory", common.FromHex("0x600063003000005200"), true},
+ {"system-gas-branch", common.FromHex("0x63010000005a1160005500"), true},
+ {"ordinary-memory", common.FromHex("0x600063003000005200"), false},
+ } {
+ t.Run(fmt.Sprintf("%d/%s", timestamp, tc.name), func(t *testing.T) {
+ blockCtx := vm.BlockContext{
+ CanTransfer: core.CanTransfer, Transfer: core.Transfer,
+ GetHash: func(uint64) common.Hash { return common.Hash{} },
+ Coinbase: from, BlockNumber: big.NewInt(1), Time: timestamp,
+ Difficulty: common.Big1, GasLimit: 30_000_000,
+ BaseFee: new(big.Int), BlobBaseFee: new(big.Int),
+ CostPerStateByte: params.CostPerStateByte,
+ }
+ if timestamp >= forkTime {
+ blockCtx.SlotNum = blockCtx.BlockNumber.Uint64()
+ }
+ statedb, err := state.New(types.EmptyRootHash, state.NewDatabaseForTesting())
+ if err != nil {
+ t.Fatal(err)
+ }
+ statedb.SetCode(to, tc.code, tracing.CodeChangeUnspecified)
+ rules := config.Rules(blockCtx.BlockNumber, false, timestamp)
+ statedb.Finalise(rules)
+ gasLimit := uint64(math.MaxUint64 / 2)
+ if !tc.system {
+ gasLimit = params.MaxTxGas
+ if timestamp >= forkTime {
+ gasLimit = blockCtx.GasLimit
+ }
+ }
+ tx := types.MustSignNewTx(accounts[0].key, types.LatestSigner(&config), &types.LegacyTx{
+ To: &to, Gas: gasLimit, GasPrice: common.Big0,
+ })
+ msg, err := core.TransactionToMessage(tx, types.MakeSigner(&config, blockCtx.BlockNumber, timestamp), common.Big0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ actual := statedb.Copy()
+ result, err := NewAPI(&testBackend{chainConfig: &config}).traceTx(context.Background(), tx, msg,
+ &Context{TxHash: tx.Hash()}, blockCtx, statedb, nil, tc.system, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var trace logger.ExecutionResult
+ if err := json.Unmarshal(result.(json.RawMessage), &trace); err != nil {
+ t.Fatal(err)
+ }
+ if !tc.system {
+ if !trace.Failed || trace.Gas != params.MaxTxGas {
+ t.Fatalf("ordinary transaction execution cap changed: failed=%v gas=%d", trace.Failed, trace.Gas)
+ }
+ return
+ }
+ evm := vm.NewEVM(blockCtx, actual, &config, vm.Config{})
+ defer evm.Release()
+ actual.Prepare(rules, from, from, &to, vm.ActivePrecompiles(rules), nil)
+ budget := vm.NewGasBudget(gasLimit, 0)
+ _, remaining, err := evm.Call(from, to, nil, budget, new(uint256.Int))
+ if err != nil {
+ t.Fatal(err)
+ }
+ actual.SetNonce(from, 1, tracing.NonceChangeEoACall)
+ if trace.Failed || trace.Gas != remaining.Used(budget) {
+ t.Fatalf("system transaction gas mismatch: failed=%v have=%d want=%d", trace.Failed, trace.Gas, remaining.Used(budget))
+ }
+ if statedb.IntermediateRoot(rules) != actual.IntermediateRoot(rules) {
+ t.Fatal("traced system transaction state differs from execution")
+ }
+ })
+ }
+ }
+}
diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
index 186ebb12c3..4c006a56a4 100644
--- a/internal/ethapi/api.go
+++ b/internal/ethapi/api.go
@@ -1402,7 +1402,6 @@ func (api *BlockChainAPI) replay(ctx context.Context, block *types.Block, accoun
// Block level pre-execution, in the same order as core.StateProcessor.Process. Without it the
// system contracts touched here keep their parent values and transactions reading them diverge.
config := api.b.ChainConfig()
- systemcontracts.TryUpdateBuildInSystemContract(config, block.Number(), parent.Time(), block.Time(), statedb, true)
evm := vm.NewEVM(core.NewEVMBlockContext(block.Header(), api.b.Chain(), nil), statedb, config, vm.Config{})
defer evm.Release()
core.PreExecution(ctx, block.BeaconRoot(), parent.Header(), config, evm, block.Number(), block.Time())
@@ -1438,7 +1437,7 @@ func (api *BlockChainAPI) replay(ctx context.Context, block *types.Block, accoun
if posa, ok := api.b.Engine().(consensus.PoSA); ok {
if isSystem, _ := posa.IsSystemTransaction(tx, block.Header()); isSystem {
- msg.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck()
+ msg.SkipNonceCheck().SkipEOACheck().SkipGasLimitCapCheck().SkipExecutionGasCapCheck()
balance := statedb.GetBalance(consensus.SystemAddress)
if balance.Cmp(common.U2560) > 0 {
statedb.SetBalance(consensus.SystemAddress, uint256.NewInt(0), tracing.BalanceChangeUnspecified)
diff --git a/internal/ethapi/override/bsc.go b/internal/ethapi/override/bsc.go
index 396306e100..28b614db95 100644
--- a/internal/ethapi/override/bsc.go
+++ b/internal/ethapi/override/bsc.go
@@ -63,8 +63,15 @@ func (o *BlockOverrides) ApplyBSC(blockCtx *vm.BlockContext) error {
// ApplyFor applies BSC-specific block overrides only on BSC chains.
func (o *BlockOverrides) ApplyFor(cfg *params.ChainConfig, blockCtx *vm.BlockContext) error {
- if cfg != nil && cfg.IsInBSC() {
- return o.ApplyBSC(blockCtx)
+ if cfg != nil && cfg.IsInBSC() && o != nil {
+ if err := o.ApplyBSC(blockCtx); err != nil {
+ return err
+ }
+ blockCtx.SlotNum = 0
+ if cfg.IsAmsterdam(blockCtx.BlockNumber, blockCtx.Time) {
+ blockCtx.SlotNum = blockCtx.BlockNumber.Uint64()
+ }
+ return nil
}
return o.Apply(blockCtx)
}
@@ -80,8 +87,14 @@ func (o *BlockOverrides) MakeHeaderBSC(header *types.Header) *types.Header {
// MakeHeaderFor applies BSC-specific header overrides only on BSC chains.
func (o *BlockOverrides) MakeHeaderFor(cfg *params.ChainConfig, header *types.Header) *types.Header {
- if cfg != nil && cfg.IsInBSC() {
- return o.MakeHeaderBSC(header)
+ if cfg != nil && cfg.IsInBSC() && o != nil {
+ h := o.MakeHeaderBSC(header)
+ h.SlotNumber = nil
+ if cfg.IsAmsterdam(h.Number, h.Time) {
+ slot := h.Number.Uint64()
+ h.SlotNumber = &slot
+ }
+ return h
}
return o.MakeHeader(header)
}
diff --git a/internal/ethapi/override/bsc_test.go b/internal/ethapi/override/bsc_test.go
index 503df61aed..e1ec7609cf 100644
--- a/internal/ethapi/override/bsc_test.go
+++ b/internal/ethapi/override/bsc_test.go
@@ -3,9 +3,14 @@ package override
import (
"math"
"math/big"
+ "reflect"
"testing"
"github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/params"
)
func TestBSCMilliRemainder(t *testing.T) {
@@ -46,3 +51,57 @@ func TestBSCMilliTimestampBounds(t *testing.T) {
}
}
}
+
+func TestBSCSlotNumberOverrides(t *testing.T) {
+ slot := func(v uint64) *uint64 { return &v }
+ number := hexutil.Big(*big.NewInt(200))
+ before, after := hexutil.Uint64(19), hexutil.Uint64(20)
+ for _, test := range []struct {
+ name string
+ bsc bool
+ timestamp uint64
+ parentSlot *uint64
+ overrides *BlockOverrides
+ want *uint64
+ }{
+ {name: "number", bsc: true, timestamp: 20, parentSlot: slot(100), overrides: &BlockOverrides{Number: &number}, want: slot(200)},
+ {name: "first-fork", bsc: true, timestamp: 19, overrides: &BlockOverrides{Time: &after}, want: slot(100)},
+ {name: "before-fork", bsc: true, timestamp: 20, parentSlot: slot(100), overrides: &BlockOverrides{Time: &before}},
+ {name: "both", bsc: true, timestamp: 19, overrides: &BlockOverrides{Number: &number, Time: &after}, want: slot(200)},
+ {name: "nil", bsc: true, timestamp: 20, parentSlot: slot(100), want: slot(100)},
+ {name: "empty", bsc: true, timestamp: 20, parentSlot: slot(100), overrides: &BlockOverrides{}, want: slot(100)},
+ {name: "eth-number", timestamp: 20, parentSlot: slot(500), overrides: &BlockOverrides{Number: &number}, want: slot(500)},
+ {name: "eth-first-fork", timestamp: 19, overrides: &BlockOverrides{Time: &after}},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ fork := uint64(20)
+ cfg := ¶ms.ChainConfig{LondonBlock: big.NewInt(0), AmsterdamTime: &fork}
+ if test.bsc {
+ cfg.Parlia = ¶ms.ParliaConfig{}
+ }
+ header := &types.Header{Number: big.NewInt(100), Time: test.timestamp, SlotNumber: test.parentSlot}
+ original := types.CopyHeader(header)
+ ctx := vm.BlockContext{BlockNumber: big.NewInt(100), Time: test.timestamp}
+ if header.SlotNumber != nil {
+ ctx.SlotNum = *header.SlotNumber
+ }
+ if err := test.overrides.ApplyFor(cfg, &ctx); err != nil {
+ t.Fatal(err)
+ }
+ got := test.overrides.MakeHeaderFor(cfg, header)
+ want := uint64(0)
+ if test.want != nil {
+ want = *test.want
+ }
+ if ctx.SlotNum != want || !reflect.DeepEqual(got.SlotNumber, test.want) {
+ t.Fatalf("slot context=%d header=%v, want %v", ctx.SlotNum, got.SlotNumber, test.want)
+ }
+ if ctx.BlockNumber.Cmp(got.Number) != 0 || ctx.Time != got.Time {
+ t.Fatal("header/context mismatch")
+ }
+ if !reflect.DeepEqual(types.CopyHeader(header), original) {
+ t.Fatal("override mutated the original header")
+ }
+ })
+ }
+}
diff --git a/internal/ethapi/simulate.go b/internal/ethapi/simulate.go
index 41586513d8..95ed0cfb48 100644
--- a/internal/ethapi/simulate.go
+++ b/internal/ethapi/simulate.go
@@ -36,6 +36,7 @@ import (
"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/state"
+ "github.com/ethereum/go-ethereum/core/systemcontracts"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/types/bal"
"github.com/ethereum/go-ethereum/core/vm"
@@ -529,6 +530,10 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header,
if sim.chainConfig.IsShanghai(header.Number, header.Time) {
blockBody.Withdrawals = *block.BlockOverrides.Withdrawals
}
+ if sim.isBSC() {
+ // Simulation omits Parlia system transactions but still applies contract upgrades.
+ systemcontracts.TryUpdateBuildInSystemContract(sim.chainConfig, header.Number, parent.Time, header.Time, sim.state, false)
+ }
// Process the withdrawals and EIP-7685 requests
requests, bal, err := core.PostExecution(ctx, sim.chainConfig, header.Number, header.Time, allLogs, blockBody.Withdrawals, evm, uint32(len(block.Calls)+1))
if err != nil {
@@ -734,9 +739,13 @@ func (sim *simulator) makeHeaders(blocks []simBlock) ([]*types.Header, error) {
if overrides.Difficulty != nil && difficulty.Sign() == 0 {
return nil, &invalidParamsError{fmt.Sprintf("block %d: difficulty override is not allowed after the merge", number)}
}
- // The slot number is unknown when the parent has none, so it is omitted then.
var slotNumber *uint64
- if header.SlotNumber != nil {
+ if sim.isBSC() {
+ if sim.chainConfig.IsAmsterdam(number, timestamp) {
+ slot := number.Uint64()
+ slotNumber = &slot
+ }
+ } else if header.SlotNumber != nil {
slot := *header.SlotNumber + 1
slotNumber = &slot
}
diff --git a/internal/ethapi/simulate_test.go b/internal/ethapi/simulate_test.go
index 8b9397b8b0..4871028e8e 100644
--- a/internal/ethapi/simulate_test.go
+++ b/internal/ethapi/simulate_test.go
@@ -19,11 +19,13 @@ package ethapi
import (
"encoding/json"
"math/big"
+ "reflect"
"testing"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/internal/ethapi/override"
+ "github.com/ethereum/go-ethereum/params"
)
func TestSimulateSanitizeBlockOrder(t *testing.T) {
@@ -149,3 +151,42 @@ func TestSimBlockUnmarshalOverrideKeys(t *testing.T) {
}
}
}
+
+func TestSimulateSlotNumber(t *testing.T) {
+ slot := func(v uint64) *uint64 { return &v }
+ for _, test := range []struct {
+ name string
+ bsc bool
+ parentSlot *uint64
+ timestamp uint64
+ want *uint64
+ }{
+ {name: "bsc-before-fork", bsc: true, timestamp: 19},
+ {name: "bsc-first-fork", bsc: true, timestamp: 20, want: slot(101)},
+ {name: "bsc-next", bsc: true, timestamp: 21, parentSlot: slot(100), want: slot(101)},
+ {name: "eth-first-fork", timestamp: 20},
+ {name: "eth-next", timestamp: 21, parentSlot: slot(500), want: slot(501)},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ fork := uint64(20)
+ cfg := ¶ms.ChainConfig{LondonBlock: big.NewInt(0), AmsterdamTime: &fork}
+ if test.bsc {
+ cfg.Parlia = ¶ms.ParliaConfig{}
+ }
+ parentTime := uint64(18)
+ if test.parentSlot != nil {
+ parentTime = 20
+ }
+ sim := &simulator{chainConfig: cfg, base: &types.Header{Number: big.NewInt(100), Time: parentTime,
+ Difficulty: big.NewInt(2), GasLimit: 30_000_000, BaseFee: big.NewInt(0), SlotNumber: test.parentSlot}}
+ number, timestamp := hexutil.Big(*big.NewInt(101)), hexutil.Uint64(test.timestamp)
+ headers, err := sim.makeHeaders([]simBlock{{BlockOverrides: &override.BlockOverrides{Number: &number, Time: ×tamp}}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(headers[0].SlotNumber, test.want) {
+ t.Fatalf("slot: have %v, want %v", headers[0].SlotNumber, test.want)
+ }
+ })
+ }
+}
diff --git a/miner/bid_simulator.go b/miner/bid_simulator.go
index 46fb07a14b..fe8c02d3aa 100644
--- a/miner/bid_simulator.go
+++ b/miner/bid_simulator.go
@@ -478,11 +478,16 @@ func (b *bidSimulator) newBidLoop() {
continue
}
- // Pre-check before simulation for fast feedback to the builder;
- // simulation would reject these txs anyway via state_transition preCheck.
- if errCap := b.checkIfBidExceedsTxGasLimit(newBid.bid); errCap != nil {
+ // Builders cannot produce the Amsterdam activation block, so parent rules suffice here.
+ parent := b.chain.GetHeaderByHash(newBid.bid.ParentHash)
+ if parent == nil {
+ err = consensus.ErrUnknownAncestor
+ } else {
+ err = b.checkIfBidExceedsTxGasLimit(newBid.bid, parent)
+ }
+ if err != nil {
if newBid.feedback != nil {
- newBid.feedback <- errCap
+ newBid.feedback <- err
}
continue
}
@@ -578,21 +583,23 @@ func (b *bidSimulator) getBlockInterval(parentHeader *types.Header) uint64 {
}
// checkIfBidExceedsTxGasLimit checks whether any transaction in the bid exceeds the max txn gas.
-func (b *bidSimulator) checkIfBidExceedsTxGasLimit(bid *buildertypes.Bid) error {
- currentHeader := b.chain.CurrentBlock()
- if !b.chainConfig.IsOsaka(currentHeader.Number, currentHeader.Time) {
+func (b *bidSimulator) checkIfBidExceedsTxGasLimit(bid *buildertypes.Bid, header *types.Header) error {
+ cap := params.MaxTxGas
+ if b.chainConfig.IsAmsterdam(header.Number, header.Time) {
+ cap = params.MaxTxTotalGas
+ } else if !b.chainConfig.IsOsaka(header.Number, header.Time) {
return nil
}
for _, tx := range bid.Txs {
- if tx.Gas() > params.MaxTxGas {
+ if tx.Gas() > cap {
log.Debug("discard bid due to per-tx gas limit",
"block", bid.BlockNumber,
"bidHash", bid.Hash().TerminalString(),
"txHash", tx.Hash().TerminalString(),
"txGas", tx.Gas(),
- "txGasLimit", params.MaxTxGas,
+ "txGasLimit", cap,
)
- return fmt.Errorf("bid rejected: %w (cap: %d, tx: %d)", core.ErrGasLimitTooHigh, params.MaxTxGas, tx.Gas())
+ return fmt.Errorf("bid rejected: %w (cap: %d, tx: %d)", core.ErrGasLimitTooHigh, cap, tx.Gas())
}
}
return nil
@@ -734,6 +741,9 @@ func (b *bidSimulator) preSealVerifyBidBlock(decoded *buildertypes.DecodedBidBlo
if parent == nil {
return consensus.ErrUnknownAncestor
}
+ if isAmsterdamActivation(b.chainConfig, parent, header) {
+ return errors.New("builder bids disabled on Amsterdam activation block")
+ }
expectedGasLimit := core.CalcGasLimit(parent.GasLimit, b.bidWorker.getGasCeil())
if header.GasLimit != expectedGasLimit {
return fmt.Errorf("invalid gasLimit: got %d, want %d", header.GasLimit, expectedGasLimit)
@@ -764,9 +774,13 @@ func (b *bidSimulator) preSealVerifyBidBlock(decoded *buildertypes.DecodedBidBlo
}
// Per-tx gas cap over user txs only, mirroring SendBid.
+ cap := params.MaxTxGas
+ if b.chainConfig.IsAmsterdam(header.Number, header.Time) {
+ cap = params.MaxTxTotalGas
+ }
for _, tx := range decoded.Txs[:decoded.SystemTxStart] {
- if tx.Gas() > params.MaxTxGas {
- return fmt.Errorf("%w (cap: %d, tx: %d)", core.ErrGasLimitTooHigh, params.MaxTxGas, tx.Gas())
+ if tx.Gas() > cap {
+ return fmt.Errorf("%w (cap: %d, tx: %d)", core.ErrGasLimitTooHigh, cap, tx.Gas())
}
}
@@ -1051,27 +1065,27 @@ func (b *bidSimulator) simBid(interruptCh chan int32, bidRuntime *BidRuntime) {
return
}
- // TODO: Adapt this reservation to both gas dimensions before enabling
- // Amsterdam on BSC.
- // Reserve gas for the payBidTx appended at the end of the block so the
- // admission check and greedy merge leave room for it; returned right before
- // it is committed.
- if err = bidRuntime.env.gasPool.CheckGasLegacy(params.PayBidTxGasLimit); err != nil {
+ parent := b.chain.GetHeaderByHash(bidRuntime.env.header.ParentHash)
+ if parent == nil {
+ err = consensus.ErrUnknownAncestor
return
}
-
- // error log:
- // simulation failed blockNumber=47630147 parentHash=0x2476bcc93db4c924a2c8079c6d5d783441a72d6ff70c5850b1afd778102e175e builder=0x48a5Ed9abC1a8FBe86ceC4900483f43a7f2dBB48
- // gasUsed=136807406 gasLimit=137816878 err="gas used exceeds gas limit"
- // error tracing:
- // left: b.RawBid.GasUsed + b.PayBidTxGasUsed => (136782406 + 25000 = 136807406)
- // right: headerGasLimit - b.PayBidTxGasLimit - systemGasReserved => (137816878 - 25000 - 1000000 = 136791878)
- // cause: 136807406 > 136791878 => true
- // error reason:
- // left should not be added with PayBidTxGasUsed, Or right should be not be subtracted with PayBidTxGasLimit
- // error fix:
- // 136782406 > 136791878 => false, Or 136807406 > 136816878 => false
- if bidRuntime.bid.GasUsed > bidRuntime.env.gasPool.Available(bidRuntime.env.evm.GetRules().IsAmsterdam) {
+ if isAmsterdamActivation(b.chainConfig, parent, bidRuntime.env.header) {
+ err = errors.New("builder bids disabled on Amsterdam activation block")
+ return
+ }
+ amsterdam := bidRuntime.env.evm.GetRules().IsAmsterdam
+ // Leave both budgets available for the payment appended after greedy merge.
+ if amsterdam {
+ err = bidRuntime.env.gasPool.ReserveGasAmsterdam(min(payBidTx.Gas(), params.MaxTxGas), payBidTx.Gas())
+ } else {
+ err = bidRuntime.env.gasPool.CheckGasLegacy(params.PayBidTxGasLimit)
+ }
+ if err != nil {
+ return
+ }
+ // Amsterdam validates capacity per transaction in both dimensions, not by receipt gas sums.
+ if !amsterdam && bidRuntime.bid.GasUsed > bidRuntime.env.gasPool.Available(false) {
err = errors.New("gas used exceeds gas limit")
return
}
@@ -1205,7 +1219,14 @@ func (b *bidSimulator) simBid(interruptCh chan int32, bidRuntime *BidRuntime) {
}
// commit payBidTx at the end of the block
- bidRuntime.env.gasPool.AddGas(params.PayBidTxGasLimit)
+ if amsterdam {
+ err = bidRuntime.env.gasPool.ReleaseGasAmsterdam(min(payBidTx.Gas(), params.MaxTxGas), payBidTx.Gas())
+ } else {
+ err = bidRuntime.env.gasPool.AddGas(params.PayBidTxGasLimit)
+ }
+ if err != nil {
+ return
+ }
err = bidRuntime.commitTransaction(b.chain, b.chainConfig, payBidTx, true)
if err != nil {
log.Error("BidSimulator: failed to commit tx", "builder", bidRuntime.bid.Builder,
@@ -1214,7 +1235,7 @@ func (b *bidSimulator) simBid(interruptCh chan int32, bidRuntime *BidRuntime) {
return
}
- if err = bidRuntime.env.lane.VerifyPackedBid(bidRuntime.env.gasPool.Available(bidRuntime.env.evm.GetRules().IsAmsterdam)); err != nil {
+ if err = bidRuntime.env.lane.VerifyPackedBid(bidRuntime.env.gasPool); err != nil {
log.Warn("BidSimulator: bid rejected by the payment lane", "builder", bidRuntime.bid.Builder,
"bidHash", bidRuntime.bid.Hash(), "err", err)
return
@@ -1388,7 +1409,7 @@ func (r *BidRuntime) commitTransaction(chain *core.BlockChain, chainConfig *para
}
laneType := env.lane.Classify(tx)
- usedBefore := env.gasPool.Used()
+ usedBefore := env.gasPool.Snapshot()
receipt, txBAL, err := core.ApplyTransaction(context.Background(), env.evm, env.gasPool, env.state, env.header, tx)
if err != nil {
diff --git a/miner/lane_regression_test.go b/miner/lane_regression_test.go
index cb58611d87..8191269f40 100644
--- a/miner/lane_regression_test.go
+++ b/miner/lane_regression_test.go
@@ -14,6 +14,7 @@ import (
"github.com/ethereum/go-ethereum/core/paymentlane"
"github.com/ethereum/go-ethereum/core/systemcontracts/jenner"
"github.com/ethereum/go-ethereum/core/types"
+ buildertypes "github.com/ethereum/go-ethereum/core/types/builder"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/params"
"github.com/stretchr/testify/require"
@@ -119,3 +120,110 @@ func TestBidCommitTransactionBooksNothingForAFailedTransaction(t *testing.T) {
require.NotZero(t, env.gasPool.Used(), "buyGas must have drawn from the pool, or the test proves nothing")
require.Zero(t, env.lane.Budget.PaymentLaneUsed, "a failed transaction must not book lane gas")
}
+
+func TestPaymentLaneWorkerRollback(t *testing.T) {
+ for _, amsterdam := range []bool{false, true} {
+ t.Run(map[bool]string{false: "legacy", true: "amsterdam"}[amsterdam], func(t *testing.T) {
+ w, config, parent, header, key := laneMinerChain(t, false)
+ if amsterdam {
+ config.AmsterdamTime = &header.Time
+ }
+ env, err := w.makeEnv(parent, header, common.Address{}, nil, false)
+ require.NoError(t, err)
+ defer env.discard()
+ require.True(t, env.lane.On())
+ sender := crypto.PubkeyToAddress(key.PublicKey)
+ balance := env.state.GetBalance(sender).ToBig()
+ if amsterdam {
+ require.NoError(t, env.gasPool.ReserveGasAmsterdam(25_000, 300_000))
+ }
+ before := env.gasPool.Snapshot()
+ pool := env.gasPool.String()
+ tx, err := types.SignTx(types.NewTransaction(0, common.Address{0xaa}, big.NewInt(1), 1, big.NewInt(1), nil), types.LatestSigner(config), key)
+ require.NoError(t, err)
+ require.Equal(t, paymentlane.PaymentLane, env.lane.Classify(tx))
+ _, err = w.applyTransaction(env, tx)
+ require.ErrorIs(t, err, core.ErrIntrinsicGas)
+ require.Equal(t, pool, env.gasPool.String())
+ require.Equal(t, before, env.gasPool)
+ require.Equal(t, balance, env.state.GetBalance(sender).ToBig())
+ require.Zero(t, env.lane.PaymentGasUsed())
+ require.Equal(t, env.lane.Budget.PaymentLaneQuota, env.lane.IdleGas())
+ })
+ }
+}
+
+func TestBidPaymentGasReservation(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ amsterdam bool
+ gas uint64
+ }{
+ {"legacy", false, params.PayBidTxGasLimit},
+ {"amsterdam", true, params.PayBidTxGasLimit},
+ {"amsterdam-state-creation", true, 300_000},
+ {"amsterdam-above-execution-cap", true, 30_000_000},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ w, config, parent, header, key := laneMinerChain(t, false)
+ if tc.amsterdam {
+ zero := uint64(0)
+ config.AmsterdamTime = &zero
+ slot := header.Number.Uint64()
+ header.SlotNumber = &slot
+ }
+ header.ExcessBlobGas = new(uint64)
+ header.BlobGasUsed = new(uint64)
+ env, err := w.makeEnv(parent, header, common.Address{}, nil, false)
+ require.NoError(t, err)
+ defer env.discard()
+ sender := crypto.PubkeyToAddress(key.PublicKey)
+ recipient := common.Address{0xaa}
+ payee := sender
+ if tc.gas == 300_000 {
+ payee = recipient
+ }
+ pay, err := types.SignTx(types.NewTransaction(1, payee, big.NewInt(1), tc.gas, common.Big0, nil), types.LatestSigner(config), key)
+ require.NoError(t, err)
+ if tc.amsterdam {
+ require.NoError(t, env.gasPool.ReserveGasAmsterdam(min(pay.Gas(), params.MaxTxGas), pay.Gas()))
+ } else {
+ require.NoError(t, env.gasPool.CheckGasLegacy(params.PayBidTxGasLimit))
+ }
+ if tc.amsterdam {
+ require.Zero(t, env.gasPool.Used())
+ require.Zero(t, env.lane.PaymentGasUsed())
+ }
+ // The preceding payment must be booked even while the final payment has a reservation.
+ tx, err := types.SignTx(types.NewTransaction(0, sender, big.NewInt(1), 25_000, common.Big0, nil), types.LatestSigner(config), key)
+ require.NoError(t, err)
+ r := &BidRuntime{env: env, bid: &buildertypes.Bid{}}
+ require.NoError(t, r.commitTransaction(w.chain, config, tx, true))
+ if tc.amsterdam {
+ require.Equal(t, uint64(12_000), env.lane.PaymentGasUsed())
+ } else {
+ require.Equal(t, uint64(21_000), env.lane.PaymentGasUsed())
+ }
+ before := env.gasPool.Snapshot()
+ if tc.amsterdam {
+ require.NoError(t, env.gasPool.ReleaseGasAmsterdam(min(pay.Gas(), params.MaxTxGas), pay.Gas()))
+ } else {
+ require.NoError(t, env.gasPool.AddGas(params.PayBidTxGasLimit))
+ }
+ require.Equal(t, before.CumulativeUsed(), env.gasPool.CumulativeUsed())
+ require.NoError(t, r.commitTransaction(w.chain, config, pay, true))
+ require.Equal(t, types.ReceiptStatusSuccessful, env.receipts[1].Status)
+ require.NoError(t, env.lane.VerifyPackedBid(env.gasPool))
+ if tc.amsterdam {
+ require.Equal(t, max(env.gasPool.CumulativeExecution(), env.gasPool.CumulativeState()), env.lane.PaymentGasUsed())
+ require.Equal(t, env.receipts[0].GasUsed+env.receipts[1].GasUsed, env.gasPool.CumulativeUsed())
+ if payee == recipient {
+ require.Equal(t, uint64(params.AccountCreationSize)*env.evm.Context.CostPerStateByte, env.gasPool.CumulativeState())
+ }
+ } else {
+ require.Equal(t, uint64(42_000), env.gasPool.Used())
+ require.Equal(t, uint64(42_000), env.lane.PaymentGasUsed())
+ }
+ })
+ }
+}
diff --git a/miner/miner_mev.go b/miner/miner_mev.go
index 3a69c67a3f..879e86bb6d 100644
--- a/miner/miner_mev.go
+++ b/miner/miner_mev.go
@@ -14,6 +14,7 @@ import (
buildertypes "github.com/ethereum/go-ethereum/core/types/builder"
"github.com/ethereum/go-ethereum/internal/version"
"github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/params"
)
const (
@@ -21,6 +22,11 @@ const (
maxBlobTxPerBlock = 6
)
+// isAmsterdamActivation identifies the block validators must build locally.
+func isAmsterdamActivation(config *params.ChainConfig, parent, header *types.Header) bool {
+ return !config.IsAmsterdam(parent.Number, parent.Time) && config.IsAmsterdam(header.Number, header.Time)
+}
+
// MevRunning return true if mev is running.
func (miner *Miner) MevRunning() bool {
return miner.bidSimulator.isRunning() && miner.bidSimulator.receivingBid()
@@ -114,6 +120,9 @@ func (miner *Miner) SendBidBlock(ctx context.Context, args *buildertypes.BidBloc
return common.Hash{}, buildertypes.NewInvalidBidError(fmt.Sprintf("parent not found: %s, bidHash=%s", parentHash.Hex(), bidHash))
}
+ if isAmsterdamActivation(miner.worker.chainConfig, parent, bb.Header) {
+ return common.Hash{}, buildertypes.NewInvalidBidError("builder bids disabled on Amsterdam activation block")
+ }
// Security: validators must self-produce hard-fork activation blocks.
if miner.worker.chainConfig.IsOnPasteur(bb.Header.Number, parent.Time, bb.Header.Time) ||
miner.worker.chainConfig.IsOnJenner(bb.Header.Number, parent.Time, bb.Header.Time) {
diff --git a/miner/miner_mev_test.go b/miner/miner_mev_test.go
index 96f425d004..2c195a0f70 100644
--- a/miner/miner_mev_test.go
+++ b/miner/miner_mev_test.go
@@ -3,15 +3,22 @@ package miner
import (
"crypto/rand"
"errors"
+ "math/big"
"strings"
"testing"
+ "time"
"github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
gokzg4844 "github.com/crate-crypto/go-eth-kzg"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/consensus/parlia"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/core/types"
buildertypes "github.com/ethereum/go-ethereum/core/types/builder"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto/kzg4844"
+ "github.com/ethereum/go-ethereum/miner/minerconfig"
"github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
)
@@ -107,3 +114,123 @@ func TestValidateBidBlockBlobTxs_InvalidProof(t *testing.T) {
t.Fatalf("unexpected error message: %v", err)
}
}
+
+func TestBidTransactionGasCap(t *testing.T) {
+ config := *params.ParliaTestChainConfig
+ osaka, amsterdam := uint64(100), uint64(200)
+ config.OsakaTime = &osaka
+ config.AmsterdamTime = &amsterdam
+ simulator := &bidSimulator{chainConfig: &config}
+ for _, tc := range []struct {
+ name string
+ time, gas uint64
+ rejected bool
+ }{
+ {"before-osaka", 99, params.MaxTxGas + 1, false},
+ {"osaka-cap", 100, params.MaxTxGas, false},
+ {"before-amsterdam", 199, params.MaxTxGas + 1, true},
+ {"amsterdam", 200, params.MaxTxGas + 1, false},
+ {"amsterdam-total-cap", 201, params.MaxTxTotalGas, false},
+ {"amsterdam-over-cap", 201, params.MaxTxTotalGas + 1, true},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ header := &types.Header{Number: big.NewInt(2), Time: tc.time}
+ bid := &buildertypes.Bid{Txs: types.Transactions{types.NewTx(&types.LegacyTx{Gas: tc.gas})}}
+ err := simulator.checkIfBidExceedsTxGasLimit(bid, header)
+ if errors.Is(err, core.ErrGasLimitTooHigh) != tc.rejected {
+ t.Fatalf("gas cap error: %v", err)
+ }
+ })
+ }
+}
+
+func TestAmsterdamActivation(t *testing.T) {
+ config := *params.ParliaTestChainConfig
+ fork := uint64(100)
+ config.AmsterdamTime = &fork
+ for _, tc := range []struct {
+ name string
+ parent, time uint64
+ want bool
+ }{
+ {"before", 98, 99, false}, {"activation", 99, 100, true}, {"skipped-timestamp", 99, 101, true}, {"after", 100, 101, false},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ parent := &types.Header{Number: big.NewInt(1), Time: tc.parent}
+ header := &types.Header{Number: big.NewInt(2), Time: tc.time}
+ if got := isAmsterdamActivation(&config, parent, header); got != tc.want {
+ t.Fatalf("activation=%v, want %v", got, tc.want)
+ }
+ })
+ }
+ config.AmsterdamTime = nil
+ if isAmsterdamActivation(&config, &types.Header{Number: big.NewInt(1)}, &types.Header{Number: big.NewInt(2), Time: 100}) {
+ t.Fatal("disabled Amsterdam detected as activation")
+ }
+}
+
+func TestBidBlockRejectsAmsterdamActivation(t *testing.T) {
+ w, config, _, header, _ := laneMinerChain(t, false)
+ config.AmsterdamTime = &header.Time
+ header.Root = common.Hash{1}
+ db := rawdb.NewMemoryDatabase()
+ defer db.Close()
+ engine := parlia.New(config, db, nil, common.Hash{})
+ defer engine.Close()
+ simulator := &bidSimulator{chain: w.chain, chainConfig: config, engine: engine, bidWorker: w}
+ err := simulator.preSealVerifyBidBlock(&buildertypes.DecodedBidBlock{Header: header})
+ if err == nil || err.Error() != "builder bids disabled on Amsterdam activation block" {
+ t.Fatalf("activation bid error: %v", err)
+ }
+}
+
+func TestBidGasCapBeforeSelection(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ amsterdam bool
+ gas uint64
+ reject bool
+ }{
+ {"legacy-over-cap", false, params.MaxTxGas + 1, true},
+ {"amsterdam-over-cap", true, params.MaxTxTotalGas + 1, true},
+ {"amsterdam-large-tx", true, 30_000_000, false},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ w, config, parent, _, _ := laneMinerChain(t, false)
+ if tc.amsterdam {
+ zero := uint64(0)
+ config.AmsterdamTime = &zero
+ }
+ commission := uint64(100)
+ previous := &buildertypes.Bid{GasFee: big.NewInt(1), BuilderFee: common.Big0}
+ simulator := &bidSimulator{chain: w.chain, chainConfig: config,
+ config: &minerconfig.MevConfig{ValidatorCommission: &commission},
+ exitCh: make(chan struct{}), newBidCh: make(chan newBidPackage, 1), simBidCh: make(chan *simBidReq, 1),
+ bestBidToRun: map[common.Hash]*buildertypes.Bid{parent.Hash(): previous},
+ }
+ simulator.running.Store(true)
+ done := make(chan struct{})
+ go func() { defer close(done); simulator.newBidLoop() }()
+ defer func() { close(simulator.exitCh); <-done }()
+ bid := &buildertypes.Bid{BlockNumber: parent.Number.Uint64() + 1, ParentHash: parent.Hash(), GasFee: big.NewInt(100), BuilderFee: common.Big0,
+ Txs: types.Transactions{types.NewTx(&types.LegacyTx{Gas: tc.gas})}}
+ feedback := make(chan error, 1)
+ simulator.newBidCh <- newBidPackage{bid: bid, feedback: feedback}
+ select {
+ case err := <-feedback:
+ if errors.Is(err, core.ErrGasLimitTooHigh) != tc.reject {
+ t.Fatalf("admission error: %v", err)
+ }
+ case <-time.After(3 * time.Second):
+ t.Fatal("no admission feedback")
+ }
+ if tc.reject {
+ if simulator.GetBestBidToRun(parent.Hash()) != previous || len(simulator.simBidCh) != 0 {
+ t.Fatal("oversized bid replaced or interrupted the previous candidate")
+ }
+ } else if simulator.GetBestBidToRun(parent.Hash()) != bid || len(simulator.simBidCh) != 1 {
+ t.Fatal("legal Amsterdam bid was not scheduled")
+ }
+ })
+ }
+}
diff --git a/miner/worker.go b/miner/worker.go
index 1c34b61605..7b156acf76 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -38,7 +38,6 @@ import (
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/stateless"
- "github.com/ethereum/go-ethereum/core/systemcontracts"
"github.com/ethereum/go-ethereum/core/txpool"
"github.com/ethereum/go-ethereum/core/txpool/txorder"
"github.com/ethereum/go-ethereum/core/types"
@@ -98,7 +97,7 @@ var (
// Producing-side lane metrics; core/payment_lane.go reports the imported side.
paymentLaneQuotaGauge = metrics.NewRegisteredGauge("paymentlane/paymentLaneQuota", nil) // gas, at seal
- paymentLaneIdleGauge = metrics.NewRegisteredGauge("paymentlane/paymentLaneIdle", nil) // gas wasted, at seal
+ paymentLaneIdleGauge = metrics.NewRegisteredGauge("paymentlane/paymentLaneIdle", nil) // largest unused payment reservation, at seal
generalLaneYieldedCounter = metrics.NewRegisteredCounter("paymentlane/generalLaneYielded", nil) // txs dropped for the quota
paymentLaneDeclineCounter = metrics.NewRegisteredCounter("paymentlane/produceDeclined", nil)
@@ -848,9 +847,8 @@ func (w *worker) commitBlobTransaction(env *environment, tx *types.Transaction,
func (w *worker) applyTransaction(env *environment, tx *types.Transaction, receiptProcessors ...core.ReceiptProcessor) (*types.Receipt, error) {
laneType := env.lane.Classify(tx)
var (
- snap = env.state.Snapshot()
- gp = env.gasPool.Snapshot()
- usedBefore = env.gasPool.Used()
+ snap = env.state.Snapshot()
+ gp = env.gasPool.Snapshot()
)
receipt, txBAL, err := core.ApplyTransaction(context.Background(), env.evm, env.gasPool, env.state, env.header, tx)
@@ -866,7 +864,7 @@ func (w *worker) applyTransaction(env *environment, tx *types.Transaction, recei
}
}
env.header.GasUsed = env.gasPool.Used()
- env.lane.RecordUsedFrom(laneType, env.gasPool, usedBefore)
+ env.lane.RecordUsedFrom(laneType, env.gasPool, gp)
return receipt, err
}
@@ -996,10 +994,10 @@ LOOP:
prefetchCurr.Store(tx)
laneType := env.lane.Classify(tx)
- if !env.lane.Admits(env.gasPool.Available(env.evm.GetRules().IsAmsterdam), laneType, tx.Gas()) {
+ if !env.lane.Admits(env.gasPool, laneType, tx.Gas()) {
generalLaneYieldedCounter.Inc(1)
env.generalLaneYielded++
- log.Trace("Yielding idle payment lane", "hash", ltx.Hash, "left", env.gasPool.Available(env.evm.GetRules().IsAmsterdam), "paymentLaneIdle", env.lane.Budget.IdleLane())
+ log.Trace("Yielding idle payment lane", "hash", ltx.Hash, "left", env.gasPool.Available(env.evm.GetRules().IsAmsterdam), "paymentLaneIdle", env.lane.IdleGas())
txs.Pop()
continue
}
@@ -1147,13 +1145,17 @@ func (w *worker) prepareWork(genParams *generateParams, witness bool) (*environm
}
}
// Apply EIP-7843.
- // TODO: Define BSC's slot mapping and supply slotNum from commitWork
- // before enabling Amsterdam block production.
if w.chainConfig.IsAmsterdam(header.Number, header.Time) {
- if genParams.slotNum == nil {
- return nil, errors.New("missing slot number")
+ if w.chainConfig.IsInBSC() {
+ // BSC uses block numbers instead of beacon slots.
+ slot := header.Number.Uint64()
+ header.SlotNumber = &slot
+ } else {
+ if genParams.slotNum == nil {
+ return nil, errors.New("missing slot number")
+ }
+ header.SlotNumber = genParams.slotNum
}
- header.SlotNumber = genParams.slotNum
}
// Could potentially happen if starting to mine in an odd state.
// Note genParams.coinbase can be different with header.Coinbase
@@ -1164,9 +1166,6 @@ func (w *worker) prepareWork(genParams *generateParams, witness bool) (*environm
return nil, err
}
- // Handle upgrade built-in system contract code
- systemcontracts.TryUpdateBuildInSystemContract(w.chainConfig, header.Number, parent.Time, header.Time, env.state, true)
-
env.bal.Merge(core.PreExecution(context.Background(), header.ParentBeaconRoot, parent, w.chainConfig, env.evm, header.Number, header.Time))
return env, nil
}
@@ -1318,18 +1317,22 @@ func (w *worker) generateWork(genParam *generateParams, witness bool) *newPayloa
}
}
}
- allLogs := make([]*types.Log, 0)
- for _, r := range work.receipts {
- allLogs = append(allLogs, r.Logs...)
- }
- requests, postBAL, err := core.PostExecution(context.Background(), w.chainConfig, work.header.Number, work.header.Time, allLogs, genParam.withdrawals, work.evm, uint32(work.tcount+1))
- if err != nil {
- return &newPayloadResult{err: err}
- }
- work.bal.Merge(postBAL)
- if requests != nil {
- reqHash := types.CalcRequestsHash(requests)
- work.header.RequestsHash = &reqHash
+ var requests [][]byte
+ if w.chainConfig.IsNotInBSC() {
+ var allLogs []*types.Log
+ for _, receipt := range work.receipts {
+ allLogs = append(allLogs, receipt.Logs...)
+ }
+ var postBAL *bal.ConstructionBlockAccessList
+ requests, postBAL, err = core.PostExecution(context.Background(), w.chainConfig, work.header.Number, work.header.Time, allLogs, genParam.withdrawals, work.evm, uint32(work.tcount+1))
+ if err != nil {
+ return &newPayloadResult{err: err}
+ }
+ work.bal.Merge(postBAL)
+ if requests != nil {
+ reqHash := types.CalcRequestsHash(requests)
+ work.header.RequestsHash = &reqHash
+ }
}
fees := work.state.GetBalance(consensus.SystemAddress)
@@ -1337,7 +1340,7 @@ func (w *worker) generateWork(genParam *generateParams, witness bool) *newPayloa
if err != nil {
return &newPayloadResult{err: err}
}
- if err := work.lane.Verify(block.GasUsed()); err != nil {
+ if err := work.lane.Verify(block.GasUsed(), work.gasPool); err != nil {
paymentLaneDeclineCounter.Inc(1)
log.Error("Payment lane refused to seal", "number", block.Number(), "err", err)
return &newPayloadResult{err: err}
@@ -1576,7 +1579,10 @@ LOOP:
var simBidBlockReward *uint256.Int
var simBidValidatorReward *uint256.Int
var localValidatorReward *uint256.Int
- if w.bidFetcher != nil && bestWork.header.Difficulty.Cmp(diffInTurn) == 0 {
+ parent := w.chain.GetHeaderByHash(bestWork.header.ParentHash)
+ // Cached builder bids must not replace the validator's Amsterdam activation block.
+ if w.bidFetcher != nil && bestWork.header.Difficulty.Cmp(diffInTurn) == 0 &&
+ parent != nil && !isAmsterdamActivation(w.chainConfig, parent, bestWork.header) {
inturnBlocksGauge.Inc(1)
localValidatorReward = new(uint256.Int).Mul(bestReward, uint256.NewInt(*w.config.Mev.ValidatorCommission))
localValidatorReward.Div(localValidatorReward, uint256.NewInt(10000))
@@ -1703,8 +1709,6 @@ func (w *worker) commit(env *environment, interval func(), start time.Time) erro
if env.header.EmptyWithdrawalsHash() {
body.Withdrawals = make([]*types.Withdrawal, 0)
}
- // TODO: Run post-execution and collect Parlia finalization changes into
- // the BAL, then attach it to the block before enabling Amsterdam on BSC.
block, receipts, err := core.AssembleBlock(w.engine, w.chain, types.CopyHeader(env.header), env.state, &body, env.receipts, env.bal)
env.committed = true
if err != nil {
@@ -1717,14 +1721,14 @@ func (w *worker) commit(env *environment, interval func(), start time.Time) erro
env.receipts = receipts
finalizeBlockTimer.UpdateSince(finalizeStart)
- if err := env.lane.Verify(block.GasUsed()); err != nil {
+ if err := env.lane.Verify(block.GasUsed(), env.gasPool); err != nil {
paymentLaneDeclineCounter.Inc(1)
log.Error("Payment lane refused to seal", "number", block.Number(), "err", err)
return err
}
if env.lane.On() {
paymentLaneQuotaGauge.Update(int64(env.lane.Budget.PaymentLaneQuota))
- paymentLaneIdleGauge.Update(int64(env.lane.Budget.IdleLane()))
+ paymentLaneIdleGauge.Update(int64(env.lane.IdleGas()))
}
// If Cancun enabled, sidecars can't be nil then.
@@ -1737,7 +1741,7 @@ func (w *worker) commit(env *environment, interval func(), start time.Time) erro
case w.taskCh <- &task{receipts: receipts, state: env.state, block: block, createdAt: time.Now(), miningStartAt: start}:
log.Info("Commit new sealing work", "number", block.Number(), "sealhash", w.engine.SealHash(block.Header()),
"txs", len(env.txs), "blobs", env.blobs, "gas", block.GasUsed(), "paymentLaneQuota", env.lane.Budget.PaymentLaneQuota,
- "paymentLaneIdle", env.lane.Budget.IdleLane(), "generalLaneYielded", env.generalLaneYielded,
+ "paymentLaneIdle", env.lane.IdleGas(), "generalLaneYielded", env.generalLaneYielded,
"fees", feesInEther, "elapsed", common.PrettyDuration(time.Since(start)))
case <-w.exitCh:
diff --git a/miner/worker_test.go b/miner/worker_test.go
index 4f4c12b454..19df4be598 100644
--- a/miner/worker_test.go
+++ b/miner/worker_test.go
@@ -30,10 +30,12 @@ import (
"github.com/ethereum/go-ethereum/consensus/parlia"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/rawdb"
+ "github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/core/txpool"
"github.com/ethereum/go-ethereum/core/txpool/legacypool"
"github.com/ethereum/go-ethereum/core/types"
buildertypes "github.com/ethereum/go-ethereum/core/types/builder"
+ "github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/eth/downloader"
"github.com/ethereum/go-ethereum/ethdb"
@@ -488,3 +490,77 @@ func testGetSealingWork(t *testing.T, chainConfig *params.ChainConfig, engine co
}
}
}
+
+func TestPrepareWorkSlotNumber(t *testing.T) {
+ for _, bsc := range []bool{true, false} {
+ name := "eth"
+ config := *params.AllDevChainProtocolChanges
+ config.BogotaTime = nil
+ if bsc {
+ name = "bsc"
+ config = *params.BSCChainConfig
+ config.LondonBlock = big.NewInt(0)
+ }
+ t.Run(name, func(t *testing.T) {
+ fork := uint64(2_000_000_000)
+ config.AmsterdamTime = &fork
+ w, backend := newTestWorker(t, &config, ethash.NewFaker(), rawdb.NewMemoryDatabase(), 0)
+ defer backend.chain.Stop()
+ defer backend.txPool.Close()
+ defer w.close()
+ suppliedSlot, zeroSlot := uint64(500), uint64(0)
+ for _, test := range []struct {
+ name string
+ timestamp uint64
+ supplied *uint64
+ }{
+ {name: "before-fork", timestamp: 1},
+ {name: "before-fork-supplied", timestamp: 1, supplied: &suppliedSlot},
+ {name: "first-fork", timestamp: fork},
+ {name: "supplied", timestamp: fork, supplied: &suppliedSlot},
+ {name: "supplied-zero", timestamp: fork, supplied: &zeroSlot},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ env, err := w.prepareWork(&generateParams{timestamp: test.timestamp, forceTime: true, coinbase: testBankAddress, slotNum: test.supplied}, false)
+ if !bsc && test.timestamp == fork && test.supplied == nil {
+ if err == nil || err.Error() != "missing slot number" {
+ t.Fatalf("expected missing slot error, got %v", err)
+ }
+ return
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer env.discard()
+ if test.timestamp < fork {
+ if env.header.SlotNumber != nil {
+ t.Fatal("slot present before fork")
+ }
+ return
+ }
+ want := env.header.Number.Uint64()
+ if !bsc {
+ want = *test.supplied
+ }
+ if env.header.SlotNumber == nil || *env.header.SlotNumber != want || env.evm.Context.SlotNum != want {
+ t.Fatalf("slot header=%v context=%d, want %d", env.header.SlotNumber, env.evm.Context.SlotNum, want)
+ }
+ if bsc {
+ address := common.Address{0x80}
+ code := []byte{byte(vm.SLOTNUM), byte(vm.PUSH1), 0, byte(vm.MSTORE), byte(vm.PUSH1), 32, byte(vm.PUSH1), 0, byte(vm.RETURN)}
+ env.state.SetCode(address, code, tracing.CodeChangeUnspecified)
+ rules := env.evm.GetRules()
+ env.state.Prepare(rules, testBankAddress, testBankAddress, &address, vm.ActivePrecompiles(rules), nil)
+ ret, _, err := env.evm.Call(testBankAddress, address, nil, vm.NewGasBudget(100_000, 0), new(uint256.Int))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(ret) != 32 || new(big.Int).SetBytes(ret).Uint64() != want {
+ t.Fatalf("SLOTNUM returned %x, want %d", ret, want)
+ }
+ }
+ })
+ }
+ })
+ }
+}