A sleek solidity cheatsheet

AtharvSan — Sun, 30 Mar 2025 08:03:45 +0000

part 1 of a 5 part series on essentials for solidity devs

solidity_cheatsheet.sol
cryptography_cheatsheet.sol
assembly_cheatsheet.sol
designPatterns_cheatsheet.sol
security_cheatsheet.sol

It compiles! Get the full cheatsheet here. Drop a star if you find this useful, it will motivate me to do more of it.

basics
- license
- pragma
- imports
- contract
- events
- constructor
- receive
- modifier
- functions
- symbols
- variables
- control sturctures
- units
- block
- msg
- tx
intermediate
- OOPs
- library
- custom errors
- fallback
- variable passing
- value types
- reference types
- type conversion
- datatype builtins
- fringe arithmetic
advanced
- function signatures and selectors
- abi encoding
- low level calls
- error handling
- bit operations
- bitmasking

license

copyleft:
- ensure that the software is free and open-source even in its derivative versions
- you use this when you do open source software and don't want to let someone else make it proprietary
- examples: GNU General Public License v3.0 (GPL-3.0)
permissive:
- allows the software to be used in proprietary software
- you use this when you want maximum adoption with minimal legal overhead
- examples: MIT, Apache-2.0, BSD-3-Clause
implementaion: SPDX-License-Identifier: licence
- Software Package Data Exchange (SPDX)
- this licence declaration is directly included in the source code as a commment

// SPDX-License-Identifier : GPL-3.0

pragma

^version: means versions above this but below breaking changes version
nothing before the version means just that one version

pragma solidity ^0.8.20;

imports

import "filename";
- imports everything from that file
import {symbol1, symbol2} from "filename";
- imports only the mentioned items
import {symbol1 as alias1, symbol2 as alias2} from "filename";

import "@openzeppelin/token/ERC20/utils/SafeERC20.sol";

OOPs

problem : large codebases are hard to manage
solution : structure code into smaller packets.
implementation
- components: class, object, method, variables
- is: inherits contracts
  - contract A is B,C,D : B is most base, D is most derived
  - C3 linearization right to left(D to B) to resolve conflicts in inheritance
- constructor: order of execution from most base to most derived (B to D)
- visibility: public, internal, private, external
- abstract: when a function is missing definition
- super: call parent class definition
- this: the contract itself in which 'this' is invoked(contract type)
- virtual and override: manage polymorphism
properties
- encapsulation: bundling everything to form a fully working entity
- abstraction: only expose what is required, rest is kept enclosed
- inheritance: acquiring properties from parents
- polymorphism: The ability to take multiple forms (method overloading & method overriding)
pros :
- Code Reusability
- Modularity
- Security & Data Hiding
- Easy Maintenance & Scalability
trivia:
- C3 linearization to resolve inheritance conflicts: inheritance from right to left in the 'is' statement

library

implementation
- cannot have state variables
- functions in library to have the first parameter as the 'datatype' on which to attach the library
libraries can be used in two methods
- using library for type : attaches library functions to the type
- library.method
trivia:
- cannot inherit, nor be inherited
- inheritance doesnt bring using for statement from parent to child, need to write using for again in child.
- cannot recieve ether
- deployment:
  - libraries are deployed only when it contains external functions and called by delegatecall
  - else its code is embedded into the calling contract at compile time
- the calling convention is designed like internal call not following the abi standard

using SafeERC20 for IERC20;

events

has normal params and indexed params(for quick searches)
indexed topics are capped at max 3
trivia:
- Event logs are stored on blockchain but not accessible from within contracts not even from the contract that created them
- indexed are special params included in a seperate place called topics
- 'indexed' arguments make it easy for searching and filtering through the logs

event Log(string message);
event newOwner(address indexed owner);

custom errors

Cheaper gas costs (saves storage compared to string messages)
More structured error messages.
implementation
- error certain_edge_case_messing_up();
- error certain_edge_case_messing_up_explained_with_args(args);
- revert certain_edge_case_messing_up();
- revert certain_edge_case_messing_up_explained_with_args(args);

