Ethereum Basics

Externally Owned Accounts (EOAs) are the only accounts on Ethereum that can initiate transactions. Unlike Contract Accounts, which execute predefined code when triggered, EOAs require a private key to sign transactions and broadcast them to the network. This process ensures that only the owner of the private key can authorize actions like sending ETH, interacting with smart contracts, or deploying new contracts.

Once a transaction is signed and broadcasted, Ethereum nodes validate and execute it, updating the global state of the blockchain.

Steps in the Transaction Lifecycle

1. User (EOA owner) initiates a transaction using a wallet or script.
2. EOA signs the transaction with its private key to prove authenticity.
3. Transaction is broadcasted to the Ethereum network.
4. Ethereum nodes validate the transaction and include it in a block.
5. The transaction updates the blockchain state, reflecting the new balance or contract execution.

This ensures that only the owner of the private key can trigger transactions, preventing unauthorized actions.

Types of Transactions EOAs Can Initiate

EOAs can initiate three primary types of transactions:

1. A simple ETH transfer from one EOA to another.
2. A smart contract interaction, calling a function within a deployed contract.
3. A contract deployment transaction, creating a new Contract Account on Ethereum.

Each transaction follows the same fundamental process but varies in complexity and execution requirements.

1. Sending ETH from One EOA to Another

The most basic transaction an EOA can initiate is transferring ETH from one account to another. This is similar to sending money between bank accounts but operates without a centralized authority.

Process

1. The sender EOA creates a transaction specifying:
   • The recipient address.
   • The amount of ETH to send.
   • A gas limit to pay for network fees.
2. The sender signs the transaction using their private key.
3. The transaction is broadcasted to the network.
4. Ethereum miners/validators verify and confirm the transaction in a block.
5. The recipient's balance increases by the transferred amount, and the sender’s balance decreases accordingly.

Example: Sending ETH from One EOA to Another

Using ethers.js, we can initiate a simple ETH transfer.

<pre><code class="language-js"> const { ethers } = require("ethers"); const provider = new ethers.providers.JsonRpcProvider("mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID"); const senderWallet = new ethers.Wallet("YOUR_PRIVATE_KEY", provider); const transaction = { to: "0xRecipientAddress", value: ethers.utils.parseEther("1.0"),  }; const sendTx = async () => { const tx = await senderWallet.sendTransaction(transaction); await tx.wait(); console.log("Transaction successful! Hash:", tx.hash); }; sendTx(); </code></pre>

Once executed, the recipient will receive 1 ETH, and the sender's balance will be deducted accordingly.

2. Interacting with a Smart Contract

EOAs can also call functions within smart contracts. This is how users interact with DeFi protocols, NFT marketplaces, DAOs, and other dApps on Ethereum.

Since smart contracts do not have private keys, they cannot execute functions on their own. Instead, an EOA must send a transaction to trigger the contract’s execution.

Process

1. The EOA creates a transaction specifying:
   • The contract’s address.
   • The function to call and any required arguments.
   • The gas limit and ETH value (if applicable).
2. The sender signs the transaction using their private key.
3. The transaction is broadcasted to the Ethereum network.
4. The Ethereum Virtual Machine (EVM) executes the function within the smart contract.
5. The contract updates its internal state or triggers additional logic, such as transferring tokens or storing data.

Example: Calling a Smart Contract Function

Let's assume we have a SimpleStorage contract deployed on Ethereum that allows users to store a number.

Solidity Smart Contract (Already Deployed)

<pre><code class="language-js"> pragma solidity ^0.8.0; contract SimpleStorage { uint public storedValue; function setValue(uint _value) public { storedValue = _value; } } </code></pre>

EOA Calling the Contract to Set a Value

<pre><code class="language-js"> const contractAddress = "0xSmartContractAddress"; const contractABI = [ "function setValue(uint _value) public" ]; const contract = new ethers.Contract(contractAddress, contractABI, senderWallet); const updateValue = async () => { const tx = await contract.setValue(42); await tx.wait(); console.log("Value updated successfully!"); }; updateValue(); </code></pre>

The EOA initiates the transaction, and the contract updates its stored value on-chain.

This is how users interact with DeFi, NFTs, DAOs, and other blockchain-based applications.

3. Deploying a Smart Contract

EOAs can deploy new smart contracts, creating a Contract Account that lives permanently on Ethereum.

Unlike EOAs, Contract Accounts do not have private keys and execute code automatically when triggered by an EOA or another contract.

Process

1. The EOA creates a transaction that contains:
   • The smart contract’s compiled bytecode.
   • Any constructor arguments (if required).
   • A gas limit and ETH value (if necessary).
2. The sender signs and broadcasts the transaction.
3. The transaction is confirmed on the blockchain, and Ethereum assigns the contract a unique address.
4. The smart contract exists permanently on Ethereum and can be interacted with like any other Contract Account.

