An Ethereum transaction from signing to finality

HOW IT FITS TOGETHER

KEY TERMS

Nonce

Per-account counter. Transactions execute strictly in nonce order, a gap blocks all later ones, and two transactions with the same nonce are mutually exclusive.

EIP-1559 fees

Base fee is set by the protocol, moves at most 12.5% per block toward a 50% full target, and is burned. The priority fee goes to the block producer. You pay min(maxFeePerGas, baseFee + maxPriorityFeePerGas) per gas used.

Typed transactions (EIP-2718)

TransactionType || payload. 0 legacy, 1 access list (2930), 2 dynamic fee (1559), 3 blob (4844, used by rollups), 4 set-code (7702, lets an EOA delegate to contract code via an authorization list). Receipts are typed too.

Chain ID and EIP-155

Legacy transactions fold chainId into v (chainId * 2 + 35/36); typed transactions carry chainId as a field. Either way a signature for one chain is invalid on another.

Builders and PBS

Most mainnet blocks are built by specialised builders and delivered to the proposer through MEV-Boost relays. Order inside a block is the builder's choice, so frontrunning and sandwiching are real for public-mempool swaps.

safe and finalized tags

JSON-RPC block tags. Slots are 12 s and epochs 32 slots; finalized usually trails the head by about two epochs (12.8 min) plus the time to reach the next checkpoint.

Replacement

Send a new tx with the same nonce and higher fees. Geth's default txpool.pricebump requires at least 10% more on both maxFeePerGas and maxPriorityFeePerGas; other clients have similar rules.

IN YOUR STACK

import { createPublicClient, createWalletClient, http, parseEther, type Hex } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { mainnet } from "viem/chains";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);
const transport = http(process.env.RPC_URL);
const wallet = createWalletClient({ account, chain: mainnet, transport });
const client = createPublicClient({ chain: mainnet, transport });

// Nonce, gas and EIP-1559 fees are filled in unless you pass them.
const hash = await wallet.sendTransaction({
  to: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
  value: parseEther("0.01"),
});

const receipt = await client.waitForTransactionReceipt({
  hash,
  confirmations: 1,
  onReplaced: (r) => console.warn(r.reason, r.transaction.hash), // repriced | cancelled | replaced
});
if (receipt.status === "reverted") throw new Error("reverted, fee still paid");

const finalized = await client.getBlock({ blockTag: "finalized" });
const isFinal = receipt.blockNumber <= finalized.number;

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);

const fee = await provider.getFeeData();
const tx = await wallet.sendTransaction({
  to: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
  value: ethers.parseEther("0.01"),
  maxFeePerGas: fee.maxFeePerGas,
  maxPriorityFeePerGas: fee.maxPriorityFeePerGas,
});
console.log("pending", tx.hash, "nonce", tx.nonce);

try {
  const receipt = await tx.wait(1, 180_000); // throws CALL_EXCEPTION on revert
  const finalized = await provider.getBlock("finalized");
  console.log(receipt!.blockNumber <= finalized!.number ? "finalized" : "included");
} catch (err) {
  if (ethers.isError(err, "TRANSACTION_REPLACED")) {
    console.warn(err.reason, err.replacement.hash); // cancelled | replaced | repriced
  } else throw err;
}

import { useSendTransaction, useWaitForTransactionReceipt } from "wagmi";
import { parseEther } from "viem";

