Merge branch 'stylus-master-896026b' into stylus-state-storage

Author: rachel-bousfield

arbitrum/backend.go

@@ -55,7 +55,6 @@ func NewBackend(stack *node.Node, config *Config, chainDb ethdb.Database, publis
 	if err != nil {
 		return nil, nil, err
 	}
-	backend.shutdownTracker.MarkStartup()
 	return backend, filterSystem, nil
 }
 
@@ -86,6 +85,7 @@ func (b *Backend) ArbInterface() ArbInterface {
 // TODO: this is used when registering backend as lifecycle in stack
 func (b *Backend) Start() error {
 	b.startBloomHandlers(b.config.BloomBitsBlocks)
+	b.shutdownTracker.MarkStartup()
 	b.shutdownTracker.Start()
 
 	return nil

arbitrum/recordingdb.go

@@ -289,9 +289,10 @@ func (r *RecordingDatabase) GetOrRecreateState(ctx context.Context, header *type
 		if currentHeader.Number.Uint64() <= genesis {
 			return nil, fmt.Errorf("moved beyond genesis looking for state looking for %d, genesis %d, err %w", returnedBlockNumber, genesis, err)
 		}
+		lastHeader := currentHeader
 		currentHeader = r.bc.GetHeader(currentHeader.ParentHash, currentHeader.Number.Uint64()-1)
 		if currentHeader == nil {
-			return nil, fmt.Errorf("chain doesn't contain parent of block %d hash %v", currentHeader.Number, currentHeader.Hash())
+			return nil, fmt.Errorf("chain doesn't contain parent of block %d hash %v (expected parent hash %v)", lastHeader.Number, lastHeader.Hash(), lastHeader.ParentHash)
 		}
 		stateDb, err = r.StateFor(currentHeader)
 		if err == nil {

core/state_processor.go

@@ -26,7 +26,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/state"
 	"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"
 )
 
@@ -131,8 +130,8 @@ func applyTransaction(msg types.Message, config *params.ChainConfig, author *com
 	receipt.GasUsed = result.UsedGas
 
 	// If the transaction created a contract, store the creation address in the receipt.
-	if msg.To() == nil {
-		receipt.ContractAddress = crypto.CreateAddress(evm.TxContext.Origin, tx.Nonce())
+	if result.TopLevelDeployed != nil {
+		receipt.ContractAddress = *result.TopLevelDeployed
 	}
 
 	// Set the receipt logs and create the bloom filter.

core/state_transition.go

@@ -92,6 +92,8 @@ type ExecutionResult struct {
 
 	// Arbitrum: a tx may yield others that need to run afterward (see retryables)
 	ScheduledTxes types.Transactions
+	// Arbitrum: the contract deployed from the top-level transaction, or nil if not a contract creation tx
+	TopLevelDeployed *common.Address
 }
 
 // Unwrap returns the internal evm error which allows us for further
@@ -360,12 +362,14 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	if rules.IsBerlin {
 		st.state.PrepareAccessList(msg.From(), msg.To(), vm.ActivePrecompiles(rules), msg.AccessList())
 	}
+	var deployedContract *common.Address
 	var (
 		ret   []byte
 		vmerr error // vm errors do not effect consensus and are therefore not assigned to err
 	)
 	if contractCreation {
-		ret, _, st.gas, vmerr = st.evm.Create(sender, st.data, st.gas, st.value)
+		deployedContract = &common.Address{}
+		ret, *deployedContract, st.gas, vmerr = st.evm.Create(sender, st.data, st.gas, st.value)
 	} else {
 		// Increment the nonce for the next transaction
 		st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)
@@ -410,10 +414,11 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	}
 
 	return &ExecutionResult{
-		UsedGas:       st.gasUsed(),
-		Err:           vmerr,
-		ReturnData:    ret,
-		ScheduledTxes: st.evm.ProcessingHook.ScheduledTxes(),
+		UsedGas:          st.gasUsed(),
+		Err:              vmerr,
+		ReturnData:       ret,
+		ScheduledTxes:    st.evm.ProcessingHook.ScheduledTxes(),
+		TopLevelDeployed: deployedContract,
 	}, nil
 }
 

core/types/receipt.go

@@ -102,6 +102,7 @@ type storedReceiptRLP struct {
 	CumulativeGasUsed uint64
 	L1GasUsed         uint64
 	Logs              []*LogForStorage
+	ContractAddress   *common.Address `rlp:"optional"` // set on new versions if an Arbitrum tx type
 }
 
 type arbLegacyStoredReceiptRLP struct {
@@ -313,6 +314,9 @@ func (r *ReceiptForStorage) EncodeRLP(_w io.Writer) error {
 		}
 	}
 	w.ListEnd(logList)
+	if r.Type >= ArbitrumDepositTxType && r.Type != ArbitrumLegacyTxType && r.ContractAddress != (common.Address{}) {
+		w.WriteBytes(r.ContractAddress[:])
+	}
 	w.ListEnd(outerList)
 	return w.Flush()
 }
@@ -379,6 +383,9 @@ func decodeStoredReceiptRLP(r *ReceiptForStorage, blob []byte) error {
 		r.Logs[i] = (*Log)(log)
 	}
 	r.Bloom = CreateBloom(Receipts{(*Receipt)(r)})
+	if stored.ContractAddress != nil {
+		r.ContractAddress = *stored.ContractAddress
+	}
 
 	return nil
 }
@@ -464,7 +471,7 @@ func (rs Receipts) DeriveFields(config *params.ChainConfig, hash common.Hash, nu
 
 		if rs[i].Type != ArbitrumLegacyTxType {
 			// The contract address can be derived from the transaction itself
-			if txs[i].To() == nil {
+			if txs[i].To() == nil && rs[i].ContractAddress == (common.Address{}) {
 				// Deriving the signer is expensive, only do if it's actually needed
 				from, _ := Sender(signer, txs[i])
 				rs[i].ContractAddress = crypto.CreateAddress(from, txs[i].Nonce())

node/rpcstack_test.go

@@ -18,6 +18,7 @@ package node
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"net/http"
 	"net/url"
@@ -417,5 +418,21 @@ func TestJWT(t *testing.T) {
 			t.Errorf("tc %d-http, token '%v': expected not to allow,  got %v", i, token, resp.StatusCode)
 		}
 	}
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	client, err := rpc.DialWebsocketJWT(ctx, wsUrl, "orig", []byte("secret"))
+	if err != nil {
+		t.Errorf("DialWebsocketJWT should have succeeded, got %v", err)
+	}
+	if client != nil {
+		client.Close()
+	}
+	client, err = rpc.DialWebsocketJWT(ctx, wsUrl, "orig", []byte("bad"))
+	if err == nil {
+		t.Error("DialWebsocketJWT with bad secret should have failed")
+	}
+	if client != nil {
+		client.Close()
+	}
 	srv.stop()
 }

rpc/client.go

@@ -74,6 +74,8 @@ type BatchElem struct {
 
 // Client represents a connection to an RPC server.
 type Client struct {
+	requestHook RequestHook
+
 	idgen    func() ID // for subscriptions
 	isHTTP   bool      // connection type: http, ws or ipc
 	services *serviceRegistry
@@ -300,25 +302,32 @@ func (c *Client) CallContext(ctx context.Context, result interface{}, method str
 	}
 	op := &requestOp{ids: []json.RawMessage{msg.ID}, resp: make(chan *jsonrpcMessage, 1)}
 
+	resultHook := c.onRequest(msg)
 	if c.isHTTP {
 		err = c.sendHTTP(ctx, op, msg)
 	} else {
 		err = c.send(ctx, op, msg)
 	}
 	if err != nil {
+		resultHook.OnResult(nil, err)
 		return err
 	}
 
 	// dispatch has accepted the request and will close the channel when it quits.
 	switch resp, err := op.wait(ctx, c); {
 	case err != nil:
+		resultHook.OnResult(resp, err)
 		return err
 	case resp.Error != nil:
+		resultHook.OnResult(resp, resp.Error)
 		return resp.Error
 	case len(resp.Result) == 0:
+		resultHook.OnResult(resp, ErrNoResult)
 		return ErrNoResult
 	default:
-		return json.Unmarshal(resp.Result, &result)
+		err := json.Unmarshal(resp.Result, &result)
+		resultHook.OnResult(resp, err)
+		return err
 	}
 }
 
@@ -362,6 +371,12 @@ func (c *Client) BatchCallContext(ctx context.Context, b []BatchElem) error {
 		byID[string(msg.ID)] = i
 	}
 
+	resultHooks := make([]ResultHook, len(msgs))
+	responsesForHooks := make([]interface{}, len(msgs))
+	for i, msg := range msgs {
+		resultHooks[i] = c.onRequest(msg)
+	}
+
 	var err error
 	if c.isHTTP {
 		err = c.sendBatchHTTP(ctx, op, msgs)
@@ -379,7 +394,9 @@ func (c *Client) BatchCallContext(ctx context.Context, b []BatchElem) error {
 		// Find the element corresponding to this response.
 		// The element is guaranteed to be present because dispatch
 		// only sends valid IDs to our channel.
-		elem := &b[byID[string(resp.ID)]]
+		idx := byID[string(resp.ID)]
+		responsesForHooks[idx] = resp
+		elem := &b[idx]
 		if resp.Error != nil {
 			elem.Error = resp.Error
 			continue
@@ -390,6 +407,9 @@ func (c *Client) BatchCallContext(ctx context.Context, b []BatchElem) error {
 		}
 		elem.Error = json.Unmarshal(resp.Result, elem.Result)
 	}
+	for i, hook := range resultHooks {
+		hook.OnResult(responsesForHooks[i], err)
+	}
 	return err
 }
 

rpc/client_arbitrum.go

@@ -1,3 +1,19 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
 package rpc
 
 import (
@@ -34,3 +50,37 @@ func DialTransport(ctx context.Context, rawUrl string, transport *http.Transport
 	}
 	return rpcClient, nil
 }
+
+func DialContextWithRequestHook(ctx context.Context, url string, hook RequestHook) (*Client, error) {
+	client, err := DialContext(ctx, url)
+	if err != nil {
+		return nil, err
+	}
+	client.requestHook = hook
+	return client, nil
+}
+
+type RequestHook interface {
+	OnRequest(request interface{}) ResultHook
+}
+
+type ResultHook interface {
+	OnResult(response interface{}, err error)
+}
+
+type noopResultHook struct{}
+
+func (h noopResultHook) OnResult(interface{}, error) {
+}
+
+func (c *Client) onRequest(request interface{}) ResultHook {
+	hooks := c.requestHook
+	var respHooks ResultHook
+	if hooks != nil {
+		respHooks = hooks.OnRequest(request)
+	}
+	if respHooks == nil {
+		respHooks = noopResultHook{}
+	}
+	return respHooks
+}

rpc/handler.go

@@ -19,6 +19,7 @@ package rpc
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
@@ -34,21 +35,20 @@ import (
 //
 // The entry points for incoming messages are:
 //
-//    h.handleMsg(message)
-//    h.handleBatch(message)
+//	h.handleMsg(message)
+//	h.handleBatch(message)
 //
 // Outgoing calls use the requestOp struct. Register the request before sending it
 // on the connection:
 //
-//    op := &requestOp{ids: ...}
-//    h.addRequestOp(op)
+//	op := &requestOp{ids: ...}
+//	h.addRequestOp(op)
 //
 // Now send the request, then wait for the reply to be delivered through handleMsg:
 //
-//    if err := op.wait(...); err != nil {
-//        h.removeRequestOp(op) // timeout, etc.
-//    }
-//
+//	if err := op.wait(...); err != nil {
+//	    h.removeRequestOp(op) // timeout, etc.
+//	}
 type handler struct {
 	reg            *serviceRegistry
 	unsubscribeCb  *callback
@@ -92,6 +92,8 @@ func newHandler(connCtx context.Context, conn jsonWriter, idgen func() ID, reg *
 	return h
 }
 
+const maxBatchResponseSize int = 10_000_000 // 10MB
+
 // handleBatch executes all messages in a batch and returns the responses.
 func (h *handler) handleBatch(msgs []*jsonrpcMessage) {
 	// Emit error response for empty batches:
@@ -114,10 +116,21 @@ func (h *handler) handleBatch(msgs []*jsonrpcMessage) {
 	}
 	// Process calls on a goroutine because they may block indefinitely:
 	h.startCallProc(func(cp *callProc) {
-		answers := make([]*jsonrpcMessage, 0, len(msgs))
+		answers := make([]json.RawMessage, 0, len(msgs))
+		var totalSize int
 		for _, msg := range calls {
 			if answer := h.handleCallMsg(cp, msg); answer != nil {
-				answers = append(answers, answer)
+				serialized, err := json.Marshal(answer)
+				if err != nil {
+					h.conn.writeJSON(cp.ctx, errorMessage(&parseError{"error serializing response: " + err.Error()}))
+					return
+				}
+				totalSize += len(serialized)
+				if totalSize > maxBatchResponseSize {
+					h.conn.writeJSON(cp.ctx, errorMessage(&invalidRequestError{fmt.Sprintf("batch response exceeded limit of %v bytes", maxBatchResponseSize)}))
+					return
+				}
+				answers = append(answers, serialized)
 			}
 		}
 		h.addSubscriptions(cp.notifiers)