Merge branch 'main' into thiago/loadtest-gas-oscillation

Author: tclemos

cmd/dockerlogger/dockerlogger.go

@@ -10,8 +10,8 @@ import (
 	"sync"
 	"time"
 
-	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"
 	"github.com/fatih/color"
 	"github.com/spf13/cobra"
@@ -117,23 +117,23 @@ func CreateClient() (*client.Client, error) {
 }
 
 // InspectNetwork retrieves detailed information about a Docker network.
-func InspectNetwork(ctx context.Context, cli *client.Client, networkName string) (types.NetworkResource, error) {
+func InspectNetwork(ctx context.Context, cli *client.Client, networkName string) (network.Inspect, error) {
 	if networkName == "" {
-		return types.NetworkResource{}, fmt.Errorf("network name cannot be empty")
+		return network.Inspect{}, fmt.Errorf("network name cannot be empty")
 	}
 
 	if cli == nil {
-		return types.NetworkResource{}, fmt.Errorf("docker client cannot be nil")
+		return network.Inspect{}, fmt.Errorf("docker client cannot be nil")
 	}
 
-	network, err := cli.NetworkInspect(ctx, networkName, types.NetworkInspectOptions{
+	net, err := cli.NetworkInspect(ctx, networkName, network.InspectOptions{
 		Verbose: true,
 	})
 	if err != nil {
-		return types.NetworkResource{}, fmt.Errorf("failed to inspect network %s: %w", networkName, err)
+		return network.Inspect{}, fmt.Errorf("failed to inspect network %s: %w", networkName, err)
 	}
 
-	return network, nil
+	return net, nil
 }
 
 func monitorLogs(ctx context.Context, cli *client.Client, networkName string, config *LogConfig) error {
@@ -244,7 +244,7 @@ func shouldLogMessage(logLine string, config *LogConfig) bool {
 	var allowedLevels map[string]bool
 	if config.logLevels != "" {
 		allowedLevels = make(map[string]bool)
-		for _, level := range strings.Split(config.logLevels, ",") {
+		for level := range strings.SplitSeq(config.logLevels, ",") {
 			allowedLevels[strings.TrimSpace(strings.ToLower(level))] = true
 		}
 	}
@@ -267,8 +267,8 @@ func shouldLogMessage(logLine string, config *LogConfig) bool {
 
 	// Check custom keywords if no level match
 	if config.customWords != "" {
-		customKeywords := strings.Split(config.customWords, ",")
-		for _, keyword := range customKeywords {
+		customKeywords := strings.SplitSeq(config.customWords, ",")
+		for keyword := range customKeywords {
 			if strings.Contains(logLine, strings.TrimSpace(strings.ToLower(keyword))) {
 				return true
 			}

cmd/enr/enr.go

@@ -34,9 +34,9 @@ var ENRCmd = &cobra.Command{
 			log.Error().Err(err).Msg("Unable to read input")
 			return err
 		}
-		lines := strings.Split(string(rawData), "\n")
+		lines := strings.SplitSeq(string(rawData), "\n")
 
-		for _, l := range lines {
+		for l := range lines {
 			var node *enode.Node
 			var err error
 			l = strings.TrimSpace(l)

cmd/loadtest/account.go

@@ -340,7 +340,7 @@ func (ap *AccountPool) RefreshNonce(ctx context.Context, address common.Address)
 	return nil
 }
 
-// NumberOfPendingTxs returns the the difference between the internal nonce
+// NumberOfPendingTxs returns the difference between the internal nonce
 // and the network pending nonce for all accounts in the pool. It uses
 // caching to avoid making too many requests to the network.
 func (ap *AccountPool) NumberOfPendingTxs(ctx context.Context) (uint64, error) {

cmd/p2p/sensor/sensor.go

@@ -69,8 +69,9 @@ type (
 		DiscoveryDNS                 string
 		Database                     string
 		NoDiscovery                  bool
-		MaxRequests                  int
-		RequestsCacheTTL             time.Duration
+		RequestsCache                p2p.CacheOptions
+		ParentsCache                 p2p.CacheOptions
+		BlocksCache                  p2p.CacheOptions
 
 		bootnodes    []*enode.Node
 		staticNodes  []*enode.Node
@@ -192,22 +193,25 @@ var SensorCmd = &cobra.Command{
 		}, []string{"message", "url", "name", "direction"})
 
 		// Create peer connection manager for broadcasting transactions
-		conns := p2p.NewConns()
+		// and managing the global blocks cache
+		conns := p2p.NewConns(p2p.ConnsOptions{
+			BlocksCache: inputSensorParams.BlocksCache,
+		})
 
 		opts := p2p.EthProtocolOptions{
-			Context:          cmd.Context(),
-			Database:         db,
-			GenesisHash:      common.HexToHash(inputSensorParams.GenesisHash),
-			RPC:              inputSensorParams.RPC,
-			SensorID:         inputSensorParams.SensorID,
-			NetworkID:        inputSensorParams.NetworkID,
-			Conns:            conns,
-			Head:             &head,
-			HeadMutex:        &sync.RWMutex{},
-			ForkID:           forkid.ID{Hash: [4]byte(inputSensorParams.ForkID)},
-			MsgCounter:       msgCounter,
-			MaxRequests:      inputSensorParams.MaxRequests,
-			RequestsCacheTTL: inputSensorParams.RequestsCacheTTL,
+			Context:       cmd.Context(),
+			Database:      db,
+			GenesisHash:   common.HexToHash(inputSensorParams.GenesisHash),
+			RPC:           inputSensorParams.RPC,
+			SensorID:      inputSensorParams.SensorID,
+			NetworkID:     inputSensorParams.NetworkID,
+			Conns:         conns,
+			Head:          &head,
+			HeadMutex:     &sync.RWMutex{},
+			ForkID:        forkid.ID{Hash: [4]byte(inputSensorParams.ForkID)},
+			MsgCounter:    msgCounter,
+			RequestsCache: inputSensorParams.RequestsCache,
+			ParentsCache:  inputSensorParams.ParentsCache,
 		}
 
 		config := ethp2p.Config{
@@ -480,6 +484,10 @@ will result in less chance of missing data but can significantly increase memory
   - json (output to stdout)
   - none (no persistence)`)
 	f.BoolVar(&inputSensorParams.NoDiscovery, "no-discovery", false, "disable P2P peer discovery")
-	f.IntVar(&inputSensorParams.MaxRequests, "max-requests", 2048, "maximum request IDs to track per peer (0 for no limit)")
-	f.DurationVar(&inputSensorParams.RequestsCacheTTL, "requests-cache-ttl", 5*time.Minute, "time to live for requests cache entries (0 for no expiration)")
+	f.IntVar(&inputSensorParams.RequestsCache.MaxSize, "max-requests", 2048, "maximum request IDs to track per peer (0 for no limit)")
+	f.DurationVar(&inputSensorParams.RequestsCache.TTL, "requests-cache-ttl", 5*time.Minute, "time to live for requests cache entries (0 for no expiration)")
+	f.IntVar(&inputSensorParams.ParentsCache.MaxSize, "max-parents", 1024, "maximum parent block hashes to track per peer (0 for no limit)")
+	f.DurationVar(&inputSensorParams.ParentsCache.TTL, "parents-cache-ttl", 5*time.Minute, "time to live for parent hash cache entries (0 for no expiration)")
+	f.IntVar(&inputSensorParams.BlocksCache.MaxSize, "max-blocks", 1024, "maximum blocks to track across all peers (0 for no limit)")
+	f.DurationVar(&inputSensorParams.BlocksCache.TTL, "blocks-cache-ttl", 10*time.Minute, "time to live for block cache entries (0 for no expiration)")
 }

cmd/signer/signer.go

@@ -845,7 +845,7 @@ func init() {
 	SignerCmd.AddCommand(ListCmd)
 	SignerCmd.AddCommand(ImportCmd)
 
-	f := SignerCmd.Flags()
+	f := SignerCmd.PersistentFlags()
 	f.StringVar(&inputSignerOpts.keystore, "keystore", "", "use keystore in given folder or file")
 	f.StringVar(&inputSignerOpts.privateKey, "private-key", "", "use provided hex encoded private key")
 	f.StringVar(&inputSignerOpts.kms, "kms", "", "AWS or GCP if key is stored in cloud")

cmd/ulxly/balanceTreeUsage.md

@@ -21,7 +21,12 @@ This is the response from polycli:
 
 ```json
 {
-  "root": "0x4516ca2a793b8e20f56ec6ba8ca6033a672330670a3772f76f2ade9bc2125150"",
+  "root": "0x4516ca2a793b8e20f56ec6ba8ca6033a672330670a3772f76f2ade9bc2125150",
+  "balances": [{
+    "originNetwork": 0,
+    "originTokenAddress": "0x4348967e282138d8f377b467f7d9c2eb0f335d2a",
+    "totalSupply": "993432432123"
+  }]
 }
 ```
 

cmd/ulxly/ulxly.go

@@ -342,15 +342,55 @@ func balanceTree() error {
 	if err != nil {
 		return err
 	}
-	root, err := computeBalanceTree(client, bridgeAddress, l2RawClaimsData, l2NetworkID, l2RawDepositsData)
+	root, balances, err := computeBalanceTree(client, bridgeAddress, l2RawClaimsData, l2NetworkID, l2RawDepositsData)
 	if err != nil {
 		return err
 	}
-	fmt.Printf(`
-	{
-		"root": "%s"
-	}
-	`, root.String())
+	type BalanceEntry struct {
+        OriginNetwork      uint32         `json:"originNetwork"`
+        OriginTokenAddress common.Address `json:"originTokenAddress"`
+        TotalSupply        string         `json:"totalSupply"`
+    }
+
+    var balanceEntries []BalanceEntry
+    for tokenKey, balance := range balances {
+        if balance.Cmp(big.NewInt(0)) == 0 {
+            continue
+        }
+        
+        var token TokenInfo
+        token, err = TokenInfoStringToStruct(tokenKey)
+        if err != nil {
+            return err
+        }
+        
+        if token.OriginNetwork.Uint64() == uint64(l2NetworkID) {
+            continue
+        }
+
+		balanceEntries = append(balanceEntries, BalanceEntry{
+			OriginNetwork:      uint32(token.OriginNetwork.Uint64()),
+			OriginTokenAddress: token.OriginTokenAddress,
+			TotalSupply:        balance.String(),
+		})
+    }
+
+    // Create the response structure
+    response := struct {
+        Root     string         `json:"root"`
+        Balances []BalanceEntry `json:"balances"`
+    }{
+        Root:     root.String(),
+        Balances: balanceEntries,
+    }
+
+    // Marshal to JSON with proper formatting
+    jsonOutput, err := json.MarshalIndent(response, "", "  ")
+    if err != nil {
+        return err
+    }
+
+    fmt.Println(string(jsonOutput))
 	return nil
 }
 
@@ -371,7 +411,7 @@ func nullifierTree(args []string) error {
 	return nil
 }
 
-func nullifierAndBalanceTree(args []string) error {
+func nullifierAndBalanceTree() error {
 	l2NetworkID := balanceTreeOptions.L2NetworkID
 	bridgeAddress := common.HexToAddress(balanceTreeOptions.BridgeAddress)
 
@@ -401,7 +441,7 @@ func nullifierAndBalanceTree(args []string) error {
 		return err
 	}
 	log.Info().Msgf("Last LER count: %d", ler_count)
-	balanceTreeRoot, err := computeBalanceTree(client, bridgeAddress, l2RawClaimsData, l2NetworkID, l2RawDepositsData)
+	balanceTreeRoot, _, err := computeBalanceTree(client, bridgeAddress, l2RawClaimsData, l2NetworkID, l2RawDepositsData)
 	if err != nil {
 		return err
 	}
@@ -432,7 +472,7 @@ func computeNullifierTree(rawClaims []byte) (common.Hash, error) {
 	var root common.Hash
 	for scanner.Scan() {
 		claim := new(ulxly.UlxlyClaimEvent)
-		err := json.Unmarshal(scanner.Bytes(), claim)
+		err = json.Unmarshal(scanner.Bytes(), claim)
 		if err != nil {
 			return common.Hash{}, err
 		}
@@ -456,29 +496,29 @@ func computeNullifierTree(rawClaims []byte) (common.Hash, error) {
 	return root, nil
 }
 
-func computeBalanceTree(client *ethclient.Client, bridgeAddress common.Address, l2RawClaims []byte, l2NetworkID uint32, l2RawDeposits []byte) (common.Hash, error) {
+func computeBalanceTree(client *ethclient.Client, bridgeAddress common.Address, l2RawClaims []byte, l2NetworkID uint32, l2RawDeposits []byte) (common.Hash, map[string]*big.Int, error) {
 	buf := bytes.NewBuffer(l2RawClaims)
 	scanner := bufio.NewScanner(buf)
 	scannerBuf := make([]byte, 0)
 	scanner.Buffer(scannerBuf, 1024*1024)
 	bTree, err := NewBalanceTree()
 	if err != nil {
-		return common.Hash{}, err
+		return common.Hash{}, nil, err
 	}
 	balances := make(map[string]*big.Int)
 	for scanner.Scan() {
 		l2Claim := new(ulxly.UlxlyClaimEvent)
-		err := json.Unmarshal(scanner.Bytes(), l2Claim)
+		err = json.Unmarshal(scanner.Bytes(), l2Claim)
 		if err != nil {
-			return common.Hash{}, err
+			return common.Hash{}, nil, err
 		}
 		token := TokenInfo{
 			OriginNetwork:      big.NewInt(0).SetUint64(uint64(l2Claim.OriginNetwork)),
 			OriginTokenAddress: l2Claim.OriginAddress,
 		}
 		isMessage, err := checkClaimCalldata(client, bridgeAddress, l2Claim.Raw.TxHash)
 		if err != nil {
-			return common.Hash{}, err
+			return common.Hash{}, nil, err
 		}
 		if isMessage {
 			token.OriginNetwork = big.NewInt(0)
@@ -499,7 +539,7 @@ func computeBalanceTree(client *ethclient.Client, bridgeAddress common.Address,
 		l2Deposit := new(ulxly.UlxlyBridgeEvent)
 		err := json.Unmarshal(l2Scanner.Bytes(), l2Deposit)
 		if err != nil {
-			return common.Hash{}, err
+			return common.Hash{}, nil, err
 		}
 		token := TokenInfo{
 			OriginNetwork:      big.NewInt(0).SetUint64(uint64(l2Deposit.OriginNetwork)),
@@ -518,20 +558,20 @@ func computeBalanceTree(client *ethclient.Client, bridgeAddress common.Address,
 		}
 		token, err := TokenInfoStringToStruct(t)
 		if err != nil {
-			return common.Hash{}, err
+			return common.Hash{}, nil, err
 		}
 		if token.OriginNetwork.Uint64() == uint64(l2NetworkID) {
 			continue
 		}
 		root, err = bTree.UpdateBalanceTree(token, balance)
 		if err != nil {
-			return common.Hash{}, err
+			return common.Hash{}, nil, err
 		}
 		log.Info().Msgf("New balanceTree leaf. OriginNetwork: %s, TokenAddress: %s, Balance: %s, Root: %s", token.OriginNetwork.String(), token.OriginTokenAddress.String(), balance.String(), root.String())
 	}
 	log.Info().Msgf("Final balanceTree root: %s", root.String())
 
-	return root, nil
+	return root, balances, nil
 }
 
 func rollupsExitRootProof(args []string) error {
@@ -2409,7 +2449,7 @@ or if it's actually an intermediate hash.`,
 		Short: "Compute the balance tree and the nullifier tree given the deposits and claims.",
 		Long:  nullifierAndBalanceTreeUsage,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return nullifierAndBalanceTree(args)
+			return nullifierAndBalanceTree()
 		},
 		SilenceUsage: true,
 	}

cmd/wallet/wallet.go

@@ -45,7 +45,7 @@ var WalletCmd = &cobra.Command{
 		var err error
 		var mnemonic string
 		if mode == "inspect" {
-			// in the case of inspect, we'll partse a mnemonic and then continue
+			// in the case of inspect, we'll parse a mnemonic and then continue
 			mnemonic, err = getFileOrFlag(inputMnemonicFile, inputMnemonic)
 			if err != nil {
 				return err
@@ -102,17 +102,16 @@ var WalletCmd = &cobra.Command{
 }
 
 func getFileOrFlag(filename string, flag string) (string, error) {
-	if filename != "" {
-		filedata, err := os.ReadFile(filename)
-		if err != nil {
-			return "", fmt.Errorf("could not open the specified file %s. Got error %s", filename, err.Error())
-		}
-		return string(filedata), nil
-	}
-	if flag != "" {
+	if filename == "" {
 		return flag, nil
 	}
-	return "", fmt.Errorf("unable to determine flat or filename")
+
+	filedata, err := os.ReadFile(filename)
+	if err != nil {
+		return "", fmt.Errorf("failed to read file %s: %w", filename, err)
+	}
+
+	return string(filedata), nil
 }
 
 func init() {

doc/polycli_p2p_sensor.md

@@ -24,6 +24,7 @@ If no nodes.json file exists, it will be created.
 
 ```bash
       --api-port uint                 port API server will listen on (default 8080)
+      --blocks-cache-ttl duration     time to live for block cache entries (0 for no expiration) (default 10m0s)
   -b, --bootnodes string              comma separated nodes used for bootstrapping
       --database string               which database to persist data to, options are:
                                         - datastore (GCP Datastore)
@@ -38,13 +39,16 @@ If no nodes.json file exists, it will be created.
   -h, --help                          help for sensor
       --key string                    hex-encoded private key (cannot be set with --key-file)
   -k, --key-file string               private key file (cannot be set with --key)
+      --max-blocks int                maximum blocks to track across all peers (0 for no limit) (default 1024)
   -D, --max-db-concurrency int        maximum number of concurrent database operations to perform (increasing this
                                       will result in less chance of missing data but can significantly increase memory usage) (default 10000)
+      --max-parents int               maximum parent block hashes to track per peer (0 for no limit) (default 1024)
   -m, --max-peers int                 maximum number of peers to connect to (default 2000)
       --max-requests int              maximum request IDs to track per peer (0 for no limit) (default 2048)
       --nat string                    NAT port mapping mechanism (any|none|upnp|pmp|pmp:<IP>|extip:<IP>) (default "any")
   -n, --network-id uint               filter discovered nodes by this network ID
       --no-discovery                  disable P2P peer discovery
+      --parents-cache-ttl duration    time to live for parent hash cache entries (0 for no expiration) (default 5m0s)
       --port int                      TCP network listening port (default 30303)
       --pprof                         run pprof server
       --pprof-port uint               port pprof runs on (default 6060)