Example: Deploying a Smart Contract

Using ethers.js, an EOA can deploy the SimpleStorage contract to Ethereum.

<pre><code class="language-js"> const contractBytecode = "0x...";  const contractABI = [ "function setValue(uint _value) public" ]; const contractFactory = new ethers.ContractFactory(contractABI, contractBytecode, senderWallet); const deployContract = async () => { const contract = await contractFactory.deploy(); await contract.deployed(); console.log("Contract deployed at:", contract.address); }; deployContract(); </code></pre>

Once deployed, the contract has its own address, and users can interact with it via transactions.

Why EOAs Are Essential for Ethereum

EOAs serve as the bridge between users and smart contracts, enabling all decentralized applications to function.

Without EOAs, Ethereum’s smart contract system would not function because Contract Accounts cannot execute code unless an EOA calls them.

Conclusion

Externally Owned Accounts (EOAs) initiate all transactions on Ethereum, allowing users to:

• Send ETH to other EOAs for payments and transfers.
• Interact with smart contracts to use DeFi, mint NFTs, and vote in DAOs.
• Deploy smart contracts, creating new Contract Accounts on the blockchain.

Since smart contracts cannot act autonomously, EOAs are the only entry point for executing contract logic, making them essential to Ethereum’s decentralized ecosystem.

With future upgrades like account abstraction and Layer 2 scaling, EOAs will become more efficient, secure, and user-friendly, enabling greater accessibility and adoption of Ethereum-based applications.

Ethereum’s Contract Accounts are special accounts on the blockchain that are controlled by smart contract code rather than private keys. Unlike Externally Owned Accounts (EOAs), which are controlled by users and can initiate transactions, Contract Accounts cannot initiate transactions by themselves. Instead, they respond to transactions initiated by EOAs or other smart contracts.

Contract Accounts store and execute smart contracts, which are self-executing programs deployed on the Ethereum blockchain. These contracts define specific rules and logic that automatically execute when triggered by an external transaction. Smart contracts power decentralized applications (dApps), enabling trustless, automated transactions in DeFi, NFTs, DAOs, and more.

Understanding how Contract Accounts store and execute smart contract code is crucial for developers, users, and businesses interacting with Ethereum.

How Contract Accounts Work on Ethereum

Contract Accounts operate differently from EOAs in several key ways:

• They do not have private keys—their execution is determined by on-chain code.
• They cannot send transactions autonomously—they require an EOA or another contract to call them.
• They store code and state on the Ethereum blockchain.
• They execute functions based on predefined logic, responding to transaction inputs.

Contract Accounts provide the foundation for dApps, enabling automated, verifiable execution without centralized control.

How Smart Contract Code Is Stored in Contract Accounts

When a smart contract is deployed to Ethereum, it is converted into bytecode and stored on-chain at a unique contract address.

1. Writing a Smart Contract

Smart contracts on Ethereum are typically written in Solidity, a high-level programming language that compiles down to Ethereum Virtual Machine (EVM) bytecode.

Example: A simple smart contract that stores and updates a value.

<pre><code class="language-js"> pragma solidity ^0.8.0; contract SimpleStorage { uint public storedValue; function setValue(uint _value) public { storedValue = _value; } } </code></pre>

In this contract:

• storedValue is stored persistently on the blockchain.
• setValue() updates the stored value when called.
• Once deployed, this contract will always execute as programmed, without the need for intermediaries.

2. Deploying a Smart Contract to Ethereum

When a contract is deployed:

• It is compiled into EVM bytecode.
• The bytecode is sent in a transaction from an EOA.
• The blockchain assigns the contract a unique address.
• The contract's code is stored permanently on Ethereum.

Example: Deploying a smart contract using ethers.js

<pre><code class="language-js"> const { ethers } = require("ethers"); const provider = new ethers.providers.JsonRpcProvider("https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID"); const wallet = new ethers.Wallet("YOUR_PRIVATE_KEY", provider); const contractFactory = new ethers.ContractFactory(contractABI, contractBytecode, wallet); const deployContract = async () => { const contract = await contractFactory.deploy(); await contract.deployed(); console.log("Contract Address:", contract.address); }; deployContract(); </code></pre>

Once deployed, the contract exists on-chain at a permanent Ethereum address.

How Contract Accounts Execute Smart Contract Code

Contract Accounts do not execute automatically—they require an EOA or another contract to call them.

1. Calling a Smart Contract Function

EOAs send transactions to contract accounts to execute functions.

Example: Updating a stored value in the deployed contract

<pre><code class="language-js"> const contract = new ethers.Contract(contractAddress, contractABI, wallet); const updateValue = async () => { const tx = await contract.setValue(42); await tx.wait(); console.log("Transaction confirmed, value updated!"); }; updateValue(); </code></pre>

