Solidity 0.6.12 & Vyper 0.2.3 Cheat Sheet

$ solc --version
Version: 0.6.12

$ vyper --version
0.2.3

Solidity loosely borrows its syntax from Javascript and C

Vyper syntax is valid Python 3 syntax (but the opposite is not true)

{ }

:  # Vyper uses Python's off-side rule

;

'\n' and :

// comment

# comment

/* multiple line
comment */

# Multiple line
# comment

uint constant TOTAL_SUPPLY = 10000000;

TOTAL_SUPPLY: constant(uint256) = 10000000

v = 1;

v = 1

(x, y) = (0, 1);

Tuple to tuple assignment not supported

(x, y) = (y, x);

-=, *=, /=, %=, |=, &=, ^=

-=, *=, /=, %=, |=, &=, ^=

i++, ++i, i--, --i

i += 1, i -= 1

null doesn't exist in Solidity but any unitialized variables take a default value represented by 0 in memory

null doesn't exist in Vyper but any unitialized variables take a default value represented by 0 in memory

delete v // doesn't work with mappings

v = empty(uint256)

v == 0

v == 0

x > 0 ? x : -x

Conditional expression not supported

Contract c = new Contract(args);

Contract c = new Contract{value: amount}(args);

Contract c = new Contract{salt: salt}(args);

contract: address = create_forwarder_to(other_contract, value)

selfdestruct(refundAddr)

selfdestruct(refund_addr)

interface HelloWorld {
    function hello() external pure;
    function world(int) external pure;
}

interface HelloWorld:
    def hello(): nonpayable
    def world(uint256): nonpayable

interface HelloWorldWithEvent {
    event Event();
    function hello() external pure;
    function world(int) external pure;
}

contract Test {
    bytes4 public hello_world_with_event = type(HelloWorldWithEvent).interfaceId;
}

true false

True False

false

False

&& || !

and or not

== != < > <= =>

== != < > <= =>

max(x, y)

+ - * / % ** unary-

+ - * / % ** unary-

/

/

<< >> & | ^ ~

<< >> & | ^ ~

uint x = 0x52
string memory s = hex"52"

a: address= 0x14d465376c051Cbcd80Aa2d35Fd5df9910f80543
b: Bytes[32]= b'\x01\x02\x03\x04\x05\x06... (32 bytes)
d: Bytes[1] = 0b00010001

string

String[N]  # N is a fixed number

bytes  // dynamic
bytes1, bytes2, ..., bytes32  // packed
bytes[N]  // N is a fixed number, unpacked

Bytes[N]  # N is a fixed number

"don't \"no\""
'don"t \'no\''

"don't \"no\""
'don"t \'no\''

bytes(s).length

len(s)

\<newline> (escapes an actual newline)
\\ (backslash)
\' (single quote)
\" (double quote)
\b (backspace)
\f (form feed)
\n (newline)
\r (carriage return)
\t (tab)
\v (vertical tab)
\xNN (hex escape)
\uNNNN (unicode escape)

\<newline> (escapes an actual newline)
\\ (backslash)
\' (single quote)
\" (double quote)
\a (bell)
\b (backspace)
\f (form feed)
\n (newline)
\r (carriage return)
\t (tab)
\v (vertical tab)
\ooo (octal escape)
\xNN (hex escape)
\uNNNN (unicode escape)
\uNNNNNNNN (unicode escape)

Yes

Yes

abi.decode(_payload[:4], (bytes4))
// array slices only implemented for calldata arrays

slice(x, _start, _len)

keccak256(abi.encodePacked(s1)) == keccak256(abi.encodePacked(s2))

keccak256(s1) == keccak256(s2)

abi.encodePacked(s1, s2)

concat(s1, s2)

[1, 2, 3]

[1, 2, 3]

a.length

len(a)

a.length == 0

a[0]

a[0]

a[0] = 1;

a[0] = 1

Failing assertion

Failing assertion

a.push(3);  # Dynamic arrays

a.pop();  # Dynamic arrays

struct Pair {
    uint x;
    uint y;
}  // Creating a struct

Pair memory pair = Pair(2, 3);  // Instantiating a struct variable
require(pair.y > pair.x);  // Accessing elements

struct Pair:
    x: uint256
    y: uint256  # Creating a struct

pair: Pair = Pair({x: 2, y: 3})  # Instantiating a struct variable
assert pair.y > pair.x  # Accessing elements

Impossible to know

Impossible to know

m[2]

m[2]

