Add TestMode.ContractCall

packages/celotool/src/cmds/geth/simulate_client.ts

@@ -1,6 +1,12 @@
 /* tslint:disable no-console */
-import { AccountType, generateAddress } from 'src/lib/generate_utils'
-import { getIndexForLoadTestThread, simulateClient, TestMode } from 'src/lib/geth'
+import BigNumber from 'bignumber.js'
+import { AccountType, generateAddress, generatePrivateKey } from 'src/lib/generate_utils'
+import {
+  MAX_LOADTEST_THREAD_COUNT,
+  TestMode,
+  getIndexForLoadTestThread,
+  simulateClient,
+} from 'src/lib/geth'
 import * as yargs from 'yargs'
 export const command = 'simulate-client'
 
@@ -13,8 +19,12 @@ interface SimulateClientArgv extends yargs.Argv {
   index: number
   mnemonic: string
   recipientIndex: number
+  contractAddress: string
+  contractData: string
   clientCount: number
   reuseClient: boolean
+  maxGasPrice: number
+  totalTxGas: number
   testMode: string
 }
 
@@ -47,25 +57,47 @@ export const builder = () => {
         'Index of the load test account to send transactions to. Used to generate account address',
       default: 0,
     })
+    .options('contract-address', {
+      type: 'string',
+      description: `Contract Address to send to when using test mode: ${TestMode.ContractCall}`,
+      default: '',
+    })
+    .options('contract-data', {
+      type: 'string',
+      description: `Data to send to when using test mode: ${TestMode.ContractCall}`,
+      default: '',
+    })
     .options('mnemonic', {
       type: 'string',
       description: 'Mnemonic used to generate account addresses',
       demand: 'A mnemonic must be provided',
     })
     .options('client-count', {
       type: 'number',
-      description: 'Number of clients to simulate',
+      description: `Number of clients to simulate, must not exceed ${MAX_LOADTEST_THREAD_COUNT}`,
       default: 1,
     })
+    .check((argv) => argv['client-count'] <= MAX_LOADTEST_THREAD_COUNT)
     .options('reuse-client', {
       type: 'boolean',
       description: 'Use the same client for all the threads/accounts',
       default: false,
     })
+    .options('max-gas-price', {
+      type: 'number',
+      description: 'Max gasPrice to use for transactions',
+      default: 0,
+    })
+    .options('total-tx-gas', {
+      type: 'number',
+      description: 'Gas Target when using data transfers',
+      default: 500000,
+    })
     .options('test-mode', {
       type: 'string',
-      description: 'Load test mode: mixed transaction types, big calldatas, or simple transfers',
-      choices: [TestMode.Mixed, TestMode.Data, TestMode.Transfer],
+      description:
+        'Load test mode: mixed transaction types, big calldatas, simple transfers, or contract calls',
+      choices: [TestMode.Mixed, TestMode.Data, TestMode.Transfer, TestMode.ContractCall],
       default: TestMode.Mixed,
     })
 }
