How to write an Ethereum smart contract? Ethereum smart contract example

Ethereum smart contracts are self-executing agreements written in code, automatically enforcing terms when conditions are met.

Jun 15, 2025 at 11:56 pm

Understanding Ethereum Smart Contracts

Ethereum smart contracts are self-executing contracts with the terms of the agreement directly written into lines of code. These contracts run on the Ethereum Virtual Machine (EVM) and automatically execute when predetermined conditions are met. Writing a smart contract involves using specific programming languages such as Solidity, which is the most commonly used language for Ethereum development.

Smart contracts are immutable once deployed, meaning that they cannot be altered after being published to the blockchain. This characteristic makes it crucial to ensure that the code is thoroughly tested before deployment. Developers must also consider gas costs, function visibility, and security best practices when writing smart contracts.

Setting Up Your Development Environment

Before diving into writing an Ethereum smart contract, you need to set up a proper development environment. Here's how:

• Install Node.js and npm if not already installed.
• Use npm to install Truffle, a popular Ethereum development framework:
  npm install -g truffle
• Install Ganache, a personal blockchain for Ethereum development, to simulate transactions and test your contracts locally.
• Set up MetaMask, a browser extension wallet, to interact with your deployed contracts on testnets or mainnet.
• Choose a code editor like Visual Studio Code and install Solidity extensions for syntax highlighting and error detection.

Once these tools are in place, you can begin writing and testing your smart contract.

Writing Your First Smart Contract in Solidity

Let’s create a simple storage contract that stores and retrieves a number. Below is a basic example written in Solidity:

pragma solidity ^0.8.0;
contract SimpleStorage {
uint storedData;

function set(uint x) public {
    storedData = x;
}

function get() public view returns (uint) {
    return storedData;
}
}

In this example:

• The pragma solidity ^0.8.0; line specifies the version of Solidity used.
• A state variable storedData is declared to hold an unsigned integer.
• The set() function allows anyone to update the value of storedData.
• The get() function is a view function that returns the current value without modifying the contract state.

Each function and variable should be clearly defined with appropriate visibility modifiers like public, private, or internal.

Compiling and Deploying the Smart Contract

To compile and deploy the above contract using Truffle and Ganache, follow these steps:

• Create a new Truffle project:
  truffle init

• Place the Solidity file inside the contracts directory.

• In the migrations folder, create a migration script (e.g., 2_deploy_contracts.js) with the following content:

  const SimpleStorage = artifacts.require("SimpleStorage");
  module.exports = function(deployer) {
    deployer.deploy(SimpleStorage);
  };

• Compile the contract:
  truffle compile

• Start Ganache and configure the network settings in truffle-config.js.

• Deploy the contract to the local blockchain:
  truffle migrate

After deployment, you can interact with the contract using Truffle Console or via web3.js or ethers.js libraries in a frontend application.

Testing the Smart Contract

Testing ensures that your contract behaves as expected under various scenarios. Truffle provides built-in support for unit testing using JavaScript or Solidity itself.

Here’s an example of a JavaScript-based test located in the test directory:

const SimpleStorage = artifacts.require("SimpleStorage");
contract("SimpleStorage", accounts => {
  it("should store the value 42", async () => {
const instance = await SimpleStorage.deployed();
await instance.set(42, { from: accounts[0] });
const result = await instance.get.call();
assert.equal(result, 42);
});
});

This test:

• Deploys the contract instance.
• Calls the set() function with the value 42.
• Uses assert to verify that the stored value matches the expected output.

Always write tests for edge cases, especially when dealing with complex logic, access control, or financial operations.

Frequently Asked Questions

Q: What tools do I need besides Truffle for Ethereum smart contract development?

You can use Hardhat as an alternative to Truffle for compiling, deploying, and testing contracts. Additionally, Remix IDE is a browser-based tool ideal for beginners who want to write and test small contracts quickly without setting up a local environment.

Q: Can I modify a deployed Ethereum smart contract?

No, Ethereum smart contracts are immutable once deployed. If changes are needed, developers must deploy a new version of the contract and migrate data if necessary. However, patterns like proxy contracts can be used to achieve upgradeable behavior.

Q: How much does it cost to deploy a smart contract on Ethereum?

The cost depends on the complexity of the contract and the current gas price on the network. You can estimate gas costs using tools like Remix IDE or by checking the transaction details in MetaMask during deployment. More complex contracts consume more gas and therefore cost more.

Q: Is it safe to write my own smart contract for production use?

While learning to write smart contracts is valuable, deploying them in production requires thorough security audits and extensive testing. It is recommended to follow best practices, use well-established libraries like OpenZeppelin, and consult experienced auditors before launching any contract handling real funds.