export function PayButton() {
  const send = useSendTransaction();
  const receipt = useWaitForTransactionReceipt({
    hash: send.data, // query stays disabled until the wallet returns a hash
    confirmations: 2,
    onReplaced: (r) => console.warn("replaced:", r.reason),
  });

  return (
    <>
      <button
        disabled={send.isPending || receipt.isLoading}
        onClick={() => send.mutate({ to: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8", value: parseEther("0.01") })}
      >Pay 0.01 ETH</button>
      {send.isPending && <p>Confirm in your wallet</p>}
      {receipt.isLoading && <p>Submitted, waiting for inclusion</p>}
      {receipt.data?.status === "success" && <p>Included in block {receipt.data.blockNumber.toString()}</p>}
      {receipt.data?.status === "reverted" && <p>Reverted on-chain; the fee was still charged</p>}
    </>
  );
}

# Mined vs pending nonce: a gap means something is stuck
cast nonce $ADDR --block latest --rpc-url $RPC_URL
cast nonce $ADDR --block pending --rpc-url $RPC_URL
cast base-fee --rpc-url $RPC_URL

# EIP-1559 send: --gas-price is maxFeePerGas, --priority-gas-price the tip
cast send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 --value 0.01ether \
  --priority-gas-price 2gwei --account deployer --rpc-url $RPC_URL --async

cast receipt $TX_HASH status --confirmations 2 --rpc-url $RPC_URL
cast block finalized --field number --rpc-url $RPC_URL

# Cancel nonce 7: 0-value self-send, same nonce, >=10% higher on both fees
cast send $ADDR --value 0 --nonce 7 \
  --gas-price 60gwei --priority-gas-price 3gwei \
  --account deployer --rpc-url $RPC_URL

import os
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(os.environ["RPC_URL"]))
acct = w3.eth.account.from_key(os.environ["PRIVATE_KEY"])

base_fee = w3.eth.get_block("latest")["baseFeePerGas"]
tip = w3.eth.max_priority_fee
tx = {
    "type": 2,
    "chainId": w3.eth.chain_id,  # signed in, so no cross-chain replay
    "nonce": w3.eth.get_transaction_count(acct.address, "pending"),
    "to": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
    "value": w3.to_wei("0.01", "ether"),
    "gas": 21_000,
    "maxPriorityFeePerGas": tip,
    "maxFeePerGas": 2 * base_fee + tip,  # survives ~6 full blocks of +12.5%
}
signed = acct.sign_transaction(tx)
tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)

receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=180)
if receipt["status"] != 1:
    raise RuntimeError(f"reverted in block {receipt['blockNumber']}")
final = receipt["blockNumber"] <= w3.eth.get_block("finalized")["number"]

use alloy::{
    eips::BlockNumberOrTag,
    network::TransactionBuilder,
    primitives::{address, utils::parse_ether},
    providers::{Provider, ProviderBuilder},
    rpc::types::TransactionRequest,
    signers::local::PrivateKeySigner,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let signer: PrivateKeySigner = std::env::var("PRIVATE_KEY")?.parse()?;
    let rpc = std::env::var("RPC_URL")?;
    // new() enables the recommended fillers: nonce, chain ID, gas, EIP-1559 fees.
    let provider = ProviderBuilder::new().wallet(signer).connect(&rpc).await?;

    let tx = TransactionRequest::default()
        .with_to(address!("0x70997970C51812dc3A010C7d01b50e0d17dc79C8"))
        .with_value(parse_ether("0.01")?);
    let pending = provider.send_transaction(tx).await?;
    let receipt = pending.with_required_confirmations(2).get_receipt().await?;

    let finalized = provider.get_block_by_number(BlockNumberOrTag::Finalized).await?;
    let is_final = finalized.is_some_and(|b| receipt.block_number.unwrap_or(u64::MAX) <= b.header.number);
    println!("success={} final={}", receipt.status(), is_final);
    Ok(())
}

WHERE IT BITES

• Treating eth_sendRawTransaction success as payment success: the tx can still be dropped, replaced, or revert.
• Tracking only the hash: speed-ups and cancels create a new hash for the same nonce. Track (sender, nonce) and reconcile whichever hash mined.
• Crediting on one confirmation for high-value flows: blocks at the head can reorg. Use the safe or finalized tag, or re-verify the block hash later.
• Setting maxFeePerGas equal to the current base fee: a few full blocks later the tx is no longer includable and sits pending.
• Fetching the nonce independently in parallel workers or across load-balanced RPC nodes, producing duplicates and gaps.
• Showing an L2 sequencer confirmation as final settlement, or telling users an L2 tx takes 7 days to finalize (that is the bridge withdrawal window).

WHEN IT BREAKS IN PRODUCTION

• A transaction is pending forever and blocks the rest
• A deposit was credited, then vanished after a reorg
• Signatures fail because the wallet is on the wrong chain
• Balances and nonces flip between refreshes
• A Web3 payment feels like developer tooling

SOURCES

• ethereum.org: Transactions (opens in new tab)Checked 2026-10-07
• EIP-1559: Fee market change for ETH 1.0 chain (opens in new tab)Checked 2026-10-07
• EIP-7702: Set Code for EOAs (opens in new tab)Checked 2026-10-07
• ethereum.org: Proof-of-stake (slots, epochs, finality) (opens in new tab)Checked 2026-10-07
• Flashbots: MEV-Boost introduction (opens in new tab)Checked 2026-10-07
• OP Stack: Transaction finality (opens in new tab)Checked 2026-10-07