Modify EIP-7702 Txn impl per pectra-devnet-4 specs

consensus/merge/merge.go

@@ -192,11 +192,11 @@ func (s *Merge) Finalize(config *chain.Config, header *types.Header, state *stat
 		for _, rec := range receipts {
 			allLogs = append(allLogs, rec.Logs...)
 		}
-		depositReqs, err := types.ParseDepositLogs(allLogs, config.DepositContract)
+		depositReqs, err := misc.ParseDepositLogs(allLogs, config.DepositContract)
 		if err != nil {
 			return nil, nil, nil, fmt.Errorf("error: could not parse requests logs: %v", err)
 		}
-		rs = append(rs, types.FlatRequest{Type: types.DepositRequestType, RequestData: depositReqs.Encode()})
+		rs = append(rs, *depositReqs)
 		withdrawalReq := misc.DequeueWithdrawalRequests7002(syscall)
 		rs = append(rs, *withdrawalReq)
 		consolidations := misc.DequeueConsolidationRequests7251(syscall)
@@ -207,7 +207,6 @@ func (s *Merge) Finalize(config *chain.Config, header *types.Header, state *stat
 				return nil, nil, nil, fmt.Errorf("error: invalid requests root hash in header, expected: %v, got :%v", header.RequestsHash, rh)
 			}
 		}
-
 	}
 
 	return txs, receipts, rs, nil

consensus/misc/eip6110.go

@@ -0,0 +1,85 @@
+// Copyright 2024 The Erigon Authors
+// This file is part of Erigon.
+//
+// Erigon 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.
+//
+// Erigon 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 Erigon. If not, see <http://www.gnu.org/licenses/>.
+
+package misc
+
+import (
+	"fmt"
+
+	libcommon "github.com/erigontech/erigon-lib/common"
+	"github.com/erigontech/erigon/accounts/abi"
+	"github.com/erigontech/erigon/core/types"
+)
+
+const (
+	BLSPubKeyLen             = 48
+	WithdrawalCredentialsLen = 32 // withdrawalCredentials size
+	BLSSigLen                = 96 // signature size
+)
+
+var (
+	// DepositABI is an ABI instance of beacon chain deposit events.
+	DepositABI   = abi.ABI{Events: map[string]abi.Event{"DepositEvent": depositEvent}}
+	bytesT, _    = abi.NewType("bytes", "", nil)
+	depositEvent = abi.NewEvent("DepositEvent", "DepositEvent", false, abi.Arguments{
+		{Name: "pubkey", Type: bytesT, Indexed: false},
+		{Name: "withdrawal_credentials", Type: bytesT, Indexed: false},
+		{Name: "amount", Type: bytesT, Indexed: false},
+		{Name: "signature", Type: bytesT, Indexed: false},
+		{Name: "index", Type: bytesT, Indexed: false}},
+	)
+)
+
+// field type overrides for abi upacking
+type depositUnpacking struct {
+	Pubkey                []byte
+	WithdrawalCredentials []byte
+	Amount                []byte
+	Signature             []byte
+	Index                 []byte
+}
+
+// unpackDepositLog unpacks a serialized DepositEvent.
+func unpackDepositLog(data []byte) ([]byte, error) {
+	var du depositUnpacking
+	if err := DepositABI.UnpackIntoInterface(&du, "DepositEvent", data); err != nil {
+		return nil, err
+	}
+	reqData := make([]byte, 0, types.DepositRequestDataLen)
+	reqData = append(reqData, du.Pubkey...)
+	reqData = append(reqData, du.WithdrawalCredentials...)
+	reqData = append(reqData, du.Amount...)
+	reqData = append(reqData, du.Signature...)
+	reqData = append(reqData, du.Index...)
+
+	return reqData, nil
+}
+
+// ParseDepositLogs extracts the EIP-6110 deposit values from logs emitted by
+// BeaconDepositContract and returns a FlatRequest object ptr
+func ParseDepositLogs(logs []*types.Log, depositContractAddress libcommon.Address) (*types.FlatRequest, error) {
+	reqData := make([]byte, 0, len(logs)*types.DepositRequestDataLen)
+	for _, log := range logs {
+		if log.Address == depositContractAddress {
+			d, err := unpackDepositLog(log.Data)
+			if err != nil {
+				return nil, fmt.Errorf("unable to parse deposit data: %v", err)
+			}
+			reqData = append(reqData, d...)
+		}
+	}
+	return &types.FlatRequest{Type: types.DepositRequestType, RequestData: reqData}, nil
+}

core/state_transition.go

@@ -405,7 +405,11 @@ func (st *StateTransition) TransitionDb(refunds bool, gasBailout bool) (*evmtype
 			}
 
 			// 7. set authority code
-			st.state.SetCode(authority, types.AddressToDelegation(auth.Address))
+			if auth.Address == (libcommon.Address{}) {
+				st.state.SetCode(authority, nil)
+			} else {
+				st.state.SetCode(authority, types.AddressToDelegation(auth.Address))
+			}
 
 			// 8. increase the nonce of authority
 			st.state.SetNonce(authority, authorityNonce+1)

core/types/authorization.go

@@ -71,6 +71,16 @@ func (ath *Authorization) RecoverSigner(data *bytes.Buffer, b []byte) (*libcommo
 	copy(sig[32-len(r):32], r)
 	copy(sig[64-len(s):64], s)
 
+	if ath.Nonce == 1<<64-1 {
+		return nil, errors.New("Failed assertion: auth.nonce < 2**64 - 1")
+	}
+	if _, overflow := ath.ChainID.Uint64WithOverflow(); overflow {
+		return nil, fmt.Errorf("Failed assertion: auth.chain_id < 2**64")
+	}
+	if ath.V.GtUint64(1 << 8) {
+		return nil, fmt.Errorf("Failed assertion: auth.y_parity < 2**8")
+	}
+
 	if ath.V.Eq(u256.Num0) || ath.V.Eq(u256.Num1) {
 		sig[64] = byte(ath.V.Uint64())
 	} else {

core/types/eip7685_requests.go

@@ -31,6 +31,8 @@ const ConsolidationRequestDataLen = 116 // addr + sourcePubkey + targetPubkey
 
 var KnownRequestTypes = []byte{DepositRequestType, WithdrawalRequestType, ConsolidationRequestType}
 
+// FlatRequest carries serialized (flat) request data from any known Request type
+// The RequestData slice can contain collated data for more than one request of the same type
 type FlatRequest struct {
 	Type        byte
 	RequestData []byte