cmd/pushtx: add CLI tool for submitting raw signed transactions

Co-authored-by: drQedwards <213266729+drQedwards@users.noreply.github.com>

.gitignore

@@ -57,3 +57,4 @@ cmd/geth/geth
 cmd/rlpdump/rlpdump
 cmd/workload/workload
 cmd/keeper/keeper
+cmd/pushtx/pushtx

Makefile

@@ -14,6 +14,12 @@ geth:
 	@echo "Done building."
 	@echo "Run \"$(GOBIN)/geth\" to launch geth."
 
+#? pushtx: Build pushtx.
+pushtx:
+	$(GORUN) build/ci.go install ./cmd/pushtx
+	@echo "Done building."
+	@echo "Run \"$(GOBIN)/pushtx\" to launch pushtx."
+
 #? evm: Build evm.
 evm:
 	$(GORUN) build/ci.go install ./cmd/evm

cmd/pushtx/main.go

@@ -0,0 +1,177 @@
+// Copyright 2025 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+// pushtx submits a raw signed transaction to an Ethereum JSON-RPC endpoint.
+package main
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"math/big"
+	"os"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+const defaultRPCURL = "http://127.0.0.1:8545"
+
+func main() {
+	if err := run(os.Args[1:], os.Stdin); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func run(args []string, stdin io.Reader) error {
+	var (
+		rpcURL string
+		txHex  string
+	)
+	// Parse flags manually so the tool stays minimal.
+	for i := 0; i < len(args); i++ {
+		switch {
+		case args[i] == "--rpc" || args[i] == "-rpc":
+			i++
+			if i >= len(args) {
+				return fmt.Errorf("missing value for %s", args[i-1])
+			}
+			rpcURL = args[i]
+		case strings.HasPrefix(args[i], "--rpc="):
+			rpcURL = strings.TrimPrefix(args[i], "--rpc=")
+		case strings.HasPrefix(args[i], "-rpc="):
+			rpcURL = strings.TrimPrefix(args[i], "-rpc=")
+		case args[i] == "-h" || args[i] == "--help":
+			printUsage()
+			return nil
+		case strings.HasPrefix(args[i], "-"):
+			return fmt.Errorf("unknown flag: %s", args[i])
+		default:
+			if txHex != "" {
+				return fmt.Errorf("unexpected argument: %s", args[i])
+			}
+			txHex = args[i]
+		}
+	}
+
+	if rpcURL == "" {
+		rpcURL = defaultRPCURL
+	}
+
+	// Read transaction hex from stdin when no positional argument is given.
+	if txHex == "" {
+		data, err := io.ReadAll(stdin)
+		if err != nil {
+			return fmt.Errorf("reading stdin: %w", err)
+		}
+		txHex = strings.TrimSpace(string(data))
+	}
+	if txHex == "" {
+		return fmt.Errorf("no transaction data provided\nUsage: pushtx [--rpc URL] <tx-hex>")
+	}
+
+	rawTx, err := hex.DecodeString(strings.TrimPrefix(txHex, "0x"))
+	if err != nil {
+		return fmt.Errorf("invalid hex data: %w", err)
+	}
+
+	// Decode the transaction so we can display a summary.
+	var tx types.Transaction
+	if err := tx.UnmarshalBinary(rawTx); err != nil {
+		return fmt.Errorf("decoding transaction: %w", err)
+	}
+	printTxSummary(&tx)
+
+	// Send to the RPC endpoint.
+	hash, err := sendRawTransaction(rpcURL, rawTx)
+	if err != nil {
+		return fmt.Errorf("sending transaction: %w", err)
+	}
+	fmt.Println("Transaction submitted successfully")
+	fmt.Println("Hash:", hash.Hex())
+	return nil
+}
+
+// sendRawTransaction dials the given RPC endpoint and calls
+// eth_sendRawTransaction with the provided raw bytes.
+func sendRawTransaction(rpcURL string, rawTx []byte) (common.Hash, error) {
+	client, err := rpc.Dial(rpcURL)
+	if err != nil {
+		return common.Hash{}, fmt.Errorf("connecting to %s: %w", rpcURL, err)
+	}
+	defer client.Close()
+
+	var hash common.Hash
+	err = client.CallContext(context.Background(), &hash, "eth_sendRawTransaction", hexutil.Encode(rawTx))
+	if err != nil {
+		return common.Hash{}, err
+	}
+	return hash, nil
+}
+
+// printTxSummary displays the decoded transaction details to stdout.
+func printTxSummary(tx *types.Transaction) {
+	signer := types.LatestSignerForChainID(tx.ChainId())
+	from, err := types.Sender(signer, tx)
+	if err != nil {
+		from = common.Address{}
+	}
+
+	fmt.Println("Transaction details:")
+	fmt.Println("  Type:     ", tx.Type())
+	fmt.Println("  From:     ", from.Hex())
+	if tx.To() != nil {
+		fmt.Println("  To:       ", tx.To().Hex())
+	} else {
+		fmt.Println("  To:        (contract creation)")
+	}
+	fmt.Println("  Nonce:    ", tx.Nonce())
+	fmt.Println("  Value:    ", formatWei(tx.Value()))
+	fmt.Println("  Gas limit:", tx.Gas())
+	fmt.Println("  Chain ID: ", tx.ChainId())
+}
+
+// formatWei converts a wei amount to a human-readable string showing
+// both the wei value and the ETH equivalent.
+func formatWei(wei *big.Int) string {
+	if wei == nil || wei.Sign() == 0 {
+		return "0 wei (0 ETH)"
+	}
+	ether := new(big.Float).Quo(new(big.Float).SetInt(wei), new(big.Float).SetFloat64(1e18))
+	return fmt.Sprintf("%s wei (%s ETH)", wei.String(), ether.Text('f', 18))
+}
+
+func printUsage() {
+	fmt.Fprintf(os.Stderr, `Usage: pushtx [--rpc URL] <tx-hex>
+
+Submit a raw signed Ethereum transaction to a JSON-RPC endpoint.
+
+The transaction data can be provided as a positional argument or via stdin.
+
+Options:
+  --rpc URL   JSON-RPC endpoint (default: %s)
+  -h, --help  Show this help message
+
+Examples:
+  pushtx --rpc http://localhost:8545 0xf86c...
+  echo 0xf86c... | pushtx --rpc http://localhost:8545
+`, defaultRPCURL)
+}

cmd/pushtx/main_test.go

@@ -0,0 +1,233 @@
+// Copyright 2025 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"crypto/ecdsa"
+	"encoding/json"
+	"math/big"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+// signedTestTx returns a signed legacy transaction and its hex encoding.
+func signedTestTx(t *testing.T) (*types.Transaction, string) {
+	t.Helper()
+
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+	return signedTestTxWithKey(t, key)
+}
+
+func signedTestTxWithKey(t *testing.T, key *ecdsa.PrivateKey) (*types.Transaction, string) {
+	t.Helper()
+
+	tx := types.NewTx(&types.LegacyTx{
+		Nonce:    6,
+		GasPrice: big.NewInt(0),
+		Gas:      21055,
+		To:       addrPtr(common.HexToAddress("0x78b5290269740033b05bd8d71c97331295eb5918")),
+		Value:    new(big.Int).Mul(big.NewInt(10), big.NewInt(1e18)), // 10 ETH
+	})
+	signer := types.NewEIP155Signer(big.NewInt(1))
+	signed, err := types.SignTx(tx, signer, key)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := signed.MarshalBinary()
+	if err != nil {
+		t.Fatal(err)
+	}
+	return signed, hexutil.Encode(data)
+}
+
+func addrPtr(a common.Address) *common.Address { return &a }
+
+// fakeRPC starts an HTTP server that responds to eth_sendRawTransaction.
+func fakeRPC(t *testing.T, wantErr bool) *httptest.Server {
+	t.Helper()
+
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var req struct {
+			Method string            `json:"method"`
+			Params []json.RawMessage `json:"params"`
+			ID     json.RawMessage   `json:"id"`
+		}
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		if req.Method != "eth_sendRawTransaction" {
+			json.NewEncoder(w).Encode(map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      req.ID,
+				"error":   map[string]interface{}{"code": -32601, "message": "method not found"},
+			})
+			return
+		}
+		if wantErr {
+			json.NewEncoder(w).Encode(map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      req.ID,
+				"error":   map[string]interface{}{"code": -32000, "message": "already known"},
+			})
+			return
+		}
+		// Decode the raw tx to return its hash as the result.
+		var hexData string
+		json.Unmarshal(req.Params[0], &hexData)
+		rawBytes, _ := hexutil.Decode(hexData)
+		var tx types.Transaction
+		tx.UnmarshalBinary(rawBytes)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"jsonrpc": "2.0",
+			"id":      req.ID,
+			"result":  tx.Hash().Hex(),
+		})
+	}))
+}
+
+func TestRunSuccess(t *testing.T) {
+	srv := fakeRPC(t, false)
+	defer srv.Close()
+
+	_, txHex := signedTestTx(t)
+	err := run([]string{"--rpc", srv.URL, txHex}, strings.NewReader(""))
+	if err != nil {
+		t.Fatal("unexpected error:", err)
+	}
+}
+
+func TestRunFromStdin(t *testing.T) {
+	srv := fakeRPC(t, false)
+	defer srv.Close()
+
+	_, txHex := signedTestTx(t)
+	err := run([]string{"--rpc", srv.URL}, strings.NewReader(txHex))
+	if err != nil {
+		t.Fatal("unexpected error:", err)
+	}
+}
+
+func TestRunRPCError(t *testing.T) {
+	srv := fakeRPC(t, true)
+	defer srv.Close()
+
+	_, txHex := signedTestTx(t)
+	err := run([]string{"--rpc", srv.URL, txHex}, strings.NewReader(""))
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	if !strings.Contains(err.Error(), "already known") {
+		t.Fatalf("unexpected error message: %v", err)
+	}
+}
+
+func TestRunNoInput(t *testing.T) {
+	err := run(nil, strings.NewReader(""))
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	if !strings.Contains(err.Error(), "no transaction data") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestRunBadHex(t *testing.T) {
+	err := run([]string{"not-hex-data"}, strings.NewReader(""))
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	if !strings.Contains(err.Error(), "invalid hex") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestRunBadTx(t *testing.T) {
+	err := run([]string{"0xdeadbeef"}, strings.NewReader(""))
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	if !strings.Contains(err.Error(), "decoding transaction") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestRunHelp(t *testing.T) {
+	err := run([]string{"--help"}, strings.NewReader(""))
+	if err != nil {
+		t.Fatal("unexpected error:", err)
+	}
+}
+
+func TestRunUnknownFlag(t *testing.T) {
+	err := run([]string{"--unknown"}, strings.NewReader(""))
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	if !strings.Contains(err.Error(), "unknown flag") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestRunExtraArgs(t *testing.T) {
+	err := run([]string{"0xaa", "0xbb"}, strings.NewReader(""))
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	if !strings.Contains(err.Error(), "unexpected argument") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestFormatWei(t *testing.T) {
+	tests := []struct {
+		wei  *big.Int
+		want string
+	}{
+		{nil, "0 wei (0 ETH)"},
+		{big.NewInt(0), "0 wei (0 ETH)"},
+		{big.NewInt(1e18), "1000000000000000000 wei (1.000000000000000000 ETH)"},
+		{new(big.Int).Mul(big.NewInt(10), big.NewInt(1e18)), "10000000000000000000 wei (10.000000000000000000 ETH)"},
+	}
+	for _, tt := range tests {
+		got := formatWei(tt.wei)
+		if got != tt.want {
+			t.Errorf("formatWei(%v) = %q, want %q", tt.wei, got, tt.want)
+		}
+	}
+}
+
+func TestRunEqualsSyntax(t *testing.T) {
+	srv := fakeRPC(t, false)
+	defer srv.Close()
+
+	_, txHex := signedTestTx(t)
+	err := run([]string{"--rpc=" + srv.URL, txHex}, strings.NewReader(""))
+	if err != nil {
+		t.Fatal("unexpected error:", err)
+	}
+}