• The EOA triggers the transaction by calling setValue(42).
• The Ethereum Virtual Machine (EVM) executes the contract logic.
• The contract’s state updates on-chain.

2. Contracts Calling Other Contracts

Contracts can call functions on other contracts when triggered by an EOA.

Example: A contract retrieving data from another contract

<pre><code class="language-js"> pragma solidity ^0.8.0; interface IStorage { function storedValue() external view returns (uint); } contract Caller { function getValue(address contractAddress) public view returns (uint) { return IStorage(contractAddress).storedValue(); } } </code></pre>

This enables modular contract design, where multiple contracts work together to create DeFi platforms, lending protocols, and NFT marketplaces.

Gas Fees: How Contract Accounts Execute Code

Executing smart contract functions requires gas fees, paid in ETH. Since Contract Accounts cannot initiate transactions, the user (EOA) calling the function must pay for gas.

1. Estimating Gas Before Executing a Transaction

Before calling a smart contract function, users can estimate the required gas.

<pre><code class="language-js"> const estimatedGas = await contract.estimateGas.setValue(42); console.log("Estimated Gas Cost:", estimatedGas.toString()); </code></pre>

Gas fees prevent network spam and ensure validators are compensated for processing transactions.

Security Considerations for Contract Accounts

Smart contracts are immutable once deployed, meaning bugs and vulnerabilities cannot be fixed.

1. Common Smart Contract Risks

2. Preventing Smart Contract Attacks

Developers must follow best practices to secure contract accounts.

Example: Implementing a reentrancy guard

