feat(loadtest): implement uniswapv3 loadtest

Makefile

@@ -83,6 +83,7 @@ gen-go-bindings: ## Generate go bindings for smart contracts.
 	$(call gen_go_binding,contracts/tokens/ERC20,ERC20,tokens,contracts/tokens)
 	$(call gen_go_binding,contracts/tokens/ERC721,ERC721,tokens,contracts/tokens)
 	$(call gen_go_binding,contracts/loadtester,LoadTester,contracts,contracts)
+	cd contracts/uniswapv3 && ./build.sh all && ./bindings.sh
 
 # Generate go binding.
 # - $1: input_dir

README.md

@@ -8,7 +8,7 @@ We run a lot of different blockchain technologies. Different tools often have in
 - [Features](#features)
 - [Testing](#testing)
 - [Contributing](#contributing)
-- [References](#references)
+- [Reference](#reference)
 
 ## Install
 
@@ -148,43 +148,11 @@ You can then generate some load to make sure that blocks with transactions are b
 $ polycli loadtest --verbosity 700 --chain-id 1337 --concurrency 1 --requests 1000 --rate-limit 5 --mode c http://127.0.0.1:8545
 ```
 
-## Contributing
+# Contributing
 
-The `Makefile` is here to assist you to build the project, run tests, generate documentation or go bindings, etc.
+- If you add a new loadtest mode, don't forget to update the loadtest mode string by running the following command: `cd cmd/loadtest && stringer -type=loadTestMode`. You can install [stringer](https://pkg.go.dev/golang.org/x/tools/cmd/stringer) with `go install golang.org/x/tools/cmd/stringer@latest`.
 
-```sh
-$ make
-Usage:
-  make <target>
-  help             Display this help.
-
-Build
-  generate         Generate protobuf stubs.
-  build            Build go binary.
-  install          Install the go binary.
-  cross            Cross-compile go binaries using CGO.
-  simplecross      Cross-compile go binaries without using CGO.
-  clean            Clean the binary folder.
-
-Test
-  test             Run tests.
-
-Generation
-  gen-doc          Generate documentation for `polycli`.
-  gen-loadtest-modes  Generate loadtest modes strings.
-  gen-go-bindings  Generate go bindings for smart contracts.
-
-Lint
-  lint             Run linters.
-
-Clients
-  geth             Start a local geth node.
-  avail            Start a local avail node.
-  geth-loadtest    Fund test account with 5k ETH and run loadtest against an EVM/Geth chain.
-  avail-loadtest   Run loadtest against an Avail chain.
-```
-
-## References
+# Reference
 
 Sending some value to the default load testing account.
 

cmd/loadtest/app.go

@@ -91,8 +91,8 @@ type (
 )
 
 var (
-	//go:embed usage.md
-	usage               string
+	//go:embed genericUsage.md
+	genericUsage        string
 	inputLoadTestParams loadTestParams
 	loadTestResults     []loadTestSample
 	loadTestResutsMutex sync.RWMutex
@@ -150,7 +150,7 @@ var (
 var LoadtestCmd = &cobra.Command{
 	Use:   "loadtest url",
 	Short: "Run a generic load test against an Eth/EVM style JSON-RPC endpoint.",
-	Long:  usage,
+	Long:  genericUsage,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		err := runLoadTest(cmd.Context())
 		if err != nil {
@@ -188,8 +188,12 @@ var LoadtestCmd = &cobra.Command{
 }
 
 func init() {
-	ltp := new(loadTestParams)
+	initFlags()
+	initSubCommands()
+}
 
+func initFlags() {
+	ltp := new(loadTestParams)
 	ltp.Requests = LoadtestCmd.PersistentFlags().Int64P("requests", "n", 1, "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.")
 	ltp.Concurrency = LoadtestCmd.PersistentFlags().Int64P("concurrency", "c", 1, "Number of requests to perform concurrently. Default is one request at a time.")
 	ltp.TimeLimit = LoadtestCmd.PersistentFlags().Int64P("time-limit", "t", -1, "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.")
@@ -206,7 +210,7 @@ func init() {
 	ltp.AdaptiveRateLimitIncrement = LoadtestCmd.PersistentFlags().Uint64("adaptive-rate-limit-increment", 50, "When using adaptive rate limiting, this flag controls the size of the additive increases.")
 	ltp.AdaptiveCycleDuration = LoadtestCmd.PersistentFlags().Uint64("adaptive-cycle-duration-seconds", 10, "When using adaptive rate limiting, this flag controls how often we check the queue size and adjust the rates")
 	ltp.AdaptiveBackoffFactor = LoadtestCmd.PersistentFlags().Float64("adaptive-backoff-factor", 2, "When using adaptive rate limiting, this flag controls our multiplicative decrease value.")
-	ltp.Modes = LoadtestCmd.PersistentFlags().StringSliceP("mode", "m", []string{"t"}, `The testing mode to use. It can be multiple like: "t,c,d,f"
+	ltp.Modes = LoadtestCmd.Flags().StringSliceP("mode", "m", []string{"t"}, `The testing mode to use. It can be multiple like: "t,c,d,f"
 t - sending transactions
 d - deploy contract
 c - call random contract functions
@@ -217,15 +221,16 @@ s - store mode
 r - random modes
 2 - ERC20 Transfers
 7 - ERC721 Mints
+v3 - UniswapV3 swaps
 R - total recall
 rpc - call random rpc methods`)
 	ltp.Function = LoadtestCmd.PersistentFlags().Uint64P("function", "f", 1, "A specific function to be called if running with `--mode f` or a specific precompiled contract when running with `--mode a`")
 	ltp.Iterations = LoadtestCmd.PersistentFlags().Uint64P("iterations", "i", 1, "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")
 	ltp.ByteCount = LoadtestCmd.PersistentFlags().Uint64P("byte-count", "b", 1024, "If we're in store mode, this controls how many bytes we'll try to store in our contract")
 	ltp.Seed = LoadtestCmd.PersistentFlags().Int64("seed", 123456, "A seed for generating random values and addresses")
 	ltp.LtAddress = LoadtestCmd.PersistentFlags().String("lt-address", "", "The address of a pre-deployed load test contract")
-	ltp.ERC20Address = LoadtestCmd.PersistentFlags().String("erc20-address", "", "The address of a pre-deployed erc 20 contract")
-	ltp.ERC721Address = LoadtestCmd.PersistentFlags().String("erc721-address", "", "The address of a pre-deployed erc 721 contract")
+	ltp.ERC20Address = LoadtestCmd.PersistentFlags().String("erc20-address", "", "The address of a pre-deployed ERC20 contract")
+	ltp.ERC721Address = LoadtestCmd.PersistentFlags().String("erc721-address", "", "The address of a pre-deployed ERC721 contract")
 	ltp.ContractCallNumberOfBlocksToWaitFor = LoadtestCmd.PersistentFlags().Uint64("contract-call-nb-blocks-to-wait-for", 30, "The number of blocks to wait for before giving up on a contract deployment")
 	ltp.ContractCallBlockInterval = LoadtestCmd.PersistentFlags().Uint64("contract-call-block-interval", 1, "During deployment, this flag controls if we should check every block, every other block, or every nth block to determine that the contract has been deployed")
 	ltp.ForceContractDeploy = LoadtestCmd.PersistentFlags().Bool("force-contract-deploy", false, "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.")
@@ -241,3 +246,7 @@ rpc - call random rpc methods`)
 
 	// TODO Compression
 }
+
+func initSubCommands() {
+	LoadtestCmd.AddCommand(uniswapV3LoadTestCmd)
+}

cmd/loadtest/loadtest.go

@@ -17,6 +17,10 @@ import (
 
 	"github.com/maticnetwork/polygon-cli/contracts"
 	"github.com/maticnetwork/polygon-cli/contracts/tokens"
+	"github.com/maticnetwork/polygon-cli/contracts/uniswapv3"
+
+	_ "embed"
+
 	"github.com/maticnetwork/polygon-cli/metrics"
 	"github.com/maticnetwork/polygon-cli/rpctypes"
 	"github.com/maticnetwork/polygon-cli/util"
@@ -51,6 +55,7 @@ const (
 	loadTestModeERC721
 	loadTestModePrecompiledContracts
 	loadTestModePrecompiledContract
+	loadTestModeUniswapV3
 
 	// All the modes AFTER random mode will not be used when mode random is selected
 	loadTestModeRandom
@@ -61,6 +66,8 @@ const (
 	codeQualityPrivateKey = "42b6e34dc21598a807dc19d7784c71b2a7a01f6480dc6f58258f78e539f1a1fa"
 )
 
+var waitingPeriodExhaustedErr = fmt.Errorf("waiting period exhausted")
+
 func characterToLoadTestMode(mode string) (loadTestMode, error) {
 	switch mode {
 	case "t", "transaction":
@@ -87,6 +94,8 @@ func characterToLoadTestMode(mode string) (loadTestMode, error) {
 		return loadTestModePrecompiledContracts, nil
 	case "R", "recall":
 		return loadTestModeRecall, nil
+	case "v3", "uniswapv3":
+		return loadTestModeUniswapV3, nil
 	case "rpc":
 		return loadTestModeRPC, nil
 	default:
@@ -432,6 +441,62 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 		log.Debug().Str("erc721Addr", erc721Addr.String()).Msg("Obtained erc 721 contract address")
 	}
 
+	uniswapAddresses := UniswapV3Addresses{
+		FactoryV3:                   ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapFactoryV3),
+		Multicall:                   ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapMulticall),
+		ProxyAdmin:                  ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapProxyAdmin),
+		TickLens:                    ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapTickLens),
+		NFTDescriptorLib:            ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapNFTLibDescriptor),
+		NFTPositionDescriptor:       ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapNFTPositionDescriptor),
+		TransparentUpgradeableProxy: ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapUpgradeableProxy),
+		NFPositionManager:           ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapNFPositionManager),
+		Migrator:                    ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapMigrator),
+		Staker:                      ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapStaker),
+		QuoterV2:                    ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapQuoterV2),
+		SwapRouter02:                ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapSwapRouter),
+		WETH9:                       ethcommon.HexToAddress(*uniswapv3LoadTestParams.WETH9),
+	}
+	var uniswapV3Config UniswapV3Config
+	var poolConfig PoolConfig
+	if mode == loadTestModeUniswapV3 || mode == loadTestModeRandom {
+		uniswapV3Config, err = deployUniswapV3(ctx, c, tops, cops, uniswapAddresses, *ltp.FromETHAddress)
+		if err != nil {
+			return nil
+		}
+		log.Debug().Interface("config", uniswapV3Config.ToAddresses()).Msg("UniswapV3 deployment config")
+
+		tokensAToMint := big.NewInt(1_000_000_000_000_000_000)
+		var token0Config contractConfig[uniswapv3.Swapper]
+		token0Config, err = deploySwapperContract(ctx, c, tops, cops, uniswapV3Config, "Token0", "A", tokensAToMint, *ltp.FromETHAddress, ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapPoolToken0))
+		if err != nil {
+			return nil
+		}
+
+		tokensBToMint := big.NewInt(1_000_000_000_000_000_000)
+		var token1Config contractConfig[uniswapv3.Swapper]
+		token1Config, err = deploySwapperContract(ctx, c, tops, cops, uniswapV3Config, "Token1", "B", tokensBToMint, *ltp.FromETHAddress, ethcommon.HexToAddress(*uniswapv3LoadTestParams.UniswapPoolToken1))
+		if err != nil {
+			return nil
+		}
+
+		fees := big.NewInt(3_000)
+		poolConfig = PoolConfig{Fees: fees}
+		if token0Config.Address.Hex() < token1Config.Address.Hex() {
+			poolConfig.Token0 = token0Config
+			poolConfig.ReserveA = tokensAToMint
+			poolConfig.Token1 = token1Config
+			poolConfig.ReserveB = tokensBToMint
+		} else {
+			poolConfig.Token0 = token1Config
+			poolConfig.ReserveA = tokensBToMint
+			poolConfig.Token1 = token0Config
+			poolConfig.ReserveB = tokensAToMint
+		}
+		if err = createPool(ctx, c, tops, cops, uniswapV3Config, poolConfig, *ltp.FromETHAddress); err != nil {
+			return nil
+		}
+	}
+
 	var recallTransactions []rpctypes.PolyTransaction
 	if mode == loadTestModeRecall {
 		recallTransactions, err = getRecallTransactions(ctx, c, rpc)
@@ -535,6 +600,8 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 					startReq, endReq, tErr = loadTestCallPrecompiledContracts(ctx, c, myNonceValue, ltContract, false)
 				case loadTestModeRecall:
 					startReq, endReq, tErr = loadTestRecall(ctx, c, myNonceValue, recallTransactions[int(currentNonce)%len(recallTransactions)])
+				case loadTestModeUniswapV3:
+					startReq, endReq, tErr = loadTestUniswapV3(ctx, c, myNonceValue, uniswapV3Config, poolConfig)
 				case loadTestModeRPC:
 					startReq, endReq, tErr = loadTestRPC(ctx, c, myNonceValue, indexedActivity)
 				default:
@@ -728,8 +795,8 @@ func blockUntilSuccessful(ctx context.Context, c *ethclient.Client, f func() err
 				blockDiff = currentBlockNumber % startBlockNumber
 			}
 			if blockDiff > numberOfBlocksToWaitFor {
-				log.Error().Err(err).Dur("elapsedTimeSeconds", elapsed).Msg("Exhausted waiting period")
-				return err
+				log.Error().Err(err).Dur("elapsedTimeSeconds", elapsed).Msg("waiting period exhausted")
+				return waitingPeriodExhaustedErr
 			}
 
 			currentBlockNumber, err = c.BlockNumber(ctx)