← Back to AERE Academy

Deploy Your First Smart Contract

Module 1, Solidity Basics

Solidity is the most widely used language for writing smart contracts on EVM chains. A Solidity file is compiled to EVM bytecode and deployed on-chain, where it runs exactly as written, no one can alter it after deployment, and it executes identically on every node.

Contract structure

Every Solidity file starts with a pragma directive specifying the compiler version, then defines one or more contract blocks. Inside a contract you declare state variables (stored permanently on-chain), functions, events, and modifiers.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract HelloAERE {
    // State variable, stored on the blockchain
    string public greeting = "Hello, AERE Network!";

    // Function to update the greeting
    function setGreeting(string calldata _msg) external {
        greeting = _msg;
    }
}

Key concepts

• State variables are stored in contract storage, reading is free, writing costs gas.
• Functions marked view or pure only read state; they cost no gas when called off-chain.
• Events are cheap on-chain logs your front-end can listen for with ethers.js or the indexer API.
• Visibility: public (callable by anyone), external (only from outside the contract), internal (this contract + inheritors), private (this contract only).

Module 2, Setting Up Remix IDE

Remix is a browser-based Solidity IDE, no installation required. It handles compilation, deployment, and interaction with your contracts directly from the browser.

Module 3, Connecting MetaMask to AERE

Remix can deploy contracts via MetaMask. You need MetaMask installed and connected to AERE Network (chain ID 2800) before you deploy.

Module 4, Simple Storage Contract

Let's deploy a real contract. Copy the following into SimpleStorage.sol in Remix:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title SimpleStorage
 * @notice Stores and retrieves a single uint256 value on AERE Network.
 */
contract SimpleStorage {
    uint256 private _value;

    // Emitted whenever the stored value changes
    event ValueChanged(address indexed caller, uint256 newValue);

    /// @notice Write a new value to storage
    function store(uint256 value) external {
        _value = value;
        emit ValueChanged(msg.sender, value);
    }

    /// @notice Read the stored value (free, no gas)
    function retrieve() external view returns (uint256) {
        return _value;
    }
}

Compile it (Ctrl+S), then in the Deploy panel click Deploy. MetaMask will pop up, confirm the transaction. Within ~1 second (AERE's block time), the contract is deployed. You will see its address in the "Deployed Contracts" list at the bottom of the Deploy panel.

Click the deployed contract to expand it. Try calling store with a number, then retrieve to read it back. Each store call sends an on-chain transaction; each retrieve is a free local call.

Module 5, Writing and Deploying an ERC-20 Token

ERC-20 is the standard interface for fungible tokens on EVM chains. It defines a set of functions (transfer, approve, transferFrom, balanceOf, etc.) that wallets and exchanges know how to interact with automatically.

Create a new file MyToken.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title MyToken
 * @notice A minimal ERC-20 token deployed on AERE Network.
 *         1,000,000 tokens minted to the deployer on construction.
 */
contract MyToken {
    string  public name;
    string  public symbol;
    uint8   public constant decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    constructor(string memory _name, string memory _symbol) {
        name = _name;
        symbol = _symbol;
        uint256 initialSupply = 1_000_000 * 10 ** decimals;
        totalSupply = initialSupply;
        balanceOf[msg.sender] = initialSupply;
        emit Transfer(address(0), msg.sender, initialSupply);
    }

    function transfer(address to, uint256 value) external returns (bool) {
        require(balanceOf[msg.sender] >= value, "Insufficient balance");
        balanceOf[msg.sender] -= value;
        balanceOf[to] += value;
        emit Transfer(msg.sender, to, value);
        return true;
    }

    function approve(address spender, uint256 value) external returns (bool) {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) external returns (bool) {
        require(balanceOf[from] >= value, "Insufficient balance");
        require(allowance[from][msg.sender] >= value, "Allowance exceeded");
        allowance[from][msg.sender] -= value;
        balanceOf[from] -= value;
        balanceOf[to] += value;
        emit Transfer(from, to, value);
        return true;
    }
}

In Remix, compile MyToken.sol. In the Deploy panel you will see a constructor with two inputs, enter your token name (e.g. My Token) and symbol (e.g. MTK), then click Deploy and confirm in MetaMask. After one block, your token contract is live on AERE mainnet.

Module 6, Verifying on the Block Explorer

Verifying a contract means uploading the Solidity source code to the block explorer so that anyone can read exactly what the contract does. Verified contracts also become callable directly from the explorer's UI.

Find your deployed contract

After deploying, copy the contract address from Remix's "Deployed Contracts" section. Open explorer.aere.network and paste the address into the search bar. You will see the contract's transaction history and, under the "Contract" tab, the raw bytecode.

Submit source for verification

1. On the contract page, click the Contract tab, then Verify & Publish.
2. Select: Compiler type → Solidity (Single file), Compiler version → 0.8.20, Open source license → MIT.
3. Paste your full Solidity source into the editor. Make sure the pragma version matches exactly.
4. If you deployed with constructor arguments (like the token name and symbol), the explorer will ask you to provide the ABI-encoded constructor arguments. Remix displays these in its transaction details, copy the hex string beginning after 0x.
5. Click Verify and Publish.

The explorer compiles the source server-side and checks that the resulting bytecode matches what was deployed. If it matches, a green checkmark appears on the contract page, and the ABI is published so anyone can call your functions directly from the browser.

← Back to AERE Academy