@@ -74,7 +106,7 @@ export const handler = async (argv: SimulateClientArgv) => {
   for (let thread = 0; thread < argv.clientCount; thread++) {
     const senderIndex = getIndexForLoadTestThread(argv.index, thread)
     const recipientIndex = getIndexForLoadTestThread(argv.recipientIndex, thread)
-    const senderAddress = generateAddress(
+    const senderPK = generatePrivateKey(
       argv.mnemonic,
       AccountType.LOAD_TESTING_ACCOUNT,
       senderIndex
@@ -88,23 +120,26 @@ export const handler = async (argv: SimulateClientArgv) => {
     const web3ProviderPort = argv.reuseClient ? 8545 : 8545 + thread
 
     console.log(
-      `Account for sender index ${argv.index} thread ${thread}, final index ${senderIndex}: ${senderAddress}`
+      `PK for sender index ${argv.index} thread ${thread}, final index ${senderIndex}: ${senderPK}`
     )
     console.log(
       `Account for recipient index ${argv.recipientIndex} thread ${thread}, final index ${recipientIndex}: ${recipientAddress}`
     )
     console.log(`web3ProviderPort for thread ${thread}: ${web3ProviderPort}`)
-
     // tslint:disable-next-line: no-floating-promises
     simulateClient(
-      senderAddress,
+      senderPK,
       recipientAddress,
+      argv.contractAddress,
+      argv.contractData,
       argv.delay,
       argv.blockscoutUrl,
       argv.blockscoutMeasurePercent,
       argv.index,
       argv.testMode as TestMode,
       thread,
+      new BigNumber(argv.maxGasPrice),
+      argv.totalTxGas,
       `http://localhost:${web3ProviderPort}`
     )
   }

packages/celotool/src/lib/geth.ts

@@ -19,11 +19,12 @@ import { convertToContractDecimals } from './contract-utils'
 import { envVar, fetchEnv, isVmBased } from './env-utils'
 import {
   AccountType,
+  Validator,
   generateGenesis,
   generateGenesisWithMigrations,
   generatePrivateKey,
+  privateKeyToAddress,
   privateKeyToPublicKey,
-  Validator,
 } from './generate_utils'
 import { retrieveClusterIPAddress, retrieveIPAddress } from './helm_deploy'
 import { GethInstanceConfig } from './interfaces/geth-instance-config'
@@ -78,6 +79,7 @@ export const LOG_TAG_TRANSACTION_VALIDATION_ERROR = 'validate_transaction_error'
 // for log messages which show time needed to receive the receipt after
 // the transaction has been sent
 export const LOG_TAG_TX_TIME_MEASUREMENT = 'tx_time_measurement'
+export const MAX_LOADTEST_THREAD_COUNT = 100
 
 export const getEnodeAddress = (nodeId: string, ipAddress: string, port: number) => {
   return `enode://${nodeId}@${ipAddress}:${port}`
@@ -548,28 +550,31 @@ export enum TestMode {
   Mixed = 'mixed',
   Data = 'data',
   Transfer = 'transfer',
+  ContractCall = 'contract-call',
 }
 
 export const simulateClient = async (
-  senderAddress: string,
+  senderPK: string,
   recipientAddress: string,
+  contractAddress: string,
+  contractData: string,
   txPeriodMs: number, // time between new transactions in ms
   blockscoutUrl: string,
   blockscoutMeasurePercent: number, // percent of time in range [0, 100] to measure blockscout for a tx
   index: number,
   testMode: TestMode,
   thread: number,
+  maxGasPrice: BigNumber = new BigNumber(0),
+  totalTxGas: number = 500000, // aim for half million gas txs
   web3Provider: string = 'http://localhost:8545'
 ) => {
   // Assume the node is accessible via localhost with senderAddress unlocked
   const kit = newKitFromWeb3(new Web3(web3Provider))
-  const password = fetchEnv('PASSWORD')
 
   let lastNonce: number = -1
   let lastTx: string = ''
   let lastGasPriceMinimum: BigNumber = new BigNumber(0)
   let nonce: number = 0
-  let unlockNeeded: boolean = true
   let recipientAddressFinal: string = recipientAddress
   const useRandomRecipient = fetchEnv(envVar.LOAD_TEST_USE_RANDOM_RECIPIENT)
 
@@ -580,7 +585,8 @@ export const simulateClient = async (
     )
     await sleep(sleepTime)
   }
-  kit.defaultAccount = senderAddress
+  kit.addAccount(senderPK)
+  kit.defaultAccount = privateKeyToAddress(senderPK)
 
   // sleep a random amount of time in the range [0, txPeriodMs) before starting so
   // that if multiple simulations are started at the same time, they don't all
@@ -589,21 +595,34 @@ export const simulateClient = async (
   console.info(`Sleeping for ${randomSleep} ms`)
   await sleep(randomSleep)
 
+  const intrinsicGas = 21000
+  // const totalTxGas = 500000 // aim for half million gas txs
+  const calldataGas = totalTxGas - intrinsicGas
+  const calldataSize = calldataGas / 4 // 119750 < tx pool size limit (128k)
+  let dataStr = testMode === TestMode.Data ? getBigData(calldataSize) : undefined // aim for half million gas txs
+  // Also running below the 128kb limit from the tx pool
+  let transferAmount = LOAD_TEST_TRANSFER_WEI
+
+  if (testMode === TestMode.ContractCall) {
+    if (!contractData || !contractAddress) {
+      throw new Error('Contract address and data must be provided for TestMode.ContractCall')
+    }
+    dataStr = contractData
+    recipientAddressFinal = contractAddress
+    transferAmount = new BigNumber(0)
+  }
+
   const baseLogMessage: any = {
     loadTestID: index,
     threadID: thread,
-    sender: senderAddress,
+    sender: kit.defaultAccount,
     recipient: recipientAddressFinal,
     feeCurrency: '',
     txHash: '',
   }
 
   while (true) {
     const sendTransactionTime = Date.now()
-    if (unlockNeeded) {
-      await unlock(kit, kit.defaultAccount, password, 9223372036)
-      unlockNeeded = false
-    }
     const txConf = await getTxConf(testMode)
     baseLogMessage.tokenName = txConf.tokenName
 
@@ -631,6 +650,9 @@ export const simulateClient = async (
       )
       nonce = nonceResult.nonce
       gasPrice = nonceResult.newPrice
+      if (maxGasPrice.isGreaterThan(0)) {
+        gasPrice = BigNumber.min(gasPrice, maxGasPrice)
+      }
       lastGasPriceMinimum = gasPrice
       txOptions = {
         gasPrice: gasPrice.toString(),
@@ -644,19 +666,21 @@ export const simulateClient = async (
         ...baseLogMessage,
       })
     }
-    const intrinsicGas = 21000
-    const totalTxGas = 500000 // aim for half million gas txs
-    const calldataGas = totalTxGas - intrinsicGas
-    const calldataSize = calldataGas / 4 // 119750 < tx pool size limit (128k)
-    const dataStr = testMode === TestMode.Data ? getBigData(calldataSize) : undefined // aim for half million gas txs
-    // Also running below the 128kb limit from the tx pool
+
+    if (testMode === TestMode.ContractCall) {
+      if (!contractData || !contractAddress) {
+        throw new Error('Contract address and data must be provided for TestMode.ContractCall')
+      }
+      dataStr = contractData
+      recipientAddressFinal = contractAddress
+    }
 
     await txConf
       .transferFn(
         kit,
-        senderAddress,
+        kit.defaultAccount,
         recipientAddressFinal,
-        LOAD_TEST_TRANSFER_WEI,
+        transferAmount,
         dataStr,
         txOptions
       )
@@ -665,7 +689,7 @@ export const simulateClient = async (
         lastNonce = (await kit.web3.eth.getTransaction(lastTx)).nonce
         await onLoadTestTxResult(
           kit,
-          senderAddress,
+          kit.defaultAccount!,
           txResult,
           sendTransactionTime,
           baseLogMessage,
@@ -674,9 +698,12 @@ export const simulateClient = async (
         )
       })
       .catch((error: any) => {
-        if (catchNeedUnlock(error, baseLogMessage)) {
-          unlockNeeded = true
-        }
+        console.error('Load test transaction failed with error:', error)
+        tracerLog({
+          tag: LOG_TAG_TRANSACTION_ERROR,
+          error: error.toString(),
+          ...baseLogMessage,
+        })
       })
     if (sendTransactionTime + txPeriodMs > Date.now()) {
       await sleep(sendTransactionTime + txPeriodMs - Date.now())
@@ -689,32 +716,40 @@ const getBigData = (size: number) => {
 }
 
 const getTxConf = async (testMode: TestMode) => {
-  if (testMode === TestMode.Data) {
-    return {
-      feeCurrencyGold: true,
-      tokenName: 'cGLD.L',
-      transferFn: transferCalldata,
-    }
-  }
-  if (testMode === TestMode.Transfer) {
-    return {
-      feeCurrencyGold: true,
-      tokenName: 'cGLD',
-      transferFn: transferCeloGold,
-    }
-  }
-
-  // randomly choose which token to use
-  const useGold = Boolean(Math.round(Math.random()))
-  const _transferFn = useGold ? transferCeloGold : transferCeloDollars
-  const _tokenName = useGold ? 'cGLD' : 'cUSD'
-
-  // randomly choose which gas currency to use
-  const _feeCurrencyGold = Boolean(Math.round(Math.random()))
-  return {
-    feeCurrencyGold: _feeCurrencyGold,
-    tokenName: _tokenName,
-    transferFn: _transferFn,
+  switch (testMode) {
+    case TestMode.Data:
+      return {
+        feeCurrencyGold: true,
+        tokenName: 'cGLD.L',
+        transferFn: transferCalldata,
+      }
+    case TestMode.Transfer:
+      return {
+        feeCurrencyGold: true,
+        tokenName: 'cGLD',
+        transferFn: transferCeloGold,
+      }
+    case TestMode.Mixed:
+      // randomly choose which token to use
+      const useGold = Boolean(Math.round(Math.random()))
+      const _transferFn = useGold ? transferCeloGold : transferCeloDollars
+      const _tokenName = useGold ? 'cGLD' : 'cUSD'
+
+      // randomly choose which gas currency to use
+      const _feeCurrencyGold = Boolean(Math.round(Math.random()))
+      return {
+        feeCurrencyGold: _feeCurrencyGold,
+        tokenName: _tokenName,
+        transferFn: _transferFn,
+      }
+    case TestMode.ContractCall:
+      return {
+        feeCurrencyGold: true,
+        tokenName: 'contract', // For logging
+        transferFn: transferCalldata,
+      }
+    default:
+      throw new Error(`Unimplemented TestMode: ${testMode}`)
   }
 }
 
@@ -745,27 +780,6 @@ const getNonce = async (
   }
 }
 
-// Catch errors from the transfer Fn, and returns if an account unlock
-// is needed.
-const catchNeedUnlock = (error: any, baseLogMessage: any) => {
-  let unlockNeeded = false
-  if (
-    typeof error === 'string' &&
-    error.includes('Error: authentication needed: password or unlock')
-  ) {
-    console.warn('Load test transaction failed with locked account:', error)
-    unlockNeeded = true
-  } else {
-    console.error('Load test transaction failed with error:', error)
-    tracerLog({
-      tag: LOG_TAG_TRANSACTION_ERROR,
-      error: error.toString(),
-      ...baseLogMessage,
-    })
-  }
-  return unlockNeeded
-}
-
 const getFeeCurrency = async (kit: ContractKit, feeCurrencyGold: boolean, baseLogMessage: any) => {
   try {
     return feeCurrencyGold ? '' : await kit.registry.addressFor(CeloContract.StableToken)
@@ -845,9 +859,11 @@ export const onLoadTestTxResult = async (
  * @param thread the thread number inside the pod
  */
 export function getIndexForLoadTestThread(pod: number, thread: number) {
-  // max number of threads to avoid overlap is [0, base)
-  const base = 10000
-  return pod * base + thread
+  if (thread > MAX_LOADTEST_THREAD_COUNT) {
+    throw new Error(`thread count must be smaller than ${MAX_LOADTEST_THREAD_COUNT}`)
+  }
+  // max number of threads to avoid overlap is [0, MAX_LOADTEST_THREAD_COUNT)
+  return pod * MAX_LOADTEST_THREAD_COUNT + thread
 }
 
 /**