Merge pull request base#2 from base/send-txn-sync

feat: add benchmarking setup for sending raw transactions synchronously

Author: danyalprout

.env.example

@@ -1,5 +1,6 @@
 PRIVATE_KEY=todo
 TO_ADDRESS=0x7d5A90C2cd5567B9966E92c710b5E9936F400d74
+POLLING_INTERVAL_MS=100
 FLASHBLOCKS_URL=https://sepolia-preconf.base.org
 BASE_URL=https://sepolia.base.org
 REGION=texas

.gitignore

@@ -1,3 +1,4 @@
 .env
 .idea/
 *.csv
+data/

main.go

@@ -4,6 +4,7 @@ import (
 "context"
 "crypto/ecdsa"
 "encoding/csv"
+"encoding/hex"
 "fmt"
 "log"
 "math/big"
@@ -62,6 +63,25 @@ func main() {
 log.Fatal("BASE_URL environment variable not set")
 }
 
+sendTxnSync := os.Getenv("SEND_TXN_SYNC") == "true"
+runStandardTransactionSending := os.Getenv("RUN_STANDARD_TRANSACTION_SENDING") != "false"
+
+pollingIntervalMs := 100
+if pollingEnv := os.Getenv("POLLING_INTERVAL_MS"); pollingEnv != "" {
+if parsed, err := strconv.Atoi(pollingEnv); err == nil {
+pollingIntervalMs = parsed
+}
+}
+
+log.Println("Polling interval ms", pollingIntervalMs)
+
+numberOfTransactions := 100
+if txnCountEnv := os.Getenv("NUMBER_OF_TRANSACTIONS"); txnCountEnv != "" {
+if parsed, err := strconv.Atoi(txnCountEnv); err == nil {
+numberOfTransactions = parsed
+}
+}
+
 flashblocksClient, err := ethclient.Dial(flashblocksUrl)
 if err != nil {
 log.Fatalf("Failed to connect to the Ethereum client: %v", err)
@@ -92,50 +112,60 @@ func main() {
 log.Fatalf("Failed to get network ID: %v", err)
 }
 
-iterations := 100
 flashblockErrors := 0
 baseErrors := 0
 
-log.Printf("Starting flashblock transactions")
-for i := 0; i < iterations; i++ {
-timing, err := timeTransaction(chainId, privateKey, fromAddress, toAddress, flashblocksClient)
+log.Printf("Starting flashblock transactions, syncMode=%v", sendTxnSync)
+for i := 0; i < numberOfTransactions; i++ {
+timing, err := timeTransaction(chainId, privateKey, fromAddress, toAddress, flashblocksClient, sendTxnSync, pollingIntervalMs)
 if err != nil {
 flashblockErrors += 1
 log.Printf("Failed to send transaction: %v", err)
 }
 
 flashblockTimings = append(flashblockTimings, timing)
 
-// wait for it to be mined -- sleep a random amount between 600ms and 1s
-time.Sleep(time.Duration(rand.Int63n(600)+600) * time.Millisecond)
+if !sendTxnSync {
+// wait for it to be mined -- sleep a random amount between 600ms and 1s
+time.Sleep(time.Duration(rand.Int63n(600)+600) * time.Millisecond)
+} else {
+time.Sleep(time.Duration(rand.Int63n(200)+100) * time.Millisecond)
+}
 }
 
 // wait for the final fb transaction to land
 time.Sleep(5 * time.Second)
 
-log.Printf("Starting regular transactions")
-for i := 0; i < iterations; i++ {
-timing, err := timeTransaction(chainId, privateKey, fromAddress, toAddress, baseClient)
-if err != nil {
-baseErrors += 1
-log.Printf("Failed to send transaction: %v", err)
-}
+if runStandardTransactionSending {
+log.Printf("Starting regular transactions")
+for i := 0; i < numberOfTransactions; i++ {
+// Currently not supported on non-flashblock endpoints
+timing, err := timeTransaction(chainId, privateKey, fromAddress, toAddress, baseClient, false, pollingIntervalMs)
+if err != nil {
+baseErrors += 1
+log.Printf("Failed to send transaction: %v", err)
+}
 
-baseTimings = append(baseTimings, timing)
+baseTimings = append(baseTimings, timing)
 
-// wait for it to be mined -- sleep a random amount between 4s and 3s
-time.Sleep(time.Duration(rand.Int63n(1000)+4000) * time.Millisecond)
+// wait for it to be mined -- sleep a random amount between 4s and 3s
+time.Sleep(time.Duration(rand.Int63n(1000)+4000) * time.Millisecond)
+}
+} else {
+log.Printf("Skipping regular transactions (RUN_STANDARD_TRANSACTION_SENDING=false)")
 }
 
-if err := writeToFile(fmt.Sprintf("/data/flashblocks-%s.csv", region), flashblockTimings); err != nil {
+if err := writeToFile(fmt.Sprintf("./data/flashblocks-%s.csv", region), flashblockTimings); err != nil {
 log.Fatalf("Failed to write to file: %v", err)
 }
 
-if err := writeToFile(fmt.Sprintf("/data/base-%s.csv", region), baseTimings); err != nil {
-log.Fatalf("Failed to write to file: %v", err)
+if runStandardTransactionSending {
+if err := writeToFile(fmt.Sprintf("./data/base-%s.csv", region), baseTimings); err != nil {
+log.Fatalf("Failed to write to file: %v", err)
+}
 }
 
-log.Printf("Completed test iteration count", iterations)
+log.Printf("Completed test with %d transactions", numberOfTransactions)
 log.Printf("Flashblock errors: %v", flashblockErrors)
 log.Printf("BaseErrors: %v", baseErrors)
 }
@@ -170,7 +200,7 @@ func writeToFile(filename string, data []stats) error {
 return nil
 }
 
-func timeTransaction(chainId *big.Int, privateKey *ecdsa.PrivateKey, fromAddress common.Address, toAddress common.Address, client *ethclient.Client) (stats, error) {
+func timeTransaction(chainId *big.Int, privateKey *ecdsa.PrivateKey, fromAddress common.Address, toAddress common.Address, client *ethclient.Client, useSyncRPC bool, pollingIntervalMs int) (stats, error) {
 nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
 if err != nil {
 return stats{}, fmt.Errorf("unable to get nonce: %v", err)
@@ -204,24 +234,57 @@ func timeTransaction(chainId *big.Int, privateKey *ecdsa.PrivateKey, fromAddress
 return stats{}, fmt.Errorf("unable to sign transaction: %v", err)
 }
 
+if useSyncRPC {
+return sendTransactionSync(client, signedTx)
+}
+
+return sendTransactionAsync(client, signedTx, pollingIntervalMs)
+}
+
+func sendTransactionSync(client *ethclient.Client, signedTx *types.Transaction) (stats, error) {
+rawTx, err := signedTx.MarshalBinary()
+if err != nil {
+return stats{}, fmt.Errorf("unable to marshal transaction: %v", err)
+}
+
+txnData := "0x" + hex.EncodeToString(rawTx)
+
+sentAt := time.Now()
+var receipt *types.Receipt
+err = client.Client().CallContext(context.Background(), &receipt, "eth_sendRawTransactionSync", txnData)
+if err != nil {
+return stats{}, fmt.Errorf("unable to send sync transaction: %v", err)
+}
+
+log.Println("Transaction sent sync: ", signedTx.Hash().Hex())
+now := time.Now()
+return stats{
+SentAt: sentAt,
+InclusionDelay: now.Sub(sentAt),
+TxnHash: signedTx.Hash().Hex(),
+IncludedInBlock: receipt.BlockNumber.Uint64(),
+}, nil
+}
+
+func sendTransactionAsync(client *ethclient.Client, signedTx *types.Transaction, pollingIntervalMs int) (stats, error) {
 sentAt := time.Now()
-err = client.SendTransaction(context.Background(), signedTx)
+err := client.SendTransaction(context.Background(), signedTx)
 if err != nil {
 return stats{}, fmt.Errorf("unable to send transaction: %v", err)
 }
 
-log.Println("Transaction sent: ", signedTx.Hash().Hex())
+log.Println("Transaction sent async: ", signedTx.Hash().Hex())
 
 for i := 0; i < 1000; i++ {
 receipt, err := client.TransactionReceipt(context.Background(), signedTx.Hash())
 if err != nil {
-time.Sleep(10 * time.Millisecond)
+time.Sleep(time.Duration(pollingIntervalMs) * time.Millisecond)
 } else {
 now := time.Now()
 return stats{
 SentAt: sentAt,
 InclusionDelay: now.Sub(sentAt),
-TxnHash: tx.Hash().Hex(),
+TxnHash: signedTx.Hash().Hex(),
 IncludedInBlock: receipt.BlockNumber.Uint64(),
 }, nil
 }