Solidity Cheat Sheet

contract HelloWorld {

// The keyword "public" makes variables accessible from outside a contract and creates a function that other contracts or SDKs can call to access the value.

string public message;

// The keyword "private" makes variables only accessible from the contract code itself. It does not mean the data is secret. 

address private owner;

event MessageUpdated(string indexed newMessage);
error NotOwner(address owner, address sender);

// any struct and enum types

modifier onlyOwner {
        if (msg.sender != owner) {
            revert NotOwner(owner, msg.sender);
        }
        _;
}

// A special function only run during the creation of the contract

constructor(string memory initMessage) {

        // Takes a string value and stores the value in the memory data storage area, setting `message` to that value

        message = initMessage;

        // setting owner as contract creator

        owner = msg.sender;
}

// An externally accessible function that takes a string as a parameter and updates `message` only for the defined owner.

function update(string memory newMessage) external onlyOwner {
        message = newMessage;
        emit MessageUpdated(newMessage);
    }
}

(bool success,) = myAddr.call{value: 1 ether}("");
require(success, "Transfer failed");

mapping(KeyType => ValueType) public myMappingName;
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) private _approvals;

Set value: balances[myAddr] = 42;
Read value: balances[myAddr];

struct Deposit {
  address depositor;
  uint256 amount;
}

Deposit memory deposit;
Deposit public deposit;
deposit = Deposit({ depositor: msg.sender, amount: msg.value });
deposit2 = Deposit(0xa193…, 200);

Read value: deposit.depositor;
Set value: deposit.amount = 23;

enum Colors { Red, Blue, Green };
Color color = Colors.Red;

uint8[] public myStateArray;
uint8[] public myStateArray = [1, 2, 3];
uint8[3] public myStateArray  = [1, 2, 3];
uint8[] memory myMemoryArray = new uint8[](3);
uint8[3] memory myMemoryArray = [1, 2, 3];

myStateArray.length;

myStateArray.push(3);
myStateArray.pop();

function functionName([arg1, arg2...]) [public|external|internal|private] [view|pure] [payable] [modifier1, modifier2, ...] [returns([arg1, arg2, ...])] { … }
function setBalance(uint256 newBalance) external { ... }
function getBalance() view external returns(uint256 balance) { ... }
function _helperFunction() private returns(uint256 myNumber) { ... }

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

function changeOwner(address newOwner) external onlyOwner {
  owner = newOwner;
}

contract MyContract {
    // executed when called with empty data, must be external and payable
    receive() external payable {}

    // executed when no other function matches, must be external, can be payable
    fallback() external {}
}

contract MyContract {
    uint256 public balance;
    constructor(uint256 initialBalance) { balance = initialBalance; }
    function setBalance(uint256 newBalance) external { balance = newBalance; }
}

contract MyAncestorContract2 {
    function myFunction() external virtual { … }
}

contract MyAncestorContract1 is MyAncestorContract2 {
    function myFunction() external virtual override { … }
}

contract MyContract is MyAncestorContract1 {
    function myFunction() external override(MyAncestorContract1, MyAncestorContract2) { … }
}

abstract contract MyAbstractContract {
 function myImplementedFunction() external { … }
 function myNonImplementedFunction() external virtual; // must be virtual
}

interface MyInterface {
 function myNonImplementedFunction() external; // always virtual, no need to declare specifically
}

library Math {
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a > b) { return b; }
        return a;
    }

  function max(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a < b) { return b; }
        return a;
    }
}

contract MyContract {
    function min(uint256 a, uint256) public pure returns (uint256) {
        return Math.min(a,b);
    }

    function max(uint256 x) public pure returns (uint256) {
        return Math.max(a,b);
    }
}

// Using LibraryName for type:

library Math {
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

contract MyContract {
    using Math for uint256;
    function ceilDiv(uint256 a, uint256) public pure returns (uint256) {
        return x.ceilDiv(y);
    }
}

contract MyContract {
    event Deposit(
        address indexed depositor,
        uint256 amount
    );

    function deposit() external payable {
        emit Deposit(msg.sender, msg.value);
        …
    }
}

contract CheckedUncheckedTests {
    function checkedAdd() pure public returns (uint256) {
        return type(uint256).max + 1; // reverts
    }

    function checkedSub() pure public returns (uint256) {
        return type(uint256).min - 1; // reverts
    } 

    function uncheckedAdd() pure public returns (uint256) {
        // doesn’t revert, but overflows and returns 0
        unchecked { return type(uint256).max + 1; } 
    }

    function uncheckedSub() pure public returns (uint256) {
        // doesn’t revert, but underflows and returns 2^256-1
        unchecked { return type(uint256).min - 1; }
    }
}

type FixedPoint is uint256

library FixedPointMath {
    uint256 constant MULTIPLIER = 10**18;

    function add(FixedPoint a, FixedPoint b) internal pure returns (UFixed256x18) {
        return FixedPoint.wrap(FixedPoint.unwrap(a) + FixedPoint.unwrap(b));
    }

    function mul(FixedPoint a, uint256 b) internal pure returns (FixedPoint) {
        return FixedPoint.wrap(FixedPoint.unwrap(a) * b);
    }

   function mulFixedPoint(uint256 number, FixedPoint fixedPoint) internal pure returns (uint256) {
        return (number * FixedPoint.unwrap(fixedPoint)) / MULTIPLIER;
    }

    function divFixedPoint(uint256 number, FixedPoint fixedPoint) internal pure returns (uint256) {
        return (number * MULTIPLIER) / Wad.unwrap(fixedPoint);
    }

    function fromFraction(uint256 numerator, uint256 denominator) internal pure returns (FixedPoint) {
      if (numerator == 0) {
        return FixedPoint.wrap(0);
      }

      return FixedPoint.wrap((numerator * MULTIPLIER) / denominator);
    }
}

error InsufficientBalance(uint256 available, uint256 required)

function transfer(address to, uint256 amount) public {
    if (amount > balance[msg.sender]) {
        revert InsufficientBalance({
            available: balance[msg.sender],
            required: amount
        });
    }

    balance[msg.sender] -= amount;
    balance[to] += amount;
}