error amount_smaller_than_100(uint256 amount);
function custom_error(uint256 amount) public pure {
    if (amount< 100) {
        revert amount_smaller_than_100(amount);
    }
}

constructor

executes once during deployment
can recieve ether during deployment
its runtime code, not part of the contract
constructor execution order: B -> C -> solidity_cheatsheet
- most base to most derived

constructor(/* args1, args2 */) /* B(args1) C(args2) */ payable {
    wingman = new Wingman();
    owner = msg.sender;
    emit newOwner(owner);
}

fallback

called when the contract is invoked with calldata, but function definition is absent
this function has builtin definition and its very strict, only two variations allowed
fallback() external [payable] {}
fallback(bytes calldata input) external [payable] returns(bytes memory) {}
trivia:
- does not have a function signature

fallback(bytes calldata _shipment) external payable returns(bytes memory){ 
    string memory payload = abi.decode(_shipment,(string));
    return bytes(string.concat(payload, "_done"));
}

receive

this function is called when the contract is invoked without calldata
main purpose is to receive ETH
this function has builtin definition, only one variation allowed
receive() external payable {}
its mostly kept empty
trivia:
- does not have a function signature

receive() external payable {}

modifier

a piece of code that generally contains some checks and is placed on top of a function
modifiers can accept arguments
function body represented by _ it can be included multiple times.
Modifiers wrap around the function body using the special placeholder _ When multiple modifiers are applied, they execute in a nested manner:
The first modifier runs until it reaches _.
Control moves to the next modifier in the order they are listed.
This continues until the function itself executes.
Once the function completes, execution unwinds back up through the modifiers.

modifier onlyOwner() {
    require(msg.sender == owner, "only owner can call this function");
    _;
}
modifier single_digit_value(uint256 _value) {
    require(_value < 10, "value should be less than 10");
    _;
}
function onlyOwnerFunction(uint256 value) view public onlyOwner single_digit_value(value) returns(string memory) {
    return "greetings to the owner";
}

functions

return variables can be used as any other local variable.
members: .selector
return: concludes the function execution generally returns some value.

symbols

() --> functions, mapping, typecasting
{} --> function blocks, struct blocks, conditional blocks, loop blocks
[] --> arrays
; --> end of statement
: --> key value pair, array slicing, ternary operator
, --> seperator
. --> access
- --> subtraction
+ --> addition
* --> multiplication
/ --> division
% --> modulo
** --> power
|| --> or
&& --> and
| --> bitwise or
& --> bitwise and
! --> not
~ --> bitwise not
^ --> bitwise xor
<< --> left shift
>> --> right shift
== --> equal
!= --> not equal
< --> less than
> --> greater than
<= --> less than or equal
>= --> greater than or equal
= --> assignment
+= --> addition assignment
_ --> integer filler
"" --> string
'' --> string
\ --> escape character
// --> single line comment
/// --> natspec comment
/* */ --> multi line comment
/** */ --> multi line natspec comment

variables

life cycle of a variable
- definition
- declaration
- assignment
- access
attributes
- interpretation
- size
- type
- data location
- slot position
- behaviour
- visibility
- name
- value

variable passing

pass by value: value copy pasted to new location, new variable (copy paste)
pass by reference:
- pass in same data location: nothing is copy pasted, instead a new name is given to the same location value pair (renaming)
- pass in different data location: pass by value
| value |
|-----------|
| location |

name1

data location

bit level architecture, data location, inline assembly and gas costs covered in assembly cheatsheet.
--- memory ---

structure : byte addressable array that reads and writes on 32 byte words
trivia
- locally available, function scoped
- temporary existence, only for duration of tx
- cheap

--- storage ---

structure
- mapping of 32-byte keys(storage-slots) to a 32-byte values
- storage slots start at slot 0
trivia
- globally avilable
- permanent existance
- expensive

--- calldata ---
samae as memory, but its read only

DEV Community: AtharvSan