Merge pull request metachris#4 from metachris/privTx

sendPrivateTransaction + cancelPrivateTransaction

Author: metachris

README.md

@@ -5,6 +5,8 @@ Fork of [ethrpc](https://github.com/onrik/ethrpc) with additional [Flashbots RPC
 * `FlashbotsCallBundle` ([`eth_callBundle`](https://docs.flashbots.net/flashbots-auction/searchers/advanced/rpc-endpoint/#eth_callbundle))
 * `FlashbotsSendBundle` ([`eth_sendBundle`](https://docs.flashbots.net/flashbots-auction/searchers/advanced/rpc-endpoint/#eth_sendbundle))
 * `FlashbotsGetUserStats` ([`flashbots_getUserStats`](https://docs.flashbots.net/flashbots-auction/searchers/advanced/rpc-endpoint/#flashbots_getuserstats))
+* `FlashbotsSendPrivateTransaction` (`eth_sendPrivateTransaction`)
+* `FlashbotsCancelPrivateTransaction` (`eth_cancelPrivateTransaction`)
 * `FlashbotsSimulateBlock`: simulate a full block
 
 ## Usage

examples/cancelPrivateTransaction/main.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/metachris/flashbotsrpc"
+)
+
+var privateKey, _ = crypto.GenerateKey() // creating a new private key for testing. you probably want to use an existing key.
+// var privateKey, _ = crypto.HexToECDSA("YOUR_PRIVATE_KEY")
+
+func main() {
+	rpc := flashbotsrpc.New("https://relay.flashbots.net")
+	rpc.Debug = true
+
+	cancelPrivTxArgs := flashbotsrpc.FlashbotsCancelPrivateTransactionRequest{
+		TxHash: "0xYOUR_TX_HASH",
+	}
+
+	cancelled, err := rpc.FlashbotsCancelPrivateTransaction(privateKey, cancelPrivTxArgs)
+	if err != nil {
+		if errors.Is(err, flashbotsrpc.ErrRelayErrorResponse) {
+			// ErrRelayErrorResponse means it's a standard Flashbots relay error response, so probably a user error, rather than JSON or network error
+			fmt.Println(err.Error())
+		} else {
+			fmt.Printf("error: %+v\n", err)
+		}
+		return
+	}
+
+	// Print result
+	fmt.Printf("was cancelled: %v\n", cancelled)
+}

examples/sendPrivateTransaction/main.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/metachris/flashbotsrpc"
+)
+
+var privateKey, _ = crypto.GenerateKey() // creating a new private key for testing. you probably want to use an existing key.
+// var privateKey, _ = crypto.HexToECDSA("YOUR_PRIVATE_KEY")
+
+func main() {
+	rpc := flashbotsrpc.New("https://relay.flashbots.net")
+	rpc.Debug = true
+
+	sendPrivTxArgs := flashbotsrpc.FlashbotsSendPrivateTransactionRequest{
+		Tx: "0xYOUR_RAW_TX",
+	}
+
+	txHash, err := rpc.FlashbotsSendPrivateTransaction(privateKey, sendPrivTxArgs)
+	if err != nil {
+		if errors.Is(err, flashbotsrpc.ErrRelayErrorResponse) {
+			// ErrRelayErrorResponse means it's a standard Flashbots relay error response, so probably a user error, rather than JSON or network error
+			fmt.Println(err.Error())
+		} else {
+			fmt.Printf("error: %+v\n", err)
+		}
+		return
+	}
+
+	// Print txHash
+	fmt.Printf("txHash: %s\n", txHash)
+}

examples/sendbundle/main.go

@@ -1,13 +1,15 @@
 package main
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/metachris/flashbotsrpc"
 )
 
 var privateKey, _ = crypto.GenerateKey() // creating a new private key for testing. you probably want to use an existing key.
+// var privateKey, _ = crypto.HexToECDSA("YOUR_PRIVATE_KEY")
 
 func main() {
 	rpc := flashbotsrpc.New("https://relay.flashbots.net")
@@ -20,7 +22,12 @@ func main() {
 
 	result, err := rpc.FlashbotsSendBundle(privateKey, sendBundleArgs)
 	if err != nil {
-		fmt.Printf("%+v\n", err)
+		if errors.Is(err, flashbotsrpc.ErrRelayErrorResponse) {
+			// ErrRelayErrorResponse means it's a standard Flashbots relay error response, so probably a user error, rather than JSON or network error
+			fmt.Println(err.Error())
+		} else {
+			fmt.Printf("error: %+v\n", err)
+		}
 		return
 	}
 

examples/userstats/main.go

@@ -1,21 +1,29 @@
 package main
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/metachris/flashbotsrpc"
 )
 
 var privateKey, _ = crypto.GenerateKey() // creating a new private key for testing. you probably want to use an existing key.
+// var privateKey, _ = crypto.HexToECDSA("YOUR_PRIVATE_KEY")
 
 func main() {
 	rpc := flashbotsrpc.New("https://relay.flashbots.net")
 
 	// Query relay for user stats
 	result, err := rpc.FlashbotsGetUserStats(privateKey, 13281018)
 	if err != nil {
-		panic(err)
+		if errors.Is(err, flashbotsrpc.ErrRelayErrorResponse) {
+			// ErrRelayErrorResponse means it's a standard Flashbots relay error response, so probably a user error, rather than JSON or network error
+			fmt.Println(err.Error())
+		} else {
+			fmt.Printf("error: %+v\n", err)
+		}
+		return
 	}
 
 	// Print result

flashbotsrpc.go

@@ -12,8 +12,6 @@ import (
 	"os"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -187,7 +185,7 @@ func (rpc *FlashbotsRPC) CallWithFlashbotsSignature(method string, privKey *ecds
 	errorResp := new(RelayErrorResponse)
 	if err := json.Unmarshal(data, errorResp); err == nil && errorResp.Error != "" {
 		// relay returned an error
-		return nil, errors.New(errorResp.Error)
+		return nil, fmt.Errorf("%w: %s", ErrRelayErrorResponse, errorResp.Error)
 	}
 
 	resp := new(rpcResponse)
@@ -621,7 +619,7 @@ func (rpc *FlashbotsRPC) FlashbotsSendBundle(privKey *ecdsa.PrivateKey, param Fl
 	return res, err
 }
 
-// numTx is the maximum number of tx to include (used for troubleshooting). default 0 (all transactions)
+// Simulate a full Ethereum block. numTx is the maximum number of tx to include, used for troubleshooting (default: 0 - all transactions)
 func (rpc *FlashbotsRPC) FlashbotsSimulateBlock(privKey *ecdsa.PrivateKey, block *types.Block, maxTx int) (res FlashbotsCallBundleResponse, err error) {
 	if rpc.Debug {
 		fmt.Printf("Simulating block %s 0x%x %s \t %d tx \t timestamp: %d\n", block.Number(), block.Number(), block.Header().Hash(), len(block.Transactions()), block.Header().Time)
@@ -682,3 +680,28 @@ func (rpc *FlashbotsRPC) FlashbotsSimulateBlock(privKey *ecdsa.PrivateKey, block
 	res, err = rpc.FlashbotsCallBundle(privKey, params)
 	return res, err
 }
+
+// Sends a rawTx to the Flashbots relay. It will be sent to miners as bundle for 25 blocks, after which the transaction is failed.
+func (rpc *FlashbotsRPC) FlashbotsSendPrivateTransaction(privKey *ecdsa.PrivateKey, param FlashbotsSendPrivateTransactionRequest) (txHash string, err error) {
+	rawMsg, err := rpc.CallWithFlashbotsSignature("eth_sendPrivateTransaction", privKey, param)
+	if err != nil {
+		return "", err
+	}
+	err = json.Unmarshal(rawMsg, &txHash)
+	return txHash, err
+}
+
+// Try to cancel a private transaction at the Flashbots relay. If this call returns true this means the cancel was initiated, but it's not guaranteed
+// that the transaction is actually cancelled, only that it won't be sent to miners anymore. A transaction that was already sent to miners might still
+// be included in the next block.
+//
+// Possible errors: 'tx not found', 'tx was already cancelled', 'tx has already expired'
+func (rpc *FlashbotsRPC) FlashbotsCancelPrivateTransaction(privKey *ecdsa.PrivateKey, param FlashbotsCancelPrivateTransactionRequest) (cancelled bool, err error) {
+	rawMsg, err := rpc.CallWithFlashbotsSignature("eth_cancelPrivateTransaction", privKey, param)
+	if err != nil {
+		// possible todo: return specific errors for the 3 possible relay-internal error cases
+		return false, err
+	}
+	err = json.Unmarshal(rawMsg, &cancelled)
+	return cancelled, err
+}

types.go

@@ -5,8 +5,13 @@ import (
 	"encoding/json"
 	"math/big"
 	"unsafe"
+
+	"github.com/pkg/errors"
 )
 
+// ErrRelayErrorResponse means it's a standard Flashbots relay error response - probably a user error rather than JSON or network error
+var ErrRelayErrorResponse = errors.New("relay error response")
+
 // Syncing - object with syncing data info
 type Syncing struct {
 	IsSyncing     bool
@@ -369,6 +374,7 @@ type FlashbotsCallBundleResponse struct {
 	TotalGasUsed      int64                       `json:"totalGasUsed"`      // 63197
 }
 
+// sendBundle
 type FlashbotsSendBundleRequest struct {
 	Txs          []string  `json:"txs"`                         // Array[String], A list of signed transactions to execute in an atomic bundle
 	BlockNumber  string    `json:"blockNumber"`                 // String, a hex encoded block number for which this bundle is valid on
@@ -380,3 +386,13 @@ type FlashbotsSendBundleRequest struct {
 type FlashbotsSendBundleResponse struct {
 	BundleHash string `json:"bundleHash"`
 }
+
+// sendPrivateTransaction
+type FlashbotsSendPrivateTransactionRequest struct {
+	Tx string `json:"tx"`
+}
+
+// cancelPrivateTransaction
+type FlashbotsCancelPrivateTransactionRequest struct {
+	TxHash string `json:"txHash"`
+}