Solidity Cheat Sheet

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

contract HelloWorld {
    string public message = "Hello, World!";
}

pragma solidity ^0.8.0;  // >= 0.8.0 < 0.9.0
pragma solidity 0.8.20;  // Exact version
pragma solidity >=0.8.0 <0.9.0;  // Range

// SPDX-License-Identifier: MIT
// SPDX-License-Identifier: GPL-3.0
// SPDX-License-Identifier: UNLICENSED

// Single line comment

/*
 * Multi-line
 * comment
 */

/// NatSpec documentation

uint256 public count;  // 0 to 2^256-1
int256 public balance;  // -2^255 to 2^255-1
uint8 age;  // 0 to 255
int8 temp;  // -128 to 127

address public owner;
address payable public recipient;

owner = msg.sender;
recipient = payable(msg.sender);

bool public isActive = true;
bool public isPaused = false;

bytes32 public hash;
bytes public data;

hash = keccak256(abi.encodePacked("text"));

string public name = "MyToken";
string public symbol = "MTK";

enum Status { Pending, Active, Completed }
Status public currentStatus = Status.Pending;

contract MyContract {
    uint256 public count;  // Storage
    address private owner;  // Storage
    mapping(address => uint) balances;  // Storage
}

uint public x;     // Accessible externally
uint private y;    // Only this contract
uint internal z;   // This + derived contracts
uint external w;   // Only for functions, not state vars

uint public constant MAX_SUPPLY = 1000000;
address public constant BURN_ADDRESS = address(0);

address public immutable owner;

constructor() {
    owner = msg.sender;  // Set once in constructor
}

function add(uint a, uint b) public pure returns (uint) {
    return a + b;
}

function publicFunc() public { }
function privateFunc() private { }
function internalFunc() internal { }
function externalFunc() external { }

function getBalance() public view returns (uint) {
    return balance;  // Reads state
}

function calculate(uint x) public pure returns (uint) {
    return x * 2;  // No state access
}

function deposit() public payable {
    balance[msg.sender] += msg.value;
}

function getUser() public view returns (string memory, uint) {
    return (name, age);
}

(string memory n, uint a) = getUser();

modifier onlyOwner() {
    require(msg.sender == owner, "Not owner");
    _;
}

function withdraw() public onlyOwner {
    // Only owner can call
}

if (balance >= amount) {
    balance -= amount;
} else {
    revert("Insufficient balance");
}

require(msg.sender == owner, "Not authorized");
require(amount > 0, "Amount must be positive");

assert(balance >= 0);  // Internal error check

if (paused) {
    revert("Contract is paused");
}

for (uint i = 0; i < 10; i++) {
    total += i;
}

uint i = 0;
while (i < 10) {
    sum += i;
    i++;
}

mapping(address => uint) public balances;

balances[msg.sender] = 100;
uint bal = balances[msg.sender];

mapping(address => mapping(address => uint)) public allowances;

allowances[owner][spender] = amount;

uint[] public numbers;

numbers.push(10);
numbers.push(20);
uint first = numbers[0];
uint len = numbers.length;

uint[5] public fixedArray;
address[3] public admins;

numbers.push(30);     // Add to end
numbers.pop();        // Remove last
delete numbers[0];    // Set to 0, doesn't reduce length

event Transfer(address indexed from, address indexed to, uint amount);

emit Transfer(msg.sender, recipient, amount);

event Deposit(address indexed user, uint indexed amount, uint timestamp);

error InsufficientBalance(uint requested, uint available);

if (balance < amount) {
    revert InsufficientBalance(amount, balance);
}

constructor(string memory _name) {
    name = _name;
    owner = msg.sender;
}

contract Parent {
    uint public x;
}

contract Child is Parent {
    function setX(uint _x) public {
        x = _x;
    }
}

interface IERC20 {
    function transfer(address to, uint amount) external returns (bool);
    function balanceOf(address account) external view returns (uint);
}

receive() external payable {
    // Handle plain ETH transfers
}

fallback() external payable {
    // Handle unknown function calls
}