Statute of Limitations Reference

bool

Boolean type, true or false.

bool public myBool = true;

uint / int

Unsigned and signed integers. uint is alias for uint256 (8 to 256 bits in steps of 8).

uint256 public count = 0;
int256 public balance = -1;

address

Holds a 20-byte Ethereum address. payable variant can receive Ether.

address public owner = msg.sender;
address payable recipient;

bytes / string

Fixed-size byte arrays (bytes1..bytes32) and dynamic string type.

bytes32 public data;
string public name = "hello";

enum

User-defined type with a finite set of constant values.

enum Status { Active, Paused, Stopped }
Status public status = Status.Active;

array

Dynamic and fixed-size arrays. Supports push, pop, length.

uint[] public dynamicArr;
uint[5] public fixedArr;

mapping

Hash table mapping keys to values. Cannot be iterated.

mapping(address => uint) public balances;

struct

Custom composite type grouping variables together.

struct User {
  address addr;
  uint balance;
}

function

Basic function declaration with visibility, mutability, and return type.

function foo(uint x) public pure returns (uint) {
  return x * 2;
}

view / pure

view reads state but does not modify. pure neither reads nor modifies state.

function getVal() public view returns (uint) { ... }
function calc(uint a) public pure returns (uint) { ... }

payable

Functions that can receive Ether. Access amount via msg.value.

function deposit() public payable {
  // msg.value available
}

receive / fallback

receive is called on plain Ether transfers. fallback handles unknown function calls.

receive() external payable { }
fallback() external payable { }

constructor

Runs once on contract deployment. Cannot be called afterward.

constructor(uint _val) {
  owner = msg.sender;
}

modifier

Reusable precondition checks. _; marks where function body runs.

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

Visibility

public: accessible everywhere. private: current contract only. internal: current + derived. external: only from outside.

public / private / internal / external

event

Logs stored on blockchain. indexed params are searchable. Up to 3 indexed.

event Transfer(address indexed from, address indexed to, uint amount);
emit Transfer(msg.sender, to, amount);

error / require / revert

Custom errors (0.8.4+). require for inline checks. revert for explicit abort.

error InsufficientBalance(uint available, uint required);
require(bal >= amt, "Low balance");
revert InsufficientBalance(bal, amt);

inheritance

Single and multiple inheritance. Use virtual/override for polymorphism.

contract Child is Parent {
  function foo() public override { ... }
}

interface

Abstract contract with no implementation. All functions external.

interface IERC20 {
  function totalSupply() external view returns (uint);
}

abstract

Contract with at least one unimplemented function.

abstract contract Base {
  function foo() public virtual;
}

library

Stateless reusable code. Cannot hold state or receive Ether.

library SafeMath {
  function add(uint a, uint b) internal pure returns (uint) { ... }
}
using SafeMath for uint;

msg

Properties of the current message call.

msg.sender  // caller address
msg.value   // Ether sent (wei)
msg.data    // calldata bytes

block

Properties of the current block.

block.timestamp  // current block time
block.number     // current block number
block.chainid    // chain ID

tx

Transaction-level properties. Avoid tx.origin for auth.

tx.origin  // original sender
tx.gasprice