From 17ef318c42e4c4721a340e5de2ab8bb4d595a8d7 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 12 Mar 2026 15:50:38 +0000 Subject: [PATCH] cmd/pushtx: add CLI tool for submitting raw signed transactions Co-authored-by: drQedwards <213266729+drQedwards@users.noreply.github.com> --- .gitignore | 1 + Makefile | 6 ++ cmd/pushtx/main.go | 177 ++++++++++++++++++++++++++++++ cmd/pushtx/main_test.go | 233 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 417 insertions(+) create mode 100644 cmd/pushtx/main.go create mode 100644 cmd/pushtx/main_test.go diff --git a/.gitignore b/.gitignore index 293359a669..9602bff893 100644 --- a/.gitignore +++ b/.gitignore @@ -57,3 +57,4 @@ cmd/geth/geth cmd/rlpdump/rlpdump cmd/workload/workload cmd/keeper/keeper +cmd/pushtx/pushtx diff --git a/Makefile b/Makefile index f3d7f48f2f..b7cb3bc38b 100644 --- a/Makefile +++ b/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 diff --git a/cmd/pushtx/main.go b/cmd/pushtx/main.go new file mode 100644 index 0000000000..674176a996 --- /dev/null +++ b/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 . + +// 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] ") + } + + 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] + +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) +} diff --git a/cmd/pushtx/main_test.go b/cmd/pushtx/main_test.go new file mode 100644 index 0000000000..101c3e8a22 --- /dev/null +++ b/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 . + +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) + } +}