review docs

Author: tclemos

cmd/loadtest/app.go

@@ -243,17 +243,16 @@ func initFlags() {
 	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 call-only mode or pre-funded addresses).")
+	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.")
 
 	// 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"
+	ltp.Modes = LoadtestCmd.Flags().StringSliceP("mode", "m", []string{"t"}, `The testing mode to use. It can be multiple like: "d,t"
 2, erc20 - Send ERC20 tokens
 7, erc721 - Mint ERC721 tokens
 b, blob - Send blob transactions
-c, call - Call random contract functions
 cc, contract-call - Make contract calls
 d, deploy - Deploy contracts
 i, inscription - Send inscription transactions

cmd/loadtest/loadtest.go

@@ -285,7 +285,7 @@ func initializeLoadTestParams(ctx context.Context, c *ethclient.Client) error {
 		return errors.New("random mode can't be used in combinations with any other modes")
 	}
 	if hasMode(loadTestModeRPC, inputLoadTestParams.ParsedModes) && inputLoadTestParams.MultiMode && !*inputLoadTestParams.EthCallOnly {
-		return errors.New("rpc mode must be called with call-only when multiple modes are used")
+		return errors.New("rpc mode must be called with eth-call-only when multiple modes are used")
 	} else if hasMode(loadTestModeRPC, inputLoadTestParams.ParsedModes) {
 		log.Trace().Msg("Setting call only mode since we're doing RPC testing")
 		*inputLoadTestParams.EthCallOnly = true
@@ -376,7 +376,7 @@ func initializeLoadTestParams(ctx context.Context, c *ethclient.Client) error {
 				return fmt.Errorf("unable to fund sending addresses. %w", err)
 			}
 		} else if !*inputLoadTestParams.EthCallOnly {
-			// When using multiple sending addresses and not using --call-only and --address-funding-amount <= 0, we need to make sure the addresses get funded
+			// 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
 			// Set default funding to 1 ETH (1000000000000000000 wei)
 			defaultFunding := new(big.Int).SetUint64(1000000000000000000)
 			inputLoadTestParams.AddressFundingAmount = defaultFunding

cmd/loadtest/loadtestUsage.md

@@ -10,32 +10,17 @@ The `--mode` flag is important for this command.
   and cheapest transaction that can be performed.
 - `d`/`deploy` will deploy the load testing contract over and over
   again.
-- `c`/`call` will call random opcodes in our load test contract. The
-  random function that is called will be repeatedly called in a loop
-  based on the number of iterations from the `iterations` flag
-- `f`/`function` works the same way as `call` mode but instead of
-  calling random op codes, the opcode can be specified with the `-f`
-  flag. If you want to call `LOG4` you would pass `-f 164` which is
-  the opcode for `LOG4`.
 - `2`/`erc20` will run an ERC20 transfer test. The process initializes
   by minting a large amount of tokens then transferring it in small
   amounts. Each transaction is a single transfer.
 - `7`/`erc721` will run an ERC721 mint test which will mint an NFT
-  over and over again. The `iterations` flag here can be used to
-  control if we are mint 1 NFT or many.
+  over and over again.
 - `i`/`inc`/`increment` will call the increment function repeatedly on
   the load test contract. It's a minimal example of a contract call
   that will require an update to a contract's storage.
 - `s`/`store` is used to store random data in the smart contract
   storage. The amount of data stored per transaction is controlled
-  with the `byte-count` flag.
-- `P`/`precompiles` will randomly call the commonly implemented
-  precompiled functions. This functions the same way as `call` mode
-  except it's hitting precompiles rather than opcodes.
-- `p`/`precompile` will call a specific precompile in a loop. This
-  works the same way as `function` mode except rather than specifying
-  an opcode, you're specifying a precompile. E.g to call `ECRECOVER`
-  you would pass `-f 1` because it's the contract at address `0x01`
+  with the `store-data-size` flag.
 - `R`/`recall` will attempt to replay all of the transactions from the
   previous blocks. You can use `--recall-blocks` to specify how many
   previous blocks should be used to seed transaction history. It's
@@ -58,12 +43,6 @@ Here is a simple example that runs 1000 requests at a max rate of 1 request per
 $ polycli loadtest --verbosity 700 --chain-id 1256 --concurrency 1 --requests 1000 --rate-limit 1 --mode t --rpc-url http://localhost:8888
 ```
 
-Another example, a bit slower, and that specifically calls the [LOG4](https://www.evm.codes/#a4) function in the load test contract in a loop for 25,078 iterations. That number was picked specifically to require almost all of the gas for a single transaction.
-
-```bash
-$ polycli loadtest --verbosity 700 --chain-id 1256 --concurrency 1 --requests 50 --rate-limit 0.5  --mode f --function 164 --iterations 25078 --rpc-url http://private.validator-001.devnet02.pos-v3.polygon.private:8545
-```
-
 ### Load Test Contract
 
 The codebase has a contract that used for load testing. It's written in Solidity. The workflow for modifying this contract is.

doc/polycli_loadtest.md

@@ -31,32 +31,17 @@ The `--mode` flag is important for this command.
   and cheapest transaction that can be performed.
 - `d`/`deploy` will deploy the load testing contract over and over
   again.
-- `c`/`call` will call random opcodes in our load test contract. The
-  random function that is called will be repeatedly called in a loop
-  based on the number of iterations from the `iterations` flag
-- `f`/`function` works the same way as `call` mode but instead of
-  calling random op codes, the opcode can be specified with the `-f`
-  flag. If you want to call `LOG4` you would pass `-f 164` which is
-  the opcode for `LOG4`.
 - `2`/`erc20` will run an ERC20 transfer test. The process initializes
   by minting a large amount of tokens then transferring it in small
   amounts. Each transaction is a single transfer.
 - `7`/`erc721` will run an ERC721 mint test which will mint an NFT
-  over and over again. The `iterations` flag here can be used to
-  control if we are mint 1 NFT or many.
+  over and over again.
 - `i`/`inc`/`increment` will call the increment function repeatedly on
   the load test contract. It's a minimal example of a contract call
   that will require an update to a contract's storage.
 - `s`/`store` is used to store random data in the smart contract
   storage. The amount of data stored per transaction is controlled
-  with the `byte-count` flag.
-- `P`/`precompiles` will randomly call the commonly implemented
-  precompiled functions. This functions the same way as `call` mode
-  except it's hitting precompiles rather than opcodes.
-- `p`/`precompile` will call a specific precompile in a loop. This
-  works the same way as `function` mode except rather than specifying
-  an opcode, you're specifying a precompile. E.g to call `ECRECOVER`
-  you would pass `-f 1` because it's the contract at address `0x01`
+  with the `store-data-size` flag.
 - `R`/`recall` will attempt to replay all of the transactions from the
   previous blocks. You can use `--recall-blocks` to specify how many
   previous blocks should be used to seed transaction history. It's
@@ -79,12 +64,6 @@ Here is a simple example that runs 1000 requests at a max rate of 1 request per
 $ polycli loadtest --verbosity 700 --chain-id 1256 --concurrency 1 --requests 1000 --rate-limit 1 --mode t --rpc-url http://localhost:8888
 ```
 
-Another example, a bit slower, and that specifically calls the [LOG4](https://www.evm.codes/#a4) function in the load test contract in a loop for 25,078 iterations. That number was picked specifically to require almost all of the gas for a single transaction.
-
-```bash
-$ polycli loadtest --verbosity 700 --chain-id 1256 --concurrency 1 --requests 50 --rate-limit 0.5  --mode f --function 164 --iterations 25078 --rpc-url http://private.validator-001.devnet02.pos-v3.polygon.private:8545
-```
-
 ### Load Test Contract
 
 The codebase has a contract that used for load testing. It's written in Solidity. The workflow for modifying this contract is.
@@ -129,11 +108,10 @@ The codebase has a contract that used for load testing. It's written in Solidity
       --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.
       --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: "c,d,f,t"
+  -m, --mode strings                           The testing mode to use. It can be multiple like: "d,t"
                                                2, erc20 - Send ERC20 tokens
                                                7, erc721 - Mint ERC721 tokens
                                                b, blob - Send blob transactions
-                                               c, call - Call random contract functions
                                                cc, contract-call - Make contract calls
                                                d, deploy - Deploy contracts
                                                i, inscription - Send inscription transactions