Implement retrieval of latest SignerAddresses from L1

Author: ranchalp

consensus/system_contract/system_contract.go

@@ -2,7 +2,12 @@ package system_contract
 
 import (
 	"context"
+	"fmt"
+	"github.com/scroll-tech/go-ethereum"
+	"github.com/scroll-tech/go-ethereum/accounts/abi"
+	"github.com/scroll-tech/go-ethereum/ethclient"
 	"math/big"
+	"strings"
 	"sync"
 	"time"
 
@@ -26,8 +31,7 @@ type SystemContract struct {
 	config *params.SystemContractConfig // Consensus engine configuration parameters
 	client sync_service.EthClient
 
-	signerAddressL1   common.Address // Address of the signer stored in L1 System Contract
-	signerAddressesL1 []SignerAddressL1
+	signerAddressesL1 []SignerAddressL1 // Addresses of the signer stored in L1 System Contract
 
 	signer common.Address // Ethereum address of the signing key
 	signFn SignerFn       // Signer function to authorize hashes with
@@ -40,16 +44,10 @@ type SystemContract struct {
 // New creates a SystemContract consensus engine with the initial
 // signers set to the ones provided by the user.
 func New(ctx context.Context, config *params.SystemContractConfig, client sync_service.EthClient) *SystemContract {
-	blockNumber := big.NewInt(-1) // todo: get block number from L1BlocksContract (l1 block hash relay) or other source (depending on exact design)
 	ctx, cancel := context.WithCancel(ctx)
-	address, err := client.StorageAt(ctx, config.SystemContractAddress, config.SystemContractSlot, blockNumber)
-	if err != nil {
-		log.Error("failed to get signer address from L1 System Contract", "err", err)
-	}
 	systemContract := &SystemContract{
-		config:          config,
-		client:          client,
-		signerAddressL1: common.BytesToAddress(address),
+		config: config,
+		client: client,
 
 		ctx:    ctx,
 		cancel: cancel,
@@ -58,6 +56,76 @@ func New(ctx context.Context, config *params.SystemContractConfig, client sync_s
 	return systemContract
 }
 
+// Hardcoded ABI snippet for getAllTransitions():
+//
+//	function getAllTransitions() external view returns (uint64[] memory, address[] memory);
+//
+// We only need what's necessary to encode/decode "getAllTransitions".
+const getAllTransitionsABI = `[
+  {
+    "inputs": [],
+    "name": "getAllTransitions",
+    "outputs": [
+      {"internalType": "uint64[]", "type": "uint64[]"},
+      {"internalType": "address[]","type": "address[]"}
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]`
+
+// fetchAllSigners calls getAllTransitions() on the contract, decodes the results,
+// and returns them as a slice of [StartBlock, Signer].
+func (s *SystemContract) fetchAllSigners(blockNum *big.Int) ([]SignerAddressL1, error) {
+	// Parse the ABI so we can encode and decode calls
+	parsedABI, err := abi.JSON(strings.NewReader(getAllTransitionsABI))
+	if err != nil {
+		return nil, fmt.Errorf("parse ABI error: %w", err)
+	}
+
+	// Pack the function call data
+	packed, err := parsedABI.Pack("getAllTransitions")
+	if err != nil {
+		return nil, fmt.Errorf("ABI pack error: %w", err)
+	}
+
+	// Prepare the call
+	msg := ethereum.CallMsg{
+		To:   &s.config.SystemContractAddress, // The address of your SystemSignerRegistry contract
+		Data: packed,
+	}
+
+	// Perform the call via the ethclient interface (need to cast)
+	output, err := s.client.(*ethclient.Client).CallContract(s.ctx, msg, blockNum)
+	if err != nil {
+		return nil, fmt.Errorf("CallContract error: %w", err)
+	}
+	// Decode the (uint64[] memory, address[] memory) from output
+	var ret struct {
+		Blocks  []*big.Int
+		Signers []common.Address
+	}
+	err = parsedABI.UnpackIntoInterface(&ret, "getAllTransitions", output)
+	if err != nil {
+		return nil, fmt.Errorf("unpack error: %w", err)
+	}
+
+	if len(ret.Blocks) != len(ret.Signers) {
+		return nil, fmt.Errorf("mismatched array lengths blocks=%d signers=%d",
+			len(ret.Blocks), len(ret.Signers))
+	}
+
+	// Convert them into []SignerAddressL1
+	result := make([]SignerAddressL1, 0, len(ret.Blocks))
+	for i := range ret.Blocks {
+		result = append(result, SignerAddressL1{
+			StartBlock: ret.Blocks[i].Uint64(),
+			Signer:     ret.Signers[i],
+		})
+	}
+	return result, nil
+}
+
 // Authorize injects a private key into the consensus engine to mint new blocks
 // with.
 func (s *SystemContract) Authorize(signer common.Address, signFn SignerFn) {
@@ -71,6 +139,14 @@ func (s *SystemContract) Authorize(signer common.Address, signFn SignerFn) {
 func (s *SystemContract) Start() {
 	log.Info("starting SystemContract")
 	go func() {
+		s.lock.Lock()
+		signers, err := s.fetchAllSigners(nil) // nil -> latest state
+		if err != nil {
+			log.Error("failed to get signer address from L1 System Contract", "err", err)
+		}
+		s.signerAddressesL1 = signers
+		s.lock.Unlock()
+
 		syncTicker := time.NewTicker(defaultSyncInterval)
 		defer syncTicker.Stop()
 		for {
@@ -83,14 +159,12 @@ func (s *SystemContract) Start() {
 			case <-s.ctx.Done():
 				return
 			case <-syncTicker.C:
-				//TODO here
-				blockNumber := big.NewInt(-1) // todo: get block number from L1BlocksContract (l1 block hash relay) or other source (depending on exact design)
-				address, err := s.client.StorageAt(s.ctx, s.config.SystemContractAddress, s.config.SystemContractSlot, blockNumber)
+				s.lock.Lock()
+				signers, err := s.fetchAllSigners(nil) // nil -> latest state
 				if err != nil {
 					log.Error("failed to get signer address from L1 System Contract", "err", err)
 				}
-				s.lock.Lock()
-				s.signerAddressL1 = common.BytesToAddress(address)
+				s.signerAddressesL1 = signers
 				s.lock.Unlock()
 			}
 		}