Types¶
Vyper is a statically typed language. The type of each variable (state and local) must be specified or at least known at compiletime. Vyper provides several elementary types which can be combined to form complex types.
In addition, types can interact with each other in expressions containing operators.
Value Types¶
The following types are also called value types because variables of these types will always be passed by value, i.e. they are always copied when they are used as function arguments or in assignments.
Boolean¶
Keyword: bool
A boolean is a type to store a logical/truth value.
Values¶
The only possible values are the constants True
and False
.
Operators¶
Operator 
Description 


Logical negation 

Logical conjunction 

Logical disjunction 

Equality 

Inequality 
Shortcircuiting of boolean operators (or
and and
) is consistent with
the behavior of Python.
Signed Integer (256 bit)¶
Keyword: int256
A signed integer (256 bit) is a type to store positive and negative integers.
Values¶
Signed integer values between 2^{255} and (2^{255}  1), inclusive.
Interger literals cannot have a decimal point even if the decimal value is zero. For example, 2.0
cannot be interpreted as an integer.
Operators¶
Comparisons¶
Comparisons return a boolean value.
Operator 
Description 


Less than 

Less than or equal to 

Equals 

Does not equal 

Greater than or equal to 

Greater than 
x
and y
must be of the type int256
.
Arithmetic Operators¶
Operator 
Description 


Addition 

Subtraction 

Unary minus/Negation 

Multiplication 

Division 

Exponentiation 

Modulo 
x
and y
must be of the type int256
.
Signed Integer (128 bit)¶
Keyword: int128
A signed integer (128 bit) is a type to store positive and negative integers.
Values¶
Signed integer values between 2^{127} and (2^{127}  1), inclusive.
Interger literals cannot have a decimal point even if the decimal value is zero. For example, 2.0
cannot be interpreted as an integer.
Operators¶
Comparisons¶
Comparisons return a boolean value.
Operator 
Description 


Less than 

Less than or equal to 

Equals 

Does not equal 

Greater than or equal to 

Greater than 
x
and y
must be of the type int128
.
Arithmetic Operators¶
Operator 
Description 


Addition 

Subtraction 

Unary minus/Negation 

Multiplication 

Division 

Exponentiation 

Modulo 
x
and y
must be of the type int128
.
Unsigned Integer (8 bit)¶
Keyword: uint8
An unsigned integer (8 bit) is a type to store nonnegative integers.
Values¶
Integer values between 0 and (2^{8}1).
Interger literals cannot have a decimal point even if the decimal value is zero. For example, 2.0
cannot be interpreted as an integer.
Note
Integer literals are interpreted as int128
by default. In cases where uint8
is more appropriate, such as assignment, the literal might be interpreted as uint8
. Example: _variable: uint8 = _literal
. In order to explicitly cast a literal to a uint8
use convert(_literal, uint8)
.
Operators¶
Comparisons¶
Comparisons return a boolean value.
Operator 
Description 


Less than 

Less than or equal to 

Equals 

Does not equal 

Greater than or equal to 

Greater than 
x
and y
must be of the type uint8
.
Arithmetic Operators¶
Operator 
Description 


Addition 

Subtraction 

Multiplication 

Division 

Exponentiation 

Modulo 
x
and y
must be of the type uint8
.
Unsigned Integer (256 bit)¶
Keyword: uint256
An unsigned integer (256 bit) is a type to store nonnegative integers.
Values¶
Integer values between 0 and (2^{256}1).
Interger literals cannot have a decimal point even if the decimal value is zero. For example, 2.0
cannot be interpreted as an integer.
Note
Integer literals are interpreted as int128
by default. In cases where uint256
is more appropriate, such as assignment, the literal might be interpreted as uint256
. Example: _variable: uint256 = _literal
. In order to explicitly cast a literal to a uint256
use convert(_literal, uint256)
.
Operators¶
Comparisons¶
Comparisons return a boolean value.
Operator 
Description 


Less than 

Less than or equal to 

Equals 

Does not equal 

Greater than or equal to 

Greater than 
x
and y
must be of the type uint256
.
Arithmetic Operators¶
Operator 
Description 


Addition 

Subtraction 

Multiplication 

Division 

Exponentiation 

Modulo 
x
, y
and z
must be of the type uint256
.
Decimals¶
Keyword: decimal
A decimal is a type to store a decimal fixed point value.
Values¶
A value with a precision of 10 decimal places between 2^{127} and (2^{127}  1).
In order for a literal to be interpreted as decimal
it must include a decimal point.
Operators¶
Comparisons¶
Comparisons return a boolean value.
Operator 
Description 


Less than 

Less or equal 

Equals 

Does not equal 

Greater or equal 

Greater than 
x
and y
must be of the type decimal
.
Arithmetic Operators¶
Operator 
Description 


Addition 

Subtraction 

Unary minus/Negation 

Multiplication 

Division 

Modulo 
x
and y
must be of the type decimal
.
Address¶
Keyword: address
The address type holds an Ethereum address.
Values¶
An address type can hold an Ethereum address which equates to 20 bytes or 160 bits. Address literals must be written in hexadecimal notation with a leading 0x
and must be checksummed.
Members¶
Member 
Type 
Description 



