rlp: fix encoding/decoding of state-sync tx (#43)

* rlp: fix encoding/decoding of state-sync tx

* chore: add state-sync tx receipt in Finalize

* ssTxs: fix receiptsHash mismatch

* chore: remove block hash and number

* revert: add block number

* fix: rpc fixes

* polygon/sync: announce blocks/hashes for blocks received via hash announcements (#44)

* fix: log slicing in newStateSyncReceipt

---------

Co-authored-by: Manav Darji <manavdarji.india@gmail.com>

Author: kamuikatsurgi

core/vm/evmtypes/rules.go

@@ -47,5 +47,7 @@ func (bc *BlockContext) Rules(c *chain.Config) *chain.Rules {
 		IsPrague:           c.IsPrague(bc.Time) || c.IsBhilai(bc.BlockNumber),
 		IsOsaka:            c.IsOsaka(bc.Time),
 		IsAura:             c.Aura != nil,
+		IsRio:              c.IsRio(bc.BlockNumber),
+		IsStateSync:        c.IsStateSync(bc.BlockNumber),
 	}
 }

execution/chain/chain_config.go

@@ -334,6 +334,16 @@ func (c *Config) IsBhilai(num uint64) bool {
 	return (c != nil) && (c.Bor != nil) && c.Bor.IsBhilai(num)
 }
 
+// IsRio returns whether num is either equal to the Rio fork block or greater.
+func (c *Config) IsRio(num uint64) bool {
+	return (c != nil) && (c.Bor != nil) && c.Bor.IsRio(num)
+}
+
+// IsStateSync returns whether num is either equal to the StateSync fork block or greater.
+func (c *Config) IsStateSync(num uint64) bool {
+	return (c != nil) && (c.Bor != nil) && c.Bor.IsStateSync(num)
+}
+
 // IsCancun returns whether time is either equal to the Cancun fork time or greater.
 func (c *Config) IsCancun(time uint64) bool {
 	return isForked(c.CancunTime, time)
@@ -703,10 +713,9 @@ type Rules struct {
 	IsHomestead, IsTangerineWhistle, IsSpuriousDragon bool
 	IsByzantium, IsConstantinople, IsPetersburg       bool
 	IsIstanbul, IsBerlin, IsLondon, IsShanghai        bool
-	IsCancun, IsNapoli, IsBhilai                      bool
+	IsCancun, IsNapoli, IsBhilai, IsRio, IsStateSync  bool
 	IsPrague, IsOsaka                                 bool
 	IsAura                                            bool
-	IsStateSync                                       bool // TODO define a name when we have a fork that enables it
 }
 
 // isForked returns whether a fork scheduled at block s is active at the given head block.

execution/stagedsync/stage_senders.go

@@ -353,6 +353,12 @@ func recoverSenders(ctx context.Context, logPrefix string, cryptoContext *secp25
 		signer := types.MakeSigner(config, job.blockNumber, job.blockTime)
 		job.senders = make([]byte, len(body.Transactions)*length.Addr)
 		for i, txn := range body.Transactions {
+			// Skip StateSyncTx - they have no sender.
+			if txn.Type() == types.StateSyncTxType {
+				// Leave sender as zero address
+				continue
+			}
+
 			from, err := signer.SenderWithContext(cryptoContext, txn)
 			if err != nil {
 				job.err = fmt.Errorf("%w: error recovering sender for tx=%x, %v",

execution/types/receipt.go

@@ -214,7 +214,7 @@ func (r *Receipt) decodeTyped(b []byte) error {
 		return errShortTypedReceipt
 	}
 	switch b[0] {
-	case DynamicFeeTxType, AccessListTxType, BlobTxType:
+	case DynamicFeeTxType, AccessListTxType, BlobTxType, SetCodeTxType, StateSyncTxType:
 		var data receiptRLP
 		err := rlp.DecodeBytes(b[1:], &data)
 		if err != nil {
@@ -319,7 +319,7 @@ func (r *Receipt) DecodeRLP(s *rlp.Stream) error {
 		}
 		r.Type = b[0]
 		switch r.Type {
-		case AccessListTxType, DynamicFeeTxType, BlobTxType, SetCodeTxType:
+		case AccessListTxType, DynamicFeeTxType, BlobTxType, SetCodeTxType, StateSyncTxType:
 			if err := r.decodePayload(s); err != nil {
 				return err
 			}
@@ -486,6 +486,11 @@ func (rs Receipts) EncodeIndex(i int, w *bytes.Buffer) {
 		if err := rlp.Encode(w, data); err != nil {
 			panic(err)
 		}
+	case StateSyncTxType:
+		w.WriteByte(StateSyncTxType)
+		if err := rlp.Encode(w, data); err != nil {
+			panic(err)
+		}
 	default:
 		// For unsupported types, write nothing. Since this is for
 		// DeriveSha, the error will be caught matching the derived hash

execution/types/state_sync_tx.go

@@ -24,7 +24,7 @@ func (tx *StateSyncTx) Type() byte {
 }
 
 func (tx *StateSyncTx) GetChainID() *uint256.Int {
-	panic("chainID called from StateSyncTx")
+	return nil
 }
 
 func (tx *StateSyncTx) GetNonce() uint64 {
@@ -65,31 +65,33 @@ func (tx *StateSyncTx) GetTo() *common.Address {
 
 func (tx *StateSyncTx) AsMessage(_ Signer, baseFee *big.Int, rules *chain.Rules) (*Message, error) {
 	if !rules.IsStateSync {
-		// TODO change to better name when we have a hard fork for this
+		// TODO: Change to a better name when we have a hard fork for this.
 		return nil, errors.New("StateSync typed tx requires StateSync hard fork")
 	}
+
 	msg := Message{
+		to:         &common.Address{},
+		from:       common.Address{},
 		nonce:      0,
+		amount:     *uint256.NewInt(0),
 		gasLimit:   0,
 		gasPrice:   *uint256.NewInt(0),
-		tipCap:     *uint256.NewInt(0),
 		feeCap:     *uint256.NewInt(0),
-		to:         tx.GetTo(),
-		amount:     *uint256.NewInt(0),
+		tipCap:     *uint256.NewInt(0),
 		data:       []byte{},
 		accessList: nil,
 		checkNonce: false,
 	}
+
 	if baseFee != nil {
 		_ = msg.gasPrice.SetFromBig(baseFee)
 	}
 
-	msg.from = common.Address{}
 	return &msg, nil
 }
 
 func (tx *StateSyncTx) WithSignature(_ Signer, _ []byte) (Transaction, error) {
-	return nil, errors.New("StateSyncTx are not signed")
+	return nil, errors.New("StateSyncTx is not signed")
 }
 
 func (tx *StateSyncTx) Hash() common.Hash {
@@ -105,7 +107,7 @@ func (tx *StateSyncTx) Hash() common.Hash {
 }
 
 func (tx *StateSyncTx) SigningHash(_ *big.Int) common.Hash {
-	// StateSync txs are never signed, return canonical hash
+	// StateSync txs are never signed, return canonical hash.
 	return tx.Hash()
 }
 
@@ -132,24 +134,26 @@ func (tx *StateSyncTx) RawSignatureValues() (*uint256.Int, *uint256.Int, *uint25
 func (tx *StateSyncTx) EncodingSize() int {
 	var b bytes.Buffer
 	_ = tx.encode(&b)
-	return 1 + b.Len()
+	data := make([]byte, 1+b.Len())
+	return rlp.StringLen(data)
 }
 
-// EncodeRLP writes the inner payload ([]StateSyncData) without the type prefix.
+// EncodeRLP implements rlp.Encoder for database storage.
 func (tx *StateSyncTx) EncodeRLP(w io.Writer) error {
 	if tx == nil {
 		return errors.New("nil StateSyncTx")
 	}
 	var buf bytes.Buffer
+	buf.WriteByte(StateSyncTxType)
 	if err := tx.encode(&buf); err != nil {
 		return err
 	}
-	_, err := w.Write(buf.Bytes())
-	return err
+	b := newEncodingBuf()
+	defer pooledBuf.Put(b)
+	return rlp.EncodeString(buf.Bytes(), w, b[:])
 }
 
-// DecodeRLP consumes the RLP stream and populates tx.StateSyncData.
-// The type byte (0x7F) is already stripped by the UnmarshalTransaction path.
+// DecodeRLP implements rlp.Decoder.
 func (tx *StateSyncTx) DecodeRLP(s *rlp.Stream) error {
 	raw, err := s.Raw()
 	if err != nil {
@@ -158,11 +162,20 @@ func (tx *StateSyncTx) DecodeRLP(s *rlp.Stream) error {
 	return tx.decode(raw)
 }
 
+// MarshalBinary returns the canonical encoding for network transmission.
 func (tx *StateSyncTx) MarshalBinary(w io.Writer) error {
+	if tx == nil {
+		return errors.New("nil StateSyncTx")
+	}
 	if _, err := w.Write([]byte{StateSyncTxType}); err != nil {
 		return err
 	}
-	return tx.EncodeRLP(w)
+	var payloadBuf bytes.Buffer
+	if err := tx.encode(&payloadBuf); err != nil {
+		return err
+	}
+	_, err := w.Write(payloadBuf.Bytes())
+	return err
 }
 
 func (tx *StateSyncTx) Sender(_ Signer) (common.Address, error) {
@@ -178,7 +191,7 @@ func (tx *StateSyncTx) GetSender() (common.Address, bool) {
 }
 
 func (tx *StateSyncTx) SetSender(_ common.Address) {
-	// no-op, StateSyncTx has no sender
+	// no-op, StateSyncTx has no sender.
 }
 
 func (tx *StateSyncTx) IsContractDeploy() bool {
@@ -226,7 +239,7 @@ func (tx *StateSyncTx) encode(buf *bytes.Buffer) error {
 	if tx == nil {
 		return errors.New("nil StateSyncTx")
 	}
-	// Validate ascending and contiguous IDs as per PIP-74
+	// Validate ascending and contiguous IDs as per PIP-74.
 	var prev uint64
 	for i, d := range tx.StateSyncData {
 		if d == nil {
@@ -253,7 +266,7 @@ func (tx *StateSyncTx) decode(b []byte) error {
 	if err := rlp.DecodeBytes(b, &dec); err != nil {
 		return err
 	}
-	// Validate ascending and contiguous IDs as per PIP-74
+	// Validate ascending and contiguous IDs as per PIP-74.
 	if len(dec) > 0 {
 		prev := dec[0].ID
 		for i := 1; i < len(dec); i++ {

polygon/bor/bor.go

@@ -798,7 +798,7 @@ func (c *Bor) CalculateRewards(_ *chain.Config, _ *types.Header, _ []*types.Head
 // Finalize implements consensus.Engine, ensuring no uncles are set, nor block
 // rewards given.
 func (c *Bor) Finalize(_ *chain.Config, header *types.Header, state *state.IntraBlockState,
-	_ types.Transactions, _ []*types.Header, _ types.Receipts, withdrawals []*types.Withdrawal,
+	txs types.Transactions, _ []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal,
 	chain consensus.ChainReader, syscall consensus.SystemCall, _ bool, _ log.Logger,
 ) (types.FlatRequests, error) {
 	headerNumber := header.Number.Uint64()
@@ -841,7 +841,14 @@ func (c *Bor) Finalize(_ *chain.Config, header *types.Header, state *state.Intra
 		return nil, err
 	}
 
-	// PIP-74: Finalize does not append txs/receipts (that’s done in FinalizeAndAssemble)
+	if c.config.IsStateSync(headerNumber) && len(txs) > 0 {
+		lastTx := txs[len(txs)-1]
+		if lastTx.Type() == types.StateSyncTxType && receipts[len(txs)-1] == nil {
+			prevReceipts := receipts[:len(txs)-1]
+			stateSyncReceipt := newStateSyncReceipt(lastTx, prevReceipts, state, header, txs)
+			receipts[len(txs)-1] = stateSyncReceipt
+		}
+	}
 
 	return nil, nil
 }
@@ -920,7 +927,7 @@ func (c *Bor) FinalizeAndAssemble(
 		return nil, nil, err
 	}
 
-	// PIP-74: append StateSyncTx and receipt post-fork if any events executed
+	// PIP-74: append StateSyncTx and receipt post-fork if any state-sync events executed.
 	if c.config.IsStateSync(headerNumber) && len(execStateSync) > 0 {
 		c.logger.Info("FinalizeAndAssemble: Appending state sync txs", "count", len(execStateSync))
 		stateSyncTx := &types.StateSyncTx{StateSyncData: execStateSync}
@@ -1451,30 +1458,35 @@ func VerifyUncles(uncles []*types.Header) error {
 
 // newStateSyncReceipt creates a new receipt for the StateSyncTx
 func newStateSyncReceipt(tx types.Transaction, prev types.Receipts, state *state.IntraBlockState, header *types.Header, txs types.Transactions) *types.Receipt {
-	// Slice logs since previous receipts
-	allLogs := state.Logs()
-	logsFromReceiptCount := countLogsFromReceipts(prev)
-	stateSyncLogs := allLogs[logsFromReceiptCount:]
+	// state.Logs() only contains the state sync logs.
+	// regular tx logs are already in their receipts, not in state.
+	// Here, state is the intra block state.
+	stateSyncLogs := state.Logs()
+
+	// Fix log TxIndex - logs inherit TxIndex from state context during CommitStates.
+	txIndex := uint(len(txs) - 1)
+	for _, l := range stateSyncLogs {
+		l.TxIndex = txIndex
+	}
+
+	var cumulativeGasUsed uint64
+	if len(prev) > 0 {
+		cumulativeGasUsed = prev[len(prev)-1].CumulativeGasUsed
+	}
 
 	r := &types.Receipt{
 		Type:              tx.Type(),
 		Status:            types.ReceiptStatusSuccessful,
-		CumulativeGasUsed: header.GasUsed,
-		GasUsed:           0,
-		TxHash:            tx.Hash(),
+		CumulativeGasUsed: cumulativeGasUsed,
 		Logs:              stateSyncLogs,
-		BlockNumber:       header.Number,
-		TransactionIndex:  uint(len(txs) - 1),
+		// Implementation fields
+		TxHash:  tx.Hash(),
+		GasUsed: 0,
+		// Inclusion information
+		BlockNumber:      header.Number,
+		TransactionIndex: txIndex,
 	}
 	r.Bloom = types.CreateBloom(types.Receipts{r})
-	return r
-}
 
-// countLogsFromReceipts counts the total number of logs in the given receipts.
-func countLogsFromReceipts(receipts types.Receipts) int {
-	count := 0
-	for _, r := range receipts {
-		count += len(r.Logs)
-	}
-	return count
+	return r
 }

polygon/sync/sync.go

@@ -413,7 +413,7 @@ func (s *Sync) applyNewBlockChainOnTip(ctx context.Context, blockChain []*types.
 		return err
 	}
 
-	if source == EventSourceP2PNewBlock {
+	if source == EventSourceP2PNewBlock || source == EventSourceP2PNewBlockHashes {
 		// https://github.com/ethereum/devp2p/blob/master/caps/eth.md#block-propagation
 		// devp2p spec: After the header validity check, the client imports the block into its local chain by executing
 		// all transactions contained in the block, computing the block's 'post state'. The block's state-root hash

rpc/ethapi/api.go

@@ -519,11 +519,16 @@ func NewRPCTransaction(txn types.Transaction, blockHash common.Hash, blockNumber
 		}
 		result.GasPrice = (*hexutil.Big)(txn.GetTipCap().ToBig())
 	} else {
-		chainId.Set(txn.GetChainID())
-		result.ChainID = (*hexutil.Big)(chainId.ToBig())
+		if txn.Type() != types.StateSyncTxType {
+			chainId.Set(txn.GetChainID())
+			result.ChainID = (*hexutil.Big)(chainId.ToBig())
+		}
 		result.YParity = (*hexutil.Big)(v.ToBig())
-		acl := txn.GetAccessList()
-		result.Accesses = &acl
+
+		if txn.Type() != types.StateSyncTxType {
+			acl := txn.GetAccessList()
+			result.Accesses = &acl
+		}
 
 		if txn.Type() == types.AccessListTxType {
 			result.GasPrice = (*hexutil.Big)(txn.GetTipCap().ToBig())

rpc/jsonrpc/eth_block.go

@@ -229,7 +229,7 @@ func (api *APIImpl) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber
 	}
 	var borTx types.Transaction
 	var borTxHash common.Hash
-	if chainConfig.Bor != nil {
+	if chainConfig.Bor != nil && !chainConfig.Bor.IsStateSync(b.NumberU64()) {
 		possibleBorTxnHash := bortypes.ComputeBorTxHash(b.NumberU64(), b.Hash())
 		_, ok, err := api.bridgeReader.EventTxnLookup(ctx, possibleBorTxnHash)
 		if err != nil {