Merge pull request #6 from base/work-with-ingress

feat: support eth_sendBundle

Author: wlawt

.env.example

@@ -4,3 +4,6 @@ POLLING_INTERVAL_MS=100
 FLASHBLOCKS_URL=https://sepolia-preconf.base.org
 BASE_URL=https://sepolia.base.org
 REGION=texas
+NUMBER_OF_TRANSACTIONS=100
+RUN_BUNDLE_TEST=true
+BUNDLE_SIZE=3

main.go

@@ -27,6 +27,18 @@ type stats struct {
 	InclusionDelay  time.Duration
 }
 
+type Bundle struct {
+	Txs                 [][]byte      `json:"txs"`                           // Raw transaction bytes
+	BlockNumber         uint64        `json:"blockNumber"`                   // Target block number
+	FlashblockNumberMin *uint64       `json:"flashblockNumberMin,omitempty"` // Optional: minimum flashblock number
+	FlashblockNumberMax *uint64       `json:"flashblockNumberMax,omitempty"` // Optional: maximum flashblock number
+	MinTimestamp        *uint64       `json:"minTimestamp,omitempty"`        // Optional: minimum timestamp
+	MaxTimestamp        *uint64       `json:"maxTimestamp,omitempty"`        // Optional: maximum timestamp
+	RevertingTxHashes   []common.Hash `json:"revertingTxHashes"`             // Transaction hashes that can revert
+	ReplacementUuid     *string       `json:"replacementUuid,omitempty"`     // Optional: replacement UUID
+	DroppingTxHashes    []common.Hash `json:"droppingTxHashes"`              // Transaction hashes to drop
+}
+
 func main() {
 	err := godotenv.Load()
 	if err != nil {
@@ -65,6 +77,7 @@ func main() {
 
 	sendTxnSync := os.Getenv("SEND_TXN_SYNC") == "true"
 	runStandardTransactionSending := os.Getenv("RUN_STANDARD_TRANSACTION_SENDING") != "false"
+	runBundleTest := os.Getenv("RUN_BUNDLE_TEST") == "true"
 
 	pollingIntervalMs := 100
 	if pollingEnv := os.Getenv("POLLING_INTERVAL_MS"); pollingEnv != "" {
@@ -82,6 +95,13 @@ func main() {
 		}
 	}
 
+	bundleSize := 3
+	if bundleSizeEnv := os.Getenv("BUNDLE_SIZE"); bundleSizeEnv != "" {
+		if parsed, err := strconv.Atoi(bundleSizeEnv); err == nil {
+			bundleSize = parsed
+		}
+	}
+
 	flashblocksClient, err := ethclient.Dial(flashblocksUrl)
 	if err != nil {
 		log.Fatalf("Failed to connect to the Ethereum client: %v", err)
@@ -108,10 +128,22 @@ func main() {
 	var baseTimings []stats
 
 	chainId, err := baseClient.NetworkID(context.Background())
+	log.Printf("Chain ID: %v", chainId)
 	if err != nil {
 		log.Fatalf("Failed to get network ID: %v", err)
 	}
 
+	// Bundle testing
+	if runBundleTest {
+		log.Printf("Starting bundle test with %d transactions per bundle", bundleSize)
+		err = createAndSendBundle(chainId, privateKey, fromAddress, toAddress, flashblocksClient, bundleSize)
+		if err != nil {
+			log.Printf("Failed to send bundle: %v", err)
+		} else {
+			log.Printf("Bundle test completed successfully")
+		}
+	}
+
 	flashblockErrors := 0
 	baseErrors := 0
 
@@ -200,22 +232,17 @@ 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, 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)
-	}
-
+func createTx(chainId *big.Int, privateKey *ecdsa.PrivateKey, toAddress common.Address, client *ethclient.Client, nonce uint64) (*types.Transaction, error) {
 	gasPrice, err := client.SuggestGasPrice(context.Background())
 	if err != nil {
-		return stats{}, fmt.Errorf("unable to get gas price: %v", err)
+		return nil, fmt.Errorf("unable to get gas price: %v", err)
 	}
 	gasLimit := uint64(21000)
 	value := big.NewInt(100)
 
 	tip, err := client.SuggestGasTipCap(context.Background())
 	if err != nil {
-		return stats{}, fmt.Errorf("unable to get gas price: %v", err)
+		return nil, fmt.Errorf("unable to get gas tip cap: %v", err)
 	}
 
 	tx := types.NewTx(&types.DynamicFeeTx{
@@ -231,7 +258,22 @@ func timeTransaction(chainId *big.Int, privateKey *ecdsa.PrivateKey, fromAddress
 
 	signedTx, err := types.SignTx(tx, types.NewPragueSigner(chainId), privateKey)
 	if err != nil {
-		return stats{}, fmt.Errorf("unable to sign transaction: %v", err)
+		return nil, fmt.Errorf("unable to sign transaction: %v", err)
+	}
+
+	return signedTx, nil
+}
+
+func timeTransaction(chainId *big.Int, privateKey *ecdsa.PrivateKey, fromAddress common.Address, toAddress common.Address, client *ethclient.Client, useSyncRPC bool, pollingIntervalMs int) (stats, error) {
+	// Use pending nonce to avoid conflicts with pending transactions
+	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
+	if err != nil {
+		return stats{}, fmt.Errorf("unable to get nonce: %v", err)
+	}
+
+	signedTx, err := createTx(chainId, privateKey, toAddress, client, nonce)
+	if err != nil {
+		return stats{}, fmt.Errorf("unable to create transaction: %v", err)
 	}
 
 	if useSyncRPC {
@@ -296,3 +338,74 @@ func sendTransactionAsync(client *ethclient.Client, signedTx *types.Transaction,
 
 	return stats{}, fmt.Errorf("failed to get transaction")
 }
+
+func sendBundle(client *ethclient.Client, signedTxs []*types.Transaction, targetBlockNumber uint64) (string, error) {
+	// Convert transactions to raw transaction bytes and collect hashes
+	var txsBytes [][]byte
+	var txHashes []common.Hash
+	for _, tx := range signedTxs {
+		rawTx, err := tx.MarshalBinary()
+		if err != nil {
+			return "", fmt.Errorf("unable to marshal transaction: %v", err)
+		}
+		txsBytes = append(txsBytes, rawTx)
+		txHashes = append(txHashes, tx.Hash())
+	}
+
+	// Create bundle structure matching Base TIPS format
+	bundle := Bundle{
+		Txs:               txsBytes,
+		BlockNumber:       targetBlockNumber,
+		RevertingTxHashes: txHashes,        // All transaction hashes must be in reverting_tx_hashes
+		DroppingTxHashes:  []common.Hash{}, // Empty array if no dropping txs
+	}
+
+	// Send bundle via RPC call
+	var bundleHash string
+	err := client.Client().CallContext(context.Background(), &bundleHash, "eth_sendBundle", bundle)
+	if err != nil {
+		return "", fmt.Errorf("unable to send bundle: %v", err)
+	}
+
+	log.Printf("Bundle sent successfully with hash: %s", bundleHash)
+	return bundleHash, nil
+}
+
+func createAndSendBundle(chainId *big.Int, privateKey *ecdsa.PrivateKey, fromAddress common.Address, toAddress common.Address, client *ethclient.Client, numTxs int) error {
+	// Get current block number for targeting
+	currentBlock, err := client.BlockNumber(context.Background())
+	if err != nil {
+		return fmt.Errorf("unable to get current block number: %v", err)
+	}
+
+	// Target the next block
+	targetBlock := currentBlock + 1
+
+	// Get base nonce
+	baseNonce, err := client.PendingNonceAt(context.Background(), fromAddress)
+	if err != nil {
+		return fmt.Errorf("unable to get nonce: %v", err)
+	}
+
+	// Create multiple signed transactions for the bundle
+	var signedTxs []*types.Transaction
+	for i := 0; i < numTxs; i++ {
+		nonce := baseNonce + uint64(i) // Sequential nonces
+		signedTx, err := createTx(chainId, privateKey, toAddress, client, nonce)
+		if err != nil {
+			return fmt.Errorf("unable to create transaction %d: %v", i, err)
+		}
+
+		signedTxs = append(signedTxs, signedTx)
+		log.Printf("Created transaction %d with nonce %d, hash: %s", i, nonce, signedTx.Hash().Hex())
+	}
+
+	// Send the bundle
+	bundleHash, err := sendBundle(client, signedTxs, targetBlock)
+	if err != nil {
+		return fmt.Errorf("failed to send bundle: %v", err)
+	}
+
+	log.Printf("Bundle sent with hash: %s, targeting block: %d", bundleHash, targetBlock)
+	return nil
+}