rpcfuzz

var RPCFuzzCmd = &cobra.Command{
	Use:   "rpcfuzz http://localhost:8545",
	Short: "Continually run a variety of RPC calls and fuzzers",
	Long: `

This command will run a series of RPC calls against a given json rpc
endpoint. The idea is to be able to check for various features and
function to see if the RPC generally conforms to typical geth
standards for the RPC

Some setup might be neede depending on how you're testing. We'll
demonstrate with geth. In order to quickly test this, you can run geth
in dev mode:

# ./build/bin/geth --dev --dev.period 5 --http --http.addr localhost \
    --http.port 8545 \
    --http.api 'admin,debug,web3,eth,txpool,personal,clique,miner,net' \
    --verbosity 5 --rpc.gascap 50000000  --rpc.txfeecap 0 \
    --miner.gaslimit  10 --miner.gasprice 1 --gpo.blocks 1 \
    --gpo.percentile 1 --gpo.maxprice 10 --gpo.ignoreprice 2 \
    --dev.gaslimit 50000000

Once your Eth client is running and the RPC is functional, you'll need
to transfer some amount of ether to a known account that ca be used
for testing

# cast send --from "$(cast rpc --rpc-url localhost:8545 eth_coinbase | jq -r '.')" \
    --rpc-url localhost:8545 --unlocked --value 100ether \
    0x85dA99c8a7C2C95964c8EfD687E95E632Fc533D6

Then we might want to deploy some test smart contracts. For the
purposes of testing we'll our ERC20 contract:

# cast send --from 0x85dA99c8a7C2C95964c8EfD687E95E632Fc533D6 \
    --private-key 0x42b6e34dc21598a807dc19d7784c71b2a7a01f6480dc6f58258f78e539f1a1fa \
    --rpc-url localhost:8545 --create \
    "$(cat ./contracts/ERC20.bin)"

Once this has been completed this will be the address of the contract:
0x6fda56c57b0acadb96ed5624ac500c0429d59429

# docker run -v $PWD/contracts:/contracts ethereum/solc:stable --storage-layout /contracts/ERC20.sol

- https://ethereum.github.io/execution-apis/api-documentation/
- https://ethereum.org/en/developers/docs/apis/json-rpc/
- https://json-schema.org/
- https://www.liquid-technologies.com/online-json-to-schema-converter

`,
	RunE: func(cmd *cobra.Command, args []string) error {
		ctx := cmd.Context()
		rpcClient, err := rpc.DialContext(ctx, args[0])
		if err != nil {
			return err
		}
		log.Trace().Msg("Doing test setup")
		setupTests(ctx, rpcClient)
		nonce, err := GetTestAccountNonce(ctx, rpcClient)
		if err != nil {
			return err
		}
		chainId, err := GetCurrentChainID(ctx, rpcClient)
		if err != nil {
			return err
		}
		testAccountNonce = nonce
		currentChainID = chainId

		for _, t := range allTests {
			if !shouldRunTest(t) {
				log.Trace().Str("name", t.GetName()).Str("method", t.GetMethod()).Msg("Skipping test")
				continue
			}
			log.Trace().Str("name", t.GetName()).Str("method", t.GetMethod()).Msg("Running Test")
			var result interface{}
			err = rpcClient.CallContext(ctx, &result, t.GetMethod(), t.GetArgs()...)
			if err != nil && !t.ExpectError() {
				log.Error().Err(err).Str("method", t.GetMethod()).Msg("Method test failed")
				continue
			}

			if t.ExpectError() {
				err = t.Validate(err)
			} else {
				err = t.Validate(result)
			}

			if err != nil {
				log.Error().Err(err).Str("method", t.GetMethod()).Msg("Failed to validate")
				continue
			}
			log.Info().Str("method", t.GetMethod()).Msg("Successfully validated")
		}
		return nil
	},
	Args: func(cmd *cobra.Command, args []string) error {
		if len(args) != 1 {
			return fmt.Errorf("Expected 1 argument, but got %d", len(args))
		}

		privateKey, err := ethcrypto.HexToECDSA(*testPrivateHexKey)
		if err != nil {
			log.Error().Err(err).Msg("Couldn't process the hex private key")
			return err
		}

		ethAddress := ethcrypto.PubkeyToAddress(privateKey.PublicKey)
		log.Info().Str("ethAddress", ethAddress.String()).Msg("Loaded private key")

		nsValidator := regexp.MustCompile("^[a-z0-9]*$")
		rawNameSpaces := strings.Split(*testNamespaces, ",")
		enabledNamespaces = make([]string, 0)
		for _, ns := range rawNameSpaces {
			if !nsValidator.MatchString(ns) {
				return fmt.Errorf("The namespace %s is not valid", ns)
			}
			enabledNamespaces = append(enabledNamespaces, ns+"_")
		}
		log.Info().Strs("namespaces", enabledNamespaces).Msg("enabling namespaces")

		testPrivateKey = privateKey
		testEthAddress = ethAddress

		return nil
	},
}