Transaction Signing

Signing Ethereum Transactions

This page demonstrates how to create and sign an Ethereum transaction to transfer funds from one account to another. You can use the private keys generated in the Public Key Cryptography section of Blockchain Concepts. For the transaction flow, mem-pool, gas fees, and block rewards, see the Introduction to Ethereum transactions.

Note: This is a demonstration tool. In a real Ethereum transaction, you would also need to specify gas price, gas limit, and nonce. This simplified version focuses on the core transaction signing process.

Create Transaction

Fill in the transaction details below:

From Address (Sender): Enter the Ethereum address of the sender (derived from the public key)

To Address (Recipient): Enter the Ethereum address of the recipient

Amount (ETH): Amount to transfer in Ether

Nonce: Transaction nonce (prevents replay attacks)

Gas Price (Gwei): Gas price in Gwei (1 Gwei = 10^9 Wei)

Gas Limit: Maximum gas units for this transaction (21000 for simple transfers)

Chain ID: Chain ID for the network (11155111 for Sepolia testnet, 1 for Mainnet)

Smart Contract Deployment Enable this to deploy a smart contract with this transaction

Call Smart Contract Function Enable this to call a function on an existing smart contract

Smart contract calling: transaction with To=contract address, Data=encoded method selector and arguments; 65-byte ECDSA signature

Smart contract calling: The transaction is sent to the contract address (To). The data field contains the encoded method selector and arguments for the function to execute.

Contract Address: The address of the smart contract to call Function Signature: Function name and parameter types, e.g., transfer(address,uint256) Function Parameters (JSON array): Parameters as a JSON array. Example: ["0x742d35Cc...", "1000000000000000000"]

Smart contract deployment transaction: fields (nonce, signature, value, To=NULL, gasPrice, gasLimit, data with encoded bytecode); Solidity contract compiles to bytecode

Smart contract deployment: The transaction has To empty (not an EOA); the data field holds the contract's encoded bytecode. Solidity is compiled to bytecode for deployment.

Solidity Code (for Contract Deployment):

Enter Solidity code to deploy a smart contract. The compiled bytecode will be used as the transaction data.

Sign Transaction

Enter your private key to sign the transaction:

Private Key (Hex): The private key corresponding to the "From" address. You can use a key from the Key Generation page in Blockchain Concepts.

Transaction Details

Understanding the transaction components:

From Address: The Ethereum address of the account sending the funds. This is derived from the public key (which comes from the private key).
To Address: The recipient's Ethereum address where funds will be sent.
Amount: The quantity of Ether to transfer (in ETH units).
Nonce: A sequential number that ensures each transaction is unique and prevents replay attacks. It should increment for each transaction from the same account.
Gas Price: The amount of Ether you're willing to pay per unit of gas. Higher gas prices typically result in faster transaction processing.
Gas Limit: The maximum amount of gas units you're willing to spend on this transaction. For simple transfers, 21,000 is standard.
Signature: Cryptographic proof that you own the private key for the "From" address and authorize this transaction.