Balance of an address 


Keccak of code at an address, 


Size of code deployed an address, in bytes 


Boolean indicating if a contract is deployed at an address 
Syntax as follows: _address.<member>
, where _address
is of the type address
and <member>
is one of the above keywords.
Note
Operations such as SELFDESTRUCT
and CREATE2
allow for the removal and replacement of bytecode at an address. You should never assume that values of address members will not change in the future.
32bitwide Byte Array¶
Keyword: bytes32
This is a 32bitwide byte array that is otherwise similar to byte arrays.
Example:
# Declaration
hash: bytes32
# Assignment
self.hash = _hash
Operators¶
Keyword 
Description 


Return the keccak256 hash as bytes32. 

Concatenate multiple inputs. 

Return a slice of 
Where x
is a byte array and _start
as well as _len
are integer values.
Byte Arrays¶
Keyword: Bytes
A byte array with a fixed size.
The syntax being Bytes[maxLen]
, where maxLen
is an integer which denotes the maximum number of bytes.
On the ABI level the Fixedsize bytes array is annotated as bytes
.
Bytes literals may be given as bytes strings, hexadecimal, or binary.
bytes_string: Bytes[100] = b"\x01"
hex_bytes: Bytes[100] = 0x01
binary_bytes: Bytes[100] = 0b00000001
Strings¶
Keyword: String
Fixedsize strings can hold strings with equal or fewer characters than the maximum length of the string.
On the ABI level the Fixedsize bytes array is annotated as string
.
example_str: String[100] = "Test String"
Reference Types¶
Reference types do not fit into 32 bytes. Because of this, copying their value is not as feasible as with value types. Therefore only the location, i.e. the reference, of the data is passed.
Fixedsize Lists¶
Fixedsize lists hold a finite number of elements which belong to a specified type.
Lists can be declared with _name: _ValueType[_Integer]
.
# Defining a list
exampleList: int128[3]
# Setting values
exampleList = [10, 11, 12]
exampleList[2] = 42
# Returning a value
return exampleList[0]
Multidimensional lists are also possible. The notation for the declaration is reversed compared to some other languages, but the access notation is not reversed.
A two dimensional list can be declared with _name: _ValueType[inner_size][outer_size]
. Elements can be accessed with _name[outer_index][inner_index]
.
# Defining a list with 2 rows and 5 columns and set all values to 0
exampleList2D: int128[5][2] = empty(int128[5][2])
# Setting a value for row the first row (0) and last column (4)
exampleList2D[0][4] = 42
# Setting values
exampleList2D = [[10, 11, 12, 13, 14], [16, 17, 18, 19, 20]]
# Returning the value in row 0 column 4 (in this case 14)
return exampleList2D[0][4]
Structs¶
Structs are custom defined types that can group several variables.
Struct types can be used inside mappings and arrays. Structs can contain arrays and other structs, but not mappings.
Struct members can be accessed via struct.argname
.
# Defining a struct
struct MyStruct:
value1: int128
value2: decimal
# Declaring a struct variable
exampleStruct: MyStruct = MyStruct({value1: 1, value2: 2.0})
# Accessing a value
exampleStruct.value1 = 1
Mappings¶
Mappings are hash tables that are virtually initialized such that every possible key exists and is mapped to a value whose byterepresentation is all zeros: a type’s default value.
The key data is not stored in a mapping, instead its keccak256
hash used to look up a value. For this reason mappings do not have a length or a concept of a key or value being “set”.
Mapping types are declared as HashMap[_KeyType, _ValueType]
.
_KeyType
can be any base or bytes type. Mappings, interfaces or structs are not support as key types._ValueType
can actually be any type, including mappings.
Note
Mappings are only allowed as state variables.
# Defining a mapping
exampleMapping: HashMap[int128, decimal]
# Accessing a value
exampleMapping[0] = 10.1
Note
Mappings have no concept of length and so cannot be iterated over.
Initial Values¶
Unlike most programming languages, Vyper does not have a concept of null
. Instead, every variable type has a default value. To check if a variable is empty, you must compare it to the default value for it’s given type.
To reset a variable to it’s default value, assign to it the builtin empty()
function which constructs a zero value for that type.
Note
Memory variables must be assigned a value at the time they are declared.
Here you can find a list of all types and default values:
Type 
Default Value 













Note
In Bytes
the array starts with the bytes all set to '\x00'
Note
In reference types all the type’s members are set to their initial values.
Type Conversions¶
All type conversions in Vyper must be made explicitly using the builtin convert(a: atype, btype)
function. Currently, the following type conversions are supported:
In ( 
Out ( 
Allowable Values 
Additional Notes 



All 



All 



All 



All 



All 



All 
Returns 


All 
Value is truncated 



Value is truncated 


All 



All 



All 
Returns 


All 




Cannot convert negative values 


All 



All 



All 
Returns 


All 



All 



All 



All 



All 
Returns 










All 



All 



All 



All 



All 



All 



All 