Let us deploy this contract to Sepolia Testnet using Chrome console.
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract ExecutionExplorer { uint256 public storedValue; address public lastSender; uint256 public callCount; event ValueUpdated(uint256 newValue, address indexed updater); constructor(uint256 initialValue) { storedValue = initialValue; lastSender = msg.sender; callCount = 0; } function updateValue(uint256 newValue) external { storedValue = newValue; lastSender = msg.sender; callCount += 1; emit ValueUpdated(newValue, msg.sender); } function getContractBalance() external view returns (uint256) { return address(this).balance; } receive() external payable {} // Accept ETH } Get the Compiled Bytecode from Remix
If you forget how to get it, please read https://dev.to/rwu_security_researcher/from-source-to-blockchain-how-smart-contracts-go-live-with-remix-and-metamask-25h8
In Chrome Console:
// The Compile Bytecode from remix // const bytecode = "0x608060405234801561000f575f80fd5b506..."; // We need to encode the constructor argument // into 32-byte ABI format. const dummy = 42; let hexString = dummy.toString(16); hexString = hexString.padStart(64, '0'); const constructorArg = hexString; // Combine const deploymentData = bytecode + constructorArg; // Connect to MetaMask await window.ethereum.request({method: 'eth_requestAccounts'}); const accounts = await window.ethereum.request({ method: 'eth_accounts' }); const sender = accounts[0]; // Prepare deployment transaction const txParams = { from: sender, data: deploymentData, gas: '0x2dc6c0' // (optional) 200,000 gas }; // Send transaction const txHash = await window.ethereum.request({ method: 'eth_sendTransaction', params: [txParams], }); console.log("Deployment Transaction Hash:", txHash); MetaMask pops up, asks you to confirm.
This becomes just a pending transaction — floating in the mempool of your network. Validators pick transactions from the mempool to include in the next block after simulating them.
A validator (Proof of Stake) picks up your transaction and simulate the transaction locally using the EVM:
- They run your deploymentData as code in their private EVM simulation.
- If execution succeeds without errors (and gas is sufficient):
- The blockchain engine creates a new contract address.
- The runtime bytecode, i.e. the remix bytecode inside the deploymentData without the argumentData is stored at that address.
- Your storedValue, lastSender, callCount variables are set into storage in the private EVM simulation.
🎯 If anything fails (out of gas, bad opcode, etc.), the whole transaction reverts — nothing is deployed.
After the validator successfully simulates and commits the block:
- The new contract is officially created on-chain.
- Your storedValue is truly set to 42 — and the world agrees on that.
🛠 How to confirm Raw Smart Contract Storage in Chrome Console after the deployment
In Solidity, each public or internal variable is stored in a sequential "slot" in storage.
Slot 0 → first variable (storedValue)
Slot 1 → second variable (lastSender)
Slot 2 → third variable (callCount)
You want to check slot 0.
https://sepolia.etherscan.io/tx/0x37423eaf6aca4e8843fe5efbe62e79ac0e58dfcd47d09c50db0fdf28a2d759ac
const contractAddress = "0x9B45d1AAF6e91C818F416e1D948A24962A26EF7a"; const slot = "0x0"; // Slot 0 for storedValue const result = await window.ethereum.request({ method: "eth_getStorageAt", params: [contractAddress, slot, "latest"], }); console.log("Stored value (raw hex):", result); console.log("Stored value (parsed int):", parseInt(result, 16)); ✅ This reads directly from Ethereum storage at the contract address!
In this walkthrough, we focused on deploying a contract and verifying its initial storage.
In the next article, we'll dive deeper — reading multiple storage slots, checking the contract's balance, and testing how it can receive ETH dynamically.
Top comments (0)