Solidity 0.6.6 & Vyper Beta 17 Cheat Sheet

$ solc --version
Version: 0.6.6

$ vyper --version
0.1.0b17 (0.1.0 Beta 17)

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

clear(v) # doesn't work with mappings

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)

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: bytes32= b'\x01\x02\x03\x04\x05\x06... (32 bytes)
c: bytes32= 0x010203040506... (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

bytes32
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;

clear(m[2])

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

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

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

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:

/// @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

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);

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

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

1 ether
1 finney
1 szabo
1 wei
1 seconds
1 minutes
1 hours
1 days
1 weeks
1 years  // deprecated)

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

time: timestamp
time_diff: timedelta

# define custom units
units: {
    cm: "centimeter",
    km: "kilometer"
}
a: int128(cm)
b: uint256(km)

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