Understanding Gas & Transactions

📝 State-Changing (Costs Gas):
├── Send WIRE tokens to someone
├── Deploy a smart contract
├── Call a function that writes data
├── Mint/burn tokens
└── Update contract storage

👀 Read-Only (FREE):
├── Check your balance
├── Read contract data
├── View transaction history
└── Query blockchain state

Traditional Bank:
You → 🏦 Bank → ⏳ Processing → ✅ Recorded (Private ledger)

Blockchain Transaction:
You → 📢 Broadcast → 🌐 Network → ⛓️ Miners/Validators → ✅ Block (Public ledger)

🚗 Car Journey:
Distance × Fuel Price = Trip Cost
100 km × $2/liter = $200

⛓️ Blockchain Transaction:
Gas Used × Gas Price = Transaction Fee
50,000 gas × 0.01 Gwei = Fee in WIRE

// Without gas, this would run forever and crash the network
function badFunction() public {
    while(true) {
        // Do something
    }
}
 
// With gas: After ~30M gas, transaction fails and stops

Validators provide:
├── Computing power (run transactions)
├── Storage (store blockchain data)
├── Network bandwidth (broadcast blocks)
└── Security (stake their tokens)

They deserve payment for their work!

Without fees: 
Someone could send millions of transactions → Network crashes

With fees:
Spamming costs real money → Network stays healthy

Total Transaction Fee = Gas Used × Gas Price

1 WIRE = 1,000,000,000 Gwei (1 billion)
1 Gwei = 0.000000001 WIRE

Think of it like:
1 Dollar = 100 Cents
1 WIRE = 1,000,000,000 Gwei

Gas Used:    21,000 gas
Gas Price:   10 Gwei (chain minimum)
Cost:        21,000 × 10 = 210,000 Gwei = 0.00021 WIRE

Gas Used:    1,200,000 gas
Gas Price:   10 Gwei
Cost:        1,200,000 × 10 = 12,000,000 Gwei = 0.012 WIRE

Gas Used:    150,000 gas
Gas Price:   10 Gwei
Cost:        150,000 × 10 = 1,500,000 Gwei = 0.0015 WIRE

{
  "from": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
  "to": "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed",
  "value": "1000000000000000000",  // 1 WIRE (18 decimals, base unit awire)
  "data": "0x",
  "gas": "21000",
  "gasPrice": "10000000000",  // 10 Gwei (WireFluid typical minimum)
  "nonce": "5",
  "chainId": "92533",
  "v": "0x1b",
  "r": "0x...",
  "s": "0x..."
}

