add loadtest support to a file with private keys to set the sending addresses

Author: tclemos

cmd/loadtest/account.go

@@ -136,6 +136,18 @@ func (ap *AccountPool) AddRandom() error {
 	return ap.Add(privateKey)
 }
 
+// Adds multiple accounts to the pool with the given private keys
+func (ap *AccountPool) AddN(privateKeys ...*ecdsa.PrivateKey) error {
+	for _, privateKey := range privateKeys {
+		err := ap.Add(privateKey)
+		if err != nil {
+			return fmt.Errorf("failed to add account: %w", err)
+		}
+	}
+
+	return nil
+}
+
 // Adds an account to the pool with the given private key
 func (ap *AccountPool) Add(privateKey *ecdsa.PrivateKey) error {
 	ap.mu.Lock()

cmd/loadtest/app.go

@@ -86,6 +86,7 @@ type (
 		AddressFundingAmount          *uint64
 		PreFundSendingAddresses       *bool
 		KeepFundedAmount              *bool
+		SendingAddressesFile          *string
 
 		// Computed
 		CurrentGasPrice       *big.Int
@@ -250,6 +251,7 @@ func initFlags() {
 	ltp.AddressFundingAmount = LoadtestCmd.Flags().Uint64("address-funding-amount", 1000000000000000000, "The amount in gwei to fund the sending addresses with.")
 	ltp.PreFundSendingAddresses = LoadtestCmd.Flags().Bool("pre-fund-sending-addresses", false, "If set to true, the sending addresses will be fund at the start of the execution, otherwise all addresses will be funded when used for the first time.")
 	ltp.KeepFundedAmount = LoadtestCmd.Flags().Bool("keep-funded-amount", false, "If set to true, the funded amount will be kept in the sending addresses. Otherwise, the funded amount will be refunded back to the account used to fund the account.")
+	ltp.SendingAddressesFile = LoadtestCmd.Flags().String("sending-addresses-file", "", "The file containing the sending addresses private keys, one per line. This is useful for avoiding pool account queue but also to keep the same sending addresses for different execution cycles.")
 
 	// Local flags.
 	ltp.Modes = LoadtestCmd.Flags().StringSliceP("mode", "m", []string{"t"}, `The testing mode to use. It can be multiple like: "c,d,f,t"

cmd/loadtest/loadtest.go

@@ -1,7 +1,9 @@
 package loadtest
 
 import (
+	"bufio"
 	"context"
+	"crypto/ecdsa"
 	_ "embed"
 	"encoding/hex"
 	"encoding/json"
@@ -329,10 +331,30 @@ func initializeLoadTestParams(ctx context.Context, c *ethclient.Client) error {
 	// setup account pool
 	fundingAmount := *inputLoadTestParams.AddressFundingAmount
 	sendingAddressCount := *inputLoadTestParams.SendingAddressCount
+	sendingAddressesFile := *inputLoadTestParams.SendingAddressesFile
 	accountPool = NewAccountPool(ctx, c, privateKey, big.NewInt(0).SetUint64(fundingAmount))
-	if sendingAddressCount > 1 {
+	if len(sendingAddressesFile) > 0 {
+		log.Trace().
+			Str("sendingAddressFile", sendingAddressesFile).
+			Msg("Adding accounts from file to the account pool")
+
+		privateKeys, iErr := readPrivateKeysFromFile(sendingAddressesFile)
+		if iErr != nil {
+			log.Error().
+				Err(iErr).
+				Msg("Unable to read private keys from file")
+			return fmt.Errorf("unable to read private keys from file. %w", iErr)
+		}
+		err = accountPool.AddN(privateKeys...)
+	} else if sendingAddressCount > 1 {
+		log.Trace().
+			Uint64("sendingAddressCount", sendingAddressCount).
+			Msg("Adding random accounts to the account pool")
 		err = accountPool.AddRandomN(sendingAddressCount)
 	} else {
+		log.Trace().
+			Uint64("sendingAddressCount", sendingAddressCount).
+			Msg("Using the same account for all transactions")
 		err = accountPool.Add(privateKey)
 	}
 	if err != nil {
@@ -352,6 +374,35 @@ func initializeLoadTestParams(ctx context.Context, c *ethclient.Client) error {
 	return nil
 }
 
+func readPrivateKeysFromFile(sendingAddressesFile string) ([]*ecdsa.PrivateKey, error) {
+	file, err := os.Open(sendingAddressesFile)
+	if err != nil {
+		return nil, fmt.Errorf("unable to open sending addresses file: %w", err)
+	}
+	defer file.Close()
+
+	var privateKeys []*ecdsa.PrivateKey
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if len(line) == 0 {
+			continue
+		}
+		privateKey, err := ethcrypto.HexToECDSA(strings.TrimPrefix(line, "0x"))
+		if err != nil {
+			log.Error().Err(err).Str("key", line).Msg("Unable to parse private key")
+			return nil, fmt.Errorf("unable to parse private key: %w", err)
+		}
+		privateKeys = append(privateKeys, privateKey)
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("error reading sending address file: %w", err)
+	}
+
+	return privateKeys, nil
+}
+
 func initNonce(ctx context.Context, c *ethclient.Client) error {
 	currentNonceMutex.Lock()
 	defer currentNonceMutex.Unlock()

doc/polycli_fund.md

@@ -79,7 +79,7 @@ $ cast balance 0x5D8121cf716B70d3e345adB58157752304eED5C3
 ```bash
       --addresses strings         Comma-separated list of wallet addresses to fund
       --contract-address string   The address of a pre-deployed Funder contract
-  -a, --eth-amount float          The amount of ether to send to each wallet (default 0.05)
+  -a, --eth-amount uint           The amount of ether in wei to send to each wallet (default 50000000000000000)
   -f, --file string               The output JSON file path for storing the addresses and private keys of funded wallets (default "wallets.json")
       --hd-derivation             Derive wallets to fund from the private key in a deterministic way (default true)
   -h, --help                      help for fund

doc/polycli_loadtest.md

@@ -117,18 +117,18 @@ The codebase has a contract that used for load testing. It's written in Solidity
       --contract-call-payable                  Use this flag if the function is payable, the value amount passed will be from --eth-amount. This must be paired up with --mode contract-call and --contract-address
       --erc20-address string                   The address of a pre-deployed ERC20 contract
       --erc721-address string                  The address of a pre-deployed ERC721 contract
-      --eth-amount float                       The amount of ether to send on every transaction
+      --eth-amount uint                        The amount of ether in wei to send on every transaction
       --force-contract-deploy                  Some load test modes don't require a contract deployment. Set this flag to true to force contract deployments. This will still respect the --lt-address flags.
   -f, --function uint                          A specific function to be called if running with --mode f or a specific precompiled contract when running with --mode a (default 1)
       --function-arg strings                   The arguments that will be passed to a contract function call. This must be paired up with "--mode contract-call" and "--contract-address". Args can be passed multiple times: "--function-arg 'test' --function-arg 999" or comma separated values "--function-arg "test",9". The ordering of the arguments must match the ordering of the function parameters.
       --function-signature string              The contract's function signature that will be called. The format is '<function name>(<types...>)'. This must be paired up with '--mode contract-call' and '--contract-address'. If the function requires parameters you can pass them with '--function-arg <value>'.
-      --fund-sending-addresses-on-demand       If set to true, the sending addresses will be funded when used for the first time, otherwise all addresses will be fund at the start of the execution. (default true)
       --gas-limit uint                         In environments where the gas limit can't be computed on the fly, we can specify it manually. This can also be used to avoid eth_estimateGas
       --gas-price uint                         In environments where the gas price can't be determined automatically, we can specify it manually
       --gas-price-multiplier float             A multiplier to increase or decrease the gas price (default 1)
   -h, --help                                   help for loadtest
       --inscription-content string             The inscription content that will be encoded as calldata. This must be paired up with --mode inscription (default "data:,{\"p\":\"erc-20\",\"op\":\"mint\",\"tick\":\"TEST\",\"amt\":\"1\"}")
   -i, --iterations uint                        If we're making contract calls, this controls how many times the contract will execute the instruction in a loop. If we are making ERC721 Mints, this indicates the minting batch size (default 1)
+      --keep-funded-amount                     If set to true, the funded amount will be kept in the sending addresses. Otherwise, the funded amount will be refunded back to the account used to fund the account.
       --legacy                                 Send a legacy transaction instead of an EIP1559 transaction.
       --lt-address string                      The address of a pre-deployed load test contract
   -m, --mode strings                           The testing mode to use. It can be multiple like: "c,d,f,t"
@@ -151,6 +151,7 @@ The codebase has a contract that used for load testing. It's written in Solidity
                                                v3, uniswapv3 - Perform UniswapV3 swaps (default [t])
       --nonce uint                             Use this flag to manually set the starting nonce
       --output-mode string                     Format mode for summary output (json | text) (default "text")
+      --pre-fund-sending-addresses             If set to true, the sending addresses will be fund at the start of the execution, otherwise all addresses will be funded when used for the first time.
       --priority-gas-price uint                Specify Gas Tip Price in the case of EIP-1559
       --private-key string                     The hex encoded private key that we'll use to send transactions (default "42b6e34dc21598a807dc19d7784c71b2a7a01f6480dc6f58258f78e539f1a1fa")
       --rate-limit float                       An overall limit to the number of requests per second. Give a number less than zero to remove this limit all together (default 4)
@@ -160,6 +161,7 @@ The codebase has a contract that used for load testing. It's written in Solidity
       --seed int                               A seed for generating random values and addresses (default 123456)
       --send-only                              Send transactions and load without waiting for it to be mined.
       --sending-address-count uint             The number of sending addresses to use. This is useful for avoiding pool account queue. (default 1)
+      --sending-addresses-file string          The file containing the sending addresses private keys, one per line. This is useful for avoiding pool account queue but also to keep the same sending addresses for different execution cycles.
       --steady-state-tx-pool-size uint         When using adaptive rate limiting, this value sets the target queue size. If the queue is smaller than this value, we'll speed up. If the queue is smaller than this value, we'll back off. (default 1000)
       --summarize                              Should we produce an execution summary after the load test has finished. If you're running a large load test, this can take a long time
   -t, --time-limit int                         Maximum number of seconds to spend for benchmarking. Use this to benchmark within a fixed total amount of time. Per default there is no time limit. (default -1)

doc/polycli_loadtest_uniswapv3.md

@@ -86,7 +86,7 @@ The command also inherits flags from parent commands.
       --chain-id uint                          The chain id for the transactions.
   -c, --concurrency int                        Number of requests to perform concurrently. Default is one request at a time. (default 1)
       --config string                          config file (default is $HOME/.polygon-cli.yaml)
-      --eth-amount float                       The amount of ether to send on every transaction
+      --eth-amount uint                        The amount of ether in wei to send on every transaction
       --gas-limit uint                         In environments where the gas limit can't be computed on the fly, we can specify it manually. This can also be used to avoid eth_estimateGas
       --gas-price uint                         In environments where the gas price can't be determined automatically, we can specify it manually
       --gas-price-multiplier float             A multiplier to increase or decrease the gas price (default 1)