rename multi-account flags from addresses to accounts

Author: tclemos

cmd/loadtest/account.go

@@ -143,7 +143,7 @@ func NewAccountPool(ctx context.Context, client *ethclient.Client, fundingPrivat
 	// Debug log for when fundingAmount==0.
 	if fundingAmount.Cmp(big.NewInt(0)) == 0 {
 		log.Debug().
-			Msg("address-funding-amount is zero - account funding disabled")
+			Msg("account-funding-amount is zero - account funding disabled")
 	}
 
 	return &AccountPool{
@@ -383,7 +383,7 @@ func (ap *AccountPool) FundAccounts(ctx context.Context) error {
 	}
 	balance, err := ap.client.BalanceAt(ctx, tops.From, nil)
 	if err != nil {
-		log.Error().Err(err).Msg("Unable to get funding address balance")
+		log.Error().Err(err).Msg("Unable to get funding account balance")
 	}
 
 	totalBalanceNeeded := new(big.Int).Mul(ap.fundingAmount, big.NewInt(int64(len(ap.accounts))))
@@ -484,7 +484,7 @@ func (ap *AccountPool) ReturnFunds(ctx context.Context) error {
 	defer ap.mu.Unlock()
 
 	log.Debug().
-		Msg("Returning funds from sending addresses to funding address")
+		Msg("Returning funds from sending accounts to funding account")
 
 	ethTransferGas := big.NewInt(21000)
 	err := ap.clientRateLimiter.Wait(ctx)
@@ -513,7 +513,7 @@ func (ap *AccountPool) ReturnFunds(ctx context.Context) error {
 	}
 	balanceBefore, err := ap.client.BalanceAt(ctx, fundingAddress, nil)
 	if err != nil {
-		log.Error().Err(err).Msg("Unable to get funding address balance")
+		log.Error().Err(err).Msg("Unable to get funding account balance")
 		return err
 	}
 	log.Debug().
@@ -687,7 +687,7 @@ func (ap *AccountPool) ReturnFunds(ctx context.Context) error {
 	}
 	balanceAfter, err := ap.client.BalanceAt(ctx, fundingAddress, nil)
 	if err != nil {
-		log.Error().Err(err).Msg("Unable to get funding address balance")
+		log.Error().Err(err).Msg("Unable to get funding account balance")
 		return err
 	}
 

cmd/loadtest/app.go

@@ -79,11 +79,11 @@ type (
 		BlobFeeCap                    *uint64
 		StartNonce                    *uint64
 		GasPriceMultiplier            *float64
-		SendingAddressCount           *uint64
-		AddressFundingAmount          *big.Int
-		PreFundSendingAddresses       *bool
+		SendingAccountsCount          *uint64
+		AccountFundingAmount          *big.Int
+		PreFundSendingAccounts        *bool
 		KeepFundsAfterTest            *bool
-		SendingAddressesFile          *string
+		SendingAccountsFile           *string
 		Proxy                         *string
 
 		// Computed
@@ -160,8 +160,8 @@ var (
 		0xF0, 0x0D, 0xBA, 0xBE,
 	}
 
-	randSrc        *rand.Rand
-	defaultFunding = new(big.Int).SetUint64(0) // 1 ETH
+	randSrc                     *rand.Rand
+	defaultAccountFundingAmount = new(big.Int).SetUint64(0) // 1 ETH
 )
 
 // LoadtestCmd represents the loadtest command
@@ -241,12 +241,12 @@ func initFlags() {
 	ltp.LegacyTransactionMode = LoadtestCmd.PersistentFlags().Bool("legacy", false, "Send a legacy transaction instead of an EIP1559 transaction.")
 	ltp.FireAndForget = LoadtestCmd.PersistentFlags().Bool("fire-and-forget", false, "Send transactions and load without waiting for it to be mined.")
 	ltp.BlobFeeCap = LoadtestCmd.Flags().Uint64("blob-fee-cap", 100000, "The blob fee cap, or the maximum blob fee per chunk, in Gwei.")
-	ltp.SendingAddressCount = LoadtestCmd.Flags().Uint64("sending-address-count", 1, "The number of sending addresses to use. This is useful for avoiding pool account queue.")
-	ltp.AddressFundingAmount = defaultFunding
-	LoadtestCmd.Flags().Var(&flag_loader.BigIntValue{Val: ltp.AddressFundingAmount}, "address-funding-amount", "The amount in wei to fund the sending addresses with. Set to 0 to disable account funding (useful for eth-call-only mode or pre-funded addresses).")
-	ltp.PreFundSendingAddresses = LoadtestCmd.Flags().Bool("pre-fund-sending-addresses", false, "If set to true, the sending addresses will be funded at the start of the execution, otherwise all addresses will be funded when used for the first time.")
-	ltp.KeepFundsAfterTest = LoadtestCmd.Flags().Bool("keep-funds-after-test", 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.")
+	ltp.SendingAccountsCount = LoadtestCmd.Flags().Uint64("sending-accounts-count", 1, "The number of sending accounts to use. This is useful for avoiding pool account queue.")
+	ltp.AccountFundingAmount = defaultAccountFundingAmount
+	LoadtestCmd.Flags().Var(&flag_loader.BigIntValue{Val: ltp.AccountFundingAmount}, "account-funding-amount", "The amount in wei to fund the sending accounts with. Set to 0 to disable account funding (useful for eth-call-only mode or pre-funded accounts).")
+	ltp.PreFundSendingAccounts = LoadtestCmd.Flags().Bool("pre-fund-sending-accounts", false, "If set to true, the sending accounts will be funded at the start of the execution, otherwise all accounts will be funded when used for the first time.")
+	ltp.KeepFundsAfterTest = LoadtestCmd.Flags().Bool("keep-funds-after-test", false, "If set to true, the funded amount will be kept in the sending accounts. Otherwise, the funded amount will be refunded back to the account used to fund the account.")
+	ltp.SendingAccountsFile = LoadtestCmd.Flags().String("sending-accounts-file", "", "The file containing the sending accounts private keys, one per line. This is useful for avoiding pool account queue but also to keep the same sending accounts 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: "d,t"

cmd/loadtest/loadtest.go

@@ -302,22 +302,22 @@ func initializeLoadTestParams(ctx context.Context, c *ethclient.Client) error {
 
 	randSrc = rand.New(rand.NewSource(*inputLoadTestParams.Seed))
 
-	sendingAddressCount := *inputLoadTestParams.SendingAddressCount
-	preFundSendingAddresses := *inputLoadTestParams.PreFundSendingAddresses
-	fundingAmount := inputLoadTestParams.AddressFundingAmount
-	sendingAddressesFile := *inputLoadTestParams.SendingAddressesFile
+	sendingAccountsCount := *inputLoadTestParams.SendingAccountsCount
+	preFundSendingAccounts := *inputLoadTestParams.PreFundSendingAccounts
+	fundingAmount := inputLoadTestParams.AccountFundingAmount
+	sendingAccountsFile := *inputLoadTestParams.SendingAccountsFile
 	accountPool, err = NewAccountPool(ctx, c, privateKey, fundingAmount)
 	if err != nil {
 		log.Error().Err(err).Msg("Unable to create account pool")
 		return fmt.Errorf("unable to create account pool. %w", err)
 	}
 
-	if len(sendingAddressesFile) > 0 {
+	if len(sendingAccountsFile) > 0 {
 		log.Trace().
-			Str("sendingAddressFile", sendingAddressesFile).
+			Str("sendingAccountsFile", sendingAccountsFile).
 			Msg("Adding accounts from file to the account pool")
 
-		privateKeys, iErr := readPrivateKeysFromFile(sendingAddressesFile)
+		privateKeys, iErr := readPrivateKeysFromFile(sendingAccountsFile)
 		if iErr != nil {
 			log.Error().
 				Err(iErr).
@@ -326,25 +326,25 @@ func initializeLoadTestParams(ctx context.Context, c *ethclient.Client) error {
 		}
 		if len(privateKeys) == 0 && *inputLoadTestParams.StartNonce > 0 {
 			log.Fatal().
-				Str("sendingAddressFile", sendingAddressesFile).
+				Str("sendingAccountsFile", sendingAccountsFile).
 				Msg("nonce can't be set while using multiple sending accounts")
 		}
 
 		err = accountPool.AddN(ctx, privateKeys...)
-	} else if sendingAddressCount > 1 {
+	} else if sendingAccountsCount > 1 {
 		log.Trace().
-			Uint64("sendingAddressCount", sendingAddressCount).
+			Uint64("sendingAccountsCount", sendingAccountsCount).
 			Msg("Adding random accounts to the account pool")
 
 		if *inputLoadTestParams.StartNonce > 0 {
 			log.Fatal().
-				Uint64("sendingAddressCount", sendingAddressCount).
+				Uint64("sendingAccountsCount", sendingAccountsCount).
 				Msg("nonce can't be set while using multiple sending accounts")
 		}
-		err = accountPool.AddRandomN(ctx, sendingAddressCount)
+		err = accountPool.AddRandomN(ctx, sendingAccountsCount)
 	} else {
 		log.Trace().
-			Uint64("sendingAddressCount", sendingAddressCount).
+			Uint64("sendingAccountsCount", sendingAccountsCount).
 			Msg("Using the same account for all transactions")
 		var nonce *uint64
 		if *inputLoadTestParams.StartNonce > 0 {
@@ -358,40 +358,40 @@ func initializeLoadTestParams(ctx context.Context, c *ethclient.Client) error {
 		return fmt.Errorf("unable to set account pool. %w", err)
 	}
 
-	// Only call FundAccounts() to prefund addresses if preFundSendingAddresses enabled and sendingAddressCount > 1.
-	// For single addresses, it will not be prefunded.
-	if preFundSendingAddresses && sendingAddressCount > 1 {
-		// Check if we need to auto-set funding amount for multiple addresses or pre-funding
-		if inputLoadTestParams.AddressFundingAmount.Cmp(new(big.Int)) > 0 {
+	// Only call FundAccounts() to pre fund accounts if preFundSendingAccounts enabled and sendingAAccountsCount > 1.
+	// For single account, it will not be prefunded.
+	if preFundSendingAccounts && sendingAccountsCount > 1 {
+		// Check if we need to auto-set funding amount for multiple accounts or pre-funding
+		if inputLoadTestParams.AccountFundingAmount.Cmp(new(big.Int)) > 0 {
 			err := accountPool.FundAccounts(ctx)
 			if err != nil {
-				log.Error().Err(err).Msg("Unable to fund sending addresses")
+				log.Error().Err(err).Msg("Unable to fund sending accounts")
 				iErr := accountPool.ReturnFunds(ctx)
 				if iErr != nil {
 					log.Error().
 						Err(iErr).
-						Msg("There was an issue returning the funds from the sending addresses back to the funding address")
-					return fmt.Errorf("unable to return funds from sending addresses. %w", iErr)
+						Msg("There was an issue returning the funds from the sending accounts back to the funding account")
+					return fmt.Errorf("unable to return funds from sending accounts. %w", iErr)
 				}
-				return fmt.Errorf("unable to fund sending addresses. %w", err)
+				return fmt.Errorf("unable to fund sending accounts. %w", err)
 			}
 		} else if !*inputLoadTestParams.EthCallOnly {
-			// When using multiple sending addresses and not using --eth-call-only and --address-funding-amount <= 0, we need to make sure the addresses get funded
+			// When using multiple sending accounts and not using --eth-call-only and --account-funding-amount <= 0, we need to make sure the accounts get funded
 			// Set default funding to 1 ETH (1000000000000000000 wei)
 			defaultFunding := new(big.Int).SetUint64(1000000000000000000)
-			inputLoadTestParams.AddressFundingAmount = defaultFunding
+			inputLoadTestParams.AccountFundingAmount = defaultFunding
 			log.Debug().
-				Msg("Multiple sending addresses detected with pre-funding enabled with zero funding amount - auto-setting funding amount to 1 ETH")
+				Msg("Multiple sending accounts detected with pre-funding enabled with zero funding amount - auto-setting funding amount to 1 ETH")
 		}
 	}
 
 	return nil
 }
 
-func readPrivateKeysFromFile(sendingAddressesFile string) ([]*ecdsa.PrivateKey, error) {
-	file, err := os.Open(sendingAddressesFile)
+func readPrivateKeysFromFile(sendingAccountsFile string) ([]*ecdsa.PrivateKey, error) {
+	file, err := os.Open(sendingAccountsFile)
 	if err != nil {
-		return nil, fmt.Errorf("unable to open sending addresses file: %w", err)
+		return nil, fmt.Errorf("unable to open sending accounts file: %w", err)
 	}
 	defer file.Close()
 
@@ -411,7 +411,7 @@ func readPrivateKeysFromFile(sendingAddressesFile string) ([]*ecdsa.PrivateKey,
 	}
 
 	if err := scanner.Err(); err != nil {
-		return nil, fmt.Errorf("error reading sending address file: %w", err)
+		return nil, fmt.Errorf("error reading sending accounts file: %w", err)
 	}
 
 	return privateKeys, nil
@@ -453,7 +453,7 @@ func completeLoadTest(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Clie
 	if err != nil {
 		log.Error().
 			Err(err).
-			Msg("There was an issue returning the funds from the sending addresses back to the funding address")
+			Msg("There was an issue returning the funds from the sending accounts back to the funding account")
 	}
 
 	if *inputLoadTestParams.ShouldProduceSummary {

doc/load-testing-guide.md

@@ -153,15 +153,15 @@ The loadtest command provided by `polycli` send all the transactions with the sa
 the test requires multiple accounts to be used in order to avoid the pool queue limits, the `polycli` supports
 multi-account by setting the following flags:
 
-- `sending-address-count`: defines the number of accounts that will be created to send the test txs
-- `address-funding-amount`: defines the amount that will be funded to each sending account that will be created
-- `pre-fund-sending-addresses`: if set to true, the sending addresses will be funded at the start of the execution of
+- `sending-accounts-count`: defines the number of accounts that will be created to send the test txs
+- `account-funding-amount`: defines the amount that will be funded to each sending account that will be created
+- `pre-fund-sending-accounts`: if set to true, the sending account will be funded at the start of the execution of
 the load test, funding all the created accounts concurrently, otherwise all sending accounts will be funded only when
 used for the first time.
 - `keep-funded-amount`: by default, at the final of the load test execution, all the funds funded to the sending
 accounts that were created during the execution will be returned to the funding account, which is the account set in the 
 `--private-key` flag. In case you want the funded funds to remain in the created accounts, set it to `true`
-- `sending-addresses-file`: defines the path to a file containing a list of private keys to be used by the load test.
+- `sending-accounts-file`: defines the path to a file containing a list of private keys to be used by the load test.
 Instead of creating new accounts, the test will use only the accounts defined in the file with the private keys as the
 accounts that will send the test txs
 

doc/polycli_loadtest.md

@@ -79,12 +79,12 @@ The codebase has a contract that used for load testing. It's written in Solidity
 ## Flags
 
 ```bash
+      --account-funding-amount big.Int         The amount in wei to fund the sending accounts with. Set to 0 to disable account funding (useful for eth-call-only mode or pre-funded accounts).
       --adaptive-backoff-factor float          When using adaptive rate limiting, this flag controls our multiplicative decrease value. (default 2)
       --adaptive-cycle-duration-seconds uint   When using adaptive rate limiting, this flag controls how often we check the queue size and adjust the rates (default 10)
       --adaptive-rate-limit                    Enable AIMD-style congestion control to automatically adjust request rate
       --adaptive-rate-limit-increment uint     When using adaptive rate limiting, this flag controls the size of the additive increases. (default 50)
       --adaptive-target-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)
-      --address-funding-amount big.Int         The amount in wei to fund the sending addresses with. Set to 0 to disable account funding (useful for eth-call-only mode or pre-funded addresses).
       --batch-size uint                        Number of batches to perform at a time for receipt fetching. Default is 999 requests at a time. (default 999)
       --blob-fee-cap uint                      The blob fee cap, or the maximum blob fee per chunk, in Gwei. (default 100000)
       --calldata string                        The hex encoded calldata passed in. The format is function signature + arguments encoded together. This must be paired up with --mode contract-call and --contract-address
@@ -105,7 +105,7 @@ The codebase has a contract that used for load testing. It's written in Solidity
       --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\"}")
-      --keep-funds-after-test                  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.
+      --keep-funds-after-test                  If set to true, the funded amount will be kept in the sending accounts. 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.
       --loadtest-contract-address string       The address of a pre-deployed load test contract
   -m, --mode strings                           The testing mode to use. It can be multiple like: "d,t"
@@ -124,7 +124,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 funded at the start of the execution, otherwise all addresses will be funded when used for the first time.
+      --pre-fund-sending-accounts              If set to true, the sending accounts will be funded at the start of the execution, otherwise all accounts 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")
       --proxy string                           Use the proxy specified
@@ -134,8 +134,8 @@ The codebase has a contract that used for load testing. It's written in Solidity
   -n, --requests int                           Number of requests to perform for the benchmarking session. The default is to just perform a single request which usually leads to non-representative benchmarking results. (default 1)
   -r, --rpc-url string                         The RPC endpoint url (default "http://localhost:8545")
       --seed int                               A seed for generating random values and addresses (default 123456)
-      --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.
+      --sending-accounts-count uint            The number of sending accounts to use. This is useful for avoiding pool account queue. (default 1)
+      --sending-accounts-file string           The file containing the sending accounts private keys, one per line. This is useful for avoiding pool account queue but also to keep the same sending accounts for different execution cycles.
       --store-data-size uint                   If we're in store mode, this controls how many bytes we'll try to store in our contract (default 1024)
       --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)