m[2] = 1;

m[2] = 1

A mapping has no concept of set keys, a mapping always refers to a hashed value that is the same for a given mapping and key

A mapping has no concept of set keys, a mapping always refers to a hashed value that is the same for a given mapping and key

m[2] = 0;

m[2] = empty(uint256)

uint immutable x; // have to be assigned in the constructor

function add2(uint x, uint y) public pure returns (uint) {
    return x + y;
}

@external
def add2(x: uint256, y: uint256) -> uint256:
    return x + y

function first(uint[] calldata x) public pure returns (uint) {
    // this function doesn't copy x to memory
    return x[0];
}

function first(uint[] memory x) public pure returns (uint) {
    // this function first copies x to memory
    return x[0];
}

add2(x, y)

add2(x, y)

c.f{gas: 1000, value: 4 ether}()

c.f()
raw_call(address, data, outsize, gas, value, is_delegate_call)

if (a > 2) {
    ...
else if (a == 0) {
    ...
} else {
    ...
}

if a > 2:
    ...
elif a == 0:
    ...
else:
    ...

for (uint i = 0; i < 3; i++) {
    ...
}

for i in range(3):
    ...

while (a > 0) {
    ...
}

do {
    ...
} while (a > 0);

return x + y;

return x + y

break;

break

continue;

continue

assert(x > y);

assert x > y

require(x > y);

require(false, "revert reason")

raise "revert reason"

interface DataFeed { function getData(address token) external returns (uint value); }

contract FeedConsumer {
    DataFeed feed;
    uint errorCount;
    function rate(address token) public returns (uint value, bool success) {
        // Permanently disable the mechanism if there are
        // more than 10 errors.
        require(errorCount < 10);
        try feed.getData(token) returns (uint v) {
            return (v, true);
        } catch Error(string memory /*reason*/) {
            // This is executed in case
            // revert was called inside getData
            // and a reason string was provided.
            errorCount++;
            return (0, false);
        } catch (bytes memory /*lowLevelData*/) {
            // This is executed in case revert() was used
            // or there was a failing assertion, division
            // by zero, etc. inside getData.
            errorCount++;
            return (0, false);
        }
    }
}

NatSpec conventions for functions:

/// @author Mary A. Botanist
/// @notice Calculate tree age in years, rounded up, for live trees
/// @dev The Alexandr N. Tetearing algorithm could increase precision
/// @param rings The number of rings from dendrochronological sample
/// @return age in years, rounded up for partial years

Events:

/// The address `participant` just registered for the gathering.
event Registered(address participant);

Special inheritance syntax for contracts:

/// @inheritdoc OtherContract

def foo():
    """
    @author Mary A. Botanist
    @notice Calculate tree age in years, rounded up, for live trees
    @dev The Alexandr N. Tetearing algorithm could increase precision
    @param rings The number of rings from dendrochronological sample
    @return age in years, rounded up for partial years
    """
    ...

address.transfer()

send(address, value)

address.send()

address.call.value().gas()()

raw_call(address, data, outsize, gas, value, is_delegate_call)

event Deposit(
    address indexed _from,
    bytes32 indexed _id,
    uint _value
);

emit Deposit(msg.sender, _id, msg.value);

event Deposit:
    _from: indexed(address)
    _id: indexed(bytes32)
    _value: uint256

log Deposit(msg.sender, _id, msg.value)

1 ether
1 finney
1 szabo
1 wei
1 gwei
1 seconds
1 minutes
1 hours
1 days
1 weeks
1 years  // deprecated
type(uint).min
type(uint).max
type(int8).min
type(int8).max
...

ZERO_ADDRESS
as_wei_value(1, "finney")
as_wei_value(1, "szabo")
as_wei_value(1, "wei")
as_wei_value(1, "babbage")
as_wei_value(1, "shannon")
EMPTY_BYTES32
MAX_INT128
MIN_INT128
MAX_DECIMAL
MIN_DECIMAL
MAX_UINT256
ZERO_WEI

blockhash(blockNumber)
block.coinbase
block.difficulty
block.gaslimit
block.number

block.timestamp
now  // alias for block.timestamp
gasleft()
msg.data
msg.gas
msg.sender
msg.sig
msg.value
tx.gasprice
tx.origin

blockhash(blockNumber)
block.coinbase
block.difficulty

block.number
block.prevhash  # Same as blockhash(block.number - 1)
block.timestamp



msg.gas
msg.sender

msg.value

tx.origin