<pre><code class="language-js"> contract SecureContract { bool private locked; modifier noReentrant() { require(!locked, "No reentrancy allowed"); locked = true; _; locked = false; } function withdraw() public noReentrant { // Secure withdrawal logic } } </code></pre>

Using OpenZeppelin security libraries also improves contract safety.

The Future of Contract Accounts

Ethereum is improving contract accounts through Layer 2 scaling and account abstraction.

Example: Smart contract wallets enabling gasless transactions

<pre><code class="language-js"> contract SmartWallet { address public owner; constructor() { owner = msg.sender; } function executeTransaction(address to, uint amount) public { require(msg.sender == owner, "Not authorized"); payable(to).transfer(amount); } } </code></pre>

With account abstraction, contract accounts will become more user-friendly, making Ethereum more accessible and efficient.

Conclusion

Ethereum’s Contract Accounts store and execute smart contract code, enabling a decentralized ecosystem where applications run without centralized control.

• Contract Accounts do not have private keys—they execute code when called by an EOA.
• Smart contracts store state, execute logic, and interact with other contracts.
• Users must pay gas fees to execute contract functions.
• Security measures, such as reentrancy protection and audits, are essential to preventing attacks.
• Future upgrades like account abstraction will improve how contracts interact with EOAs.

Understanding how Contract Accounts function is essential for developers, businesses, and users engaging with Ethereum’s smart contract ecosystem.

Ethereum’s Externally Owned Accounts (EOAs) and Contract Accounts work together to power decentralized applications (dApps), allowing users to interact with smart contracts, DeFi platforms, NFTs, DAOs, and other blockchain-based services.

EOAs, controlled by private keys, are the only accounts that can initiate transactions. Contract accounts, on the other hand, contain immutable smart contract code that executes when triggered by an external transaction. Together, they enable a trustless, decentralized system where applications run without central authority.

Understanding how EOAs interact with Contract Accounts is crucial for developers, DeFi users, and anyone engaging with Ethereum-based applications.

How EOAs Interact with Contract Accounts

Ethereum’s smart contract ecosystem relies on EOAs to trigger contract execution. Since contract accounts cannot initiate transactions, they depend on EOAs or other contracts to call their functions.

1. Sending ETH to a Contract Account

EOAs can transfer ETH to a smart contract, triggering predefined logic such as staking, swaps, or payments.

Example: Sending 1 ETH to a contract

<pre><code class="language-js"> const tx = { to: "0xSmartContractAddress", value: ethers.utils.parseEther("1.0"), }; const sendTx = async () => { const transaction = await wallet.sendTransaction(tx); await transaction.wait(); console.log("ETH sent successfully!"); }; sendTx(); </code></pre>

When the contract receives ETH, it can store it, execute functions, or redistribute funds based on its logic.

2. EOAs Calling Smart Contract Functions

EOAs interact with smart contracts by calling functions that modify contract state, trigger events, or transfer tokens.

Example: Updating a stored value in a contract

<pre><code class="language-js"> const contract = new ethers.Contract(contractAddress, contractABI, wallet); const updateValue = async () => { const tx = await contract.setValue(42); await tx.wait(); console.log("Transaction confirmed, value updated!"); }; updateValue(); </code></pre>

The EOA pays gas fees to process the transaction, and the contract updates its state accordingly.

3. Smart Contracts Calling Other Smart Contracts

While contract accounts cannot initiate transactions, they can call other contracts when triggered by an EOA or another contract.

Example: A contract retrieving data from another contract

<pre><code class="language-js"> pragma solidity ^0.8.0; interface IStorage { function storedValue() external view returns (uint); } contract Caller { function getValue(address contractAddress) public view returns (uint) { return IStorage(contractAddress).storedValue(); } } </code></pre>

This enables modular smart contract development, where multiple contracts work together to create complex DeFi platforms, lending protocols, and NFT marketplaces.

Real-World Applications: How EOAs and Contracts Enable dApps

EOAs and contract accounts form the backbone of decentralized applications, providing users with secure, trustless ways to interact with financial services, digital assets, and governance systems.

1. Decentralized Finance (DeFi)

EOAs interact with DeFi protocols to lend, borrow, swap, and earn interest using smart contracts.

Example: Supplying ETH to a lending protocol (Aave)

<pre><code class="language-js"> const aaveLending = new ethers.Contract(aaveAddress, aaveABI, wallet); const depositETH = async () => { const tx = await aaveLending.deposit({ value: ethers.utils.parseEther("1.0") }); await tx.wait(); console.log("1 ETH deposited into Aave!"); }; depositETH(); </code></pre>

The user’s EOA initiates the deposit, and the contract automatically manages lending and interest accrual.

2. Non-Fungible Tokens (NFTs)

EOAs mint, buy, and trade NFTs by interacting with ERC-721 smart contracts.

Example: Minting a new NFT

<pre><code class="language-js"> const nftContract = new ethers.Contract(nftAddress, nftABI, wallet); const mintNFT = async () => { const tx = await nftContract.mintNFT(); await tx.wait(); console.log("NFT minted successfully!"); }; mintNFT(); </code></pre>

The EOA calls the minting function, and the smart contract records ownership on-chain.

3. Decentralized Autonomous Organizations (DAOs)

EOAs interact with DAO governance contracts, voting on proposals and managing decentralized treasuries.

Example: Casting a vote on a DAO proposal

<pre><code class="language-js"> const daoContract = new ethers.Contract(daoAddress, daoABI, wallet); const vote = async (proposalId, support) => { const tx = await daoContract.castVote(proposalId, support); await tx.wait(); console.log("Vote cast successfully!"); }; vote(1, true); </code></pre>

EOAs submit votes, and smart contracts execute governance decisions automatically.

Gas Fees: How Transactions Are Paid

EOAs must pay gas fees when interacting with smart contracts. Contracts cannot pay for transactions, so users need ETH to cover execution costs.

Example: Estimating gas before submitting a transaction

<pre><code class="language-js"> const estimatedGas = await contract.estimateGas.someFunction(); console.log("Estimated Gas Cost:", estimatedGas.toString()); </code></pre>

Gas fees ensure that Ethereum nodes process transactions securely and prevent spam attacks.

Security Considerations: Protecting EOAs and Contracts

Ethereum’s security model ensures that EOAs and contract accounts remain secure, but vulnerabilities can arise if users or developers are careless.

1. Protecting EOAs

• Use hardware wallets for long-term storage.
• Never share private keys or store them online.
• Use multi-signature wallets for added security.

2. Securing Smart Contracts

• Implement reentrancy guards to prevent malicious exploits.
• Use OpenZeppelin libraries for tested, secure contract functions.
• Perform security audits before deploying contracts to mainnet.

Example: Preventing reentrancy attacks

<pre><code class="language-js"> contract SecureContract { bool private locked; modifier noReentrant() { require(!locked, "No reentrancy allowed"); locked = true; _; locked = false; } function withdraw() public noReentrant { // Secure withdrawal logic } } </code></pre>

By securing EOAs and contract accounts, Ethereum ensures reliable, trustless interactions.

The Future of Ethereum Accounts

Ethereum is evolving to improve the interaction between EOAs and smart contracts.

Example: Smart contract wallets enabling gasless transactions

<pre><code class="language-js"> contract SmartWallet { address public owner; constructor() { owner = msg.sender; } function executeTransaction(address to, uint amount) public { require(msg.sender == owner, "Not authorized"); payable(to).transfer(amount); } } </code></pre>

With account abstraction, smart wallets will become more user-friendly, improving Ethereum’s accessibility.

Conclusion

Ethereum’s EOAs and contract accounts work together to enable a decentralized ecosystem, allowing users to:

• Send ETH and interact with dApps via EOAs.
• Trigger smart contracts that automate DeFi, NFTs, and DAOs.
• Secure their funds and transactions with best practices.

Future upgrades like account abstraction and Layer 2 scaling will further streamline how users and smart contracts interact, making Ethereum more efficient, accessible, and secure for millions of users worldwide.