Your Account:
├── Nonce 0: Deploy contract ✅ Confirmed
├── Nonce 1: Send 10 WIRE ✅ Confirmed
├── Nonce 2: Update contract ⏳ Pending
└── Nonce 3: Send 5 WIRE ⏸️ Waiting (can't process until nonce 2 confirms)

Step 1: Creation
👤 You → Sign transaction with private key
         ↓
Step 2: Broadcast
📡 Wallet → Send to WireFluid RPC node
         ↓
Step 3: Mempool
🎯 Node → Add to mempool (pending transactions)
         ↓
Step 4: Selection
⚖️ Validator → Pick transactions for next block
         ↓
Step 5: Execution
⚡ EVM → Run transaction code
         ↓
Step 6: Validation
🔍 Validators → Verify results
         ↓
Step 7: Block Creation
📦 Block → Transaction included in block
         ↓
Step 8: Finalization
✅ Network → Block finalized (PERMANENT)
         ↓
Step 9: Confirmation
📧 You → Receive confirmation in wallet

Status: Waiting to be included in a block
What to do: Wait patiently (usually 2-5 seconds)
Can you cancel? Yes, by sending a new transaction with same nonce and higher gas

Status: Included in a block and finalized
What to do: Nothing - it's done!
Can you cancel? No - it's permanent

Status: Transaction was processed but reverted
What to do: Check error message, fix issue, try again
Common causes:
- Out of gas
- Contract reverted (require statement failed)
- Insufficient balance
- Invalid input

Status: Removed from mempool without processing
What to do: Resubmit the transaction
Common causes:
- Gas price too low
- Nonce already used
- Replaced by another transaction

// Using ethers.js
const estimatedGas = await contract.transfer.estimateGas(recipient, amount);
console.log(`Estimated gas: ${estimatedGas}`);
 
// Add 10-20% buffer for safety
const gasLimit = estimatedGas * 1.2;

When you send a transaction, MetaMask shows:
┌─────────────────────────────┐
│ Estimated gas: 50,000       │
│ Gas price: 10 Gwei          │
│ Max fee: 0.0005 WIRE        │
│                             │
│ [Edit] [Confirm]            │
└─────────────────────────────┘

Addition (a + b):           3 gas
Multiplication (a × b):     5 gas
Storage write (256 bits):   20,000 gas
Storage read:               200 gas
Create new account:         25,000 gas
Transfer tokens:            ~9,000 gas
Call external contract:     ~2,600 gas + function cost

function transfer(address to, uint256 amount) public {
    // Read sender balance:        200 gas
    // Read recipient balance:     200 gas
    // Subtract from sender:       20,000 gas (storage write)
    // Add to recipient:           20,000 gas (storage write)
    // Emit event:                 ~1,000 gas
    // ────────────────────────────────────
    // Total:                      ~41,400 gas
    // Base transaction cost:      +21,000 gas
    // ────────────────────────────────────
    // Estimated total:            ~62,400 gas
}

Think of it like giving someone $100:
"Here's $100, do the job, and give me back what you don't use"

Gas Limit = $100 (maximum you're willing to pay)

The job only costs $65:
"Here's your $65 payment, and here's your $35 change"

Gas Used = $65 (actual cost)
Refund = $35 (unused gas returned)

// You set gas limit to 100,000
const tx = await contract.transfer(recipient, amount, {
    gasLimit: 100000
});
 
// Transaction uses 62,400 gas
// You pay for: 62,400 gas
// Refunded: 37,600 gas
// You're not charged for unused gas!

If Gas Used < Gas Limit → Success! Unused gas refunded
If Gas Used > Gas Limit → Transaction fails, gas consumed

Your transaction needed 100,000 gas
You only provided 50,000 gas
Transaction stopped halfway and failed

// Too low
const tx = await contract.deploy({ gasLimit: 50000 });
 
// Sufficient
const estimated = await contract.deploy.estimateGas();
const tx = await contract.deploy({ gasLimit: estimated * 1.2 });

Your balance: 1 WIRE
Transaction cost: 0.5 WIRE (gas)
Sending amount: 0.7 WIRE
Total needed: 1.2 WIRE
You're 0.2 WIRE short!

function withdraw(uint256 amount) public {
    require(balance[msg.sender] >= amount, "Insufficient balance");
    // ↑ This check failed!
    // Transaction stopped and reverted
}

Your account nonce: 10
Transaction nonce: 8
This nonce was already used!

Network minimum: 10 Gwei (WireFluid)
Your gas price: 1 Gwei
Validators won't process it!

// 3 separate transactions = 63,000 gas
transfer(alice, 10);    // 21,000 gas
transfer(bob, 10);      // 21,000 gas
transfer(charlie, 10);  // 21,000 gas

// 1 transaction = ~35,000 gas
function batchTransfer(address[] memory recipients, uint256 amount) public {
    for(uint i = 0; i < recipients.length; i++) {
        transfer(recipients[i], amount);
    }
}

// Writing to storage: 20,000 gas per write
function updateUser(string memory name, uint256 age) public {
    userName[msg.sender] = name;       // 20,000 gas
    userAge[msg.sender] = age;         // 20,000 gas
    userUpdated[msg.sender] = true;    // 20,000 gas
    // Total: 60,000 gas
}

// Struct packing: single storage slot
struct User {
    uint128 age;      // Pack multiple values
    uint128 score;    // in one storage slot
}
 
function updateUser(uint128 age, uint128 score) public {
    users[msg.sender] = User(age, score);  // 20,000 gas
    // Savings: 40,000 gas!
}

// Store every transaction: 20,000+ gas each
mapping(uint => Transaction) public transactions;
 
function recordTransaction(uint id, uint amount) public {
    transactions[id] = Transaction(msg.sender, amount, block.timestamp);
}

// Emit event: ~1,500 gas
event TransactionRecorded(uint indexed id, address indexed user, uint amount, uint timestamp);
 
function recordTransaction(uint id, uint amount) public {
    emit TransactionRecorded(id, msg.sender, amount, block.timestamp);
}

const provider = new ethers.JsonRpcProvider("https://evm.wirefluid.com");
const gasPrice = await provider.getGasPrice();
console.log(`Current gas price: ${ethers.formatUnits(gasPrice, "gwei")} Gwei`);

Transaction Fee = Gas Used × Gas Price

Transaction Fee = Gas Used × (Base Fee + Priority Fee)

1. Click the pending transaction
2. Click "Speed Up"
3. Set higher gas price
4. Confirm

1. Transaction was included in block
2. Code executed but hit an error
3. Validator work was done (deserves payment)
4. You pay for gas used, even if it failed

// Reset your MetaMask nonce
Settings → Advanced → Reset Account
 
// Or get current nonce programmatically
const nonce = await provider.getTransactionCount(address, "pending");