Types, Mappings and Structs

Solidity's type system

Value types include bool, uint256 (unsigned integers in sizes from uint8 to uint256, in steps of 8 bits; uint is an alias for uint256), int256 (signed), address (20 bytes) and address payable (can receive ether), fixed-size bytes1 to bytes32, and enums. Solidity has no floating point: represent fractional values as integers with a fixed number of decimals (tokens typically use 18, so 1.5 tokens is 1.5e18). Reference types are arrays (fixed uint[3] or dynamic uint[]), bytes and string (dynamic), structs and mappings. A mapping(address => uint256) is a hash table where every possible key exists with a default zero value; mappings cannot be iterated or have their length taken, so track keys separately if needed. Since Solidity 0.8, arithmetic is checked: overflow and underflow revert automatically; use an unchecked { ... } block only when you have proven overflow impossible, to save gas. Integer division truncates, so multiply before dividing to preserve precision. Constants (constant) and immutable variables are embedded in bytecode and cost no storage reads.

Types in a simple token-like ledger

Mappings, structs, enums and fixed-point arithmetic.

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

contract Ledger {
    enum Tier { Basic, Silver, Gold }

    struct Member {
        Tier tier;
        uint64 joinedAt;
        bool active;
    }

    uint8 public constant DECIMALS = 18;
    uint256 public constant FEE_BPS = 250;                 // 2.5% in basis points

    mapping(address => uint256) public balanceOf;         // default value 0 for every address
    mapping(address => Member) public members;
    mapping(address => mapping(address => uint256)) public allowance;   // nested mapping

    function join(Tier tier) external {
        members[msg.sender] = Member({tier: tier, joinedAt: uint64(block.timestamp), active: true});
    }

    function feeFor(uint256 amount) public pure returns (uint256) {
        return (amount * FEE_BPS) / 10_000;               // multiply first, then divide
    }

    function credit(address to, uint256 wholeTokens) external {
        balanceOf[to] += wholeTokens * 10 ** DECIMALS;     // reverts on overflow (0.8+)
    }

    function sumFirst(uint256[] calldata values, uint256 n) external pure returns (uint256 total) {
        for (uint256 i = 0; i < n && i < values.length; ) {
            total += values[i];
            unchecked { ++i; }                             // i cannot overflow here
        }
    }
}

Paise, not rupees

Without decimals, Solidity is like a till that only counts paise. To represent Rs 1.50 you store 150 paise; tokens do the same with 18 decimal places, so every amount is a whole number of the smallest unit.

त्वरित जाँच: What happens in Solidity 0.8+ when a uint256 subtraction would go below zero?

• It wraps around to a huge number
• The transaction reverts
• It returns zero
• It becomes negative