Integers ​

There are two main types of integers in SmartPy:

• signed integers sp.TInt;
• unsigned integers sp.TNat.

The corresponding types in Michelson are

Michelson int

and

Michelson nat

SmartPy also uses a third definition sp.TIntOrNat which stands for integers that are not yet determined as sp.TInt or sp.TNat.

Literals ​

1, 2, 0, -5
Literal of type sp.TIntOrNat when non negative and sp.TInt otherwise.

sp.int(i)
A literal of type sp.TInt when i is a Python integer literal.

sp.nat(n)
A literal of type sp.TNat when n is a non negative Python integer literal.

Example ​

value  = 1          # sp.TIntOrNat
value1 = -1         # sp.TInt
value2 = sp.int(10) # sp.TInt
value3 = sp.nat(20) # sp.TNat

Arithmetic Operations ​

The usual arithmetic operators +, -, *, %, //, <<, >> behave just like in Python.

In SmartPy, type inference of arithmetic operators imposes that both sides have the same type. This constraint can be relaxed by explicitly using sp.to_int.

Addition ​

expr1 + expr2 sp.add(<expr1>, <expr2>) (Overloaded version) Michelson ADD
Add two numerical values, expr1 and expr2.

Example ​

sp.int(1) + sp.int(2) # 3 of type sp.TInt
sp.nat(1) + sp.nat(2) # 3 of type sp.TNat
1 + sp.int(2)         # 3 of type sp.TInt
1 + sp.nat(2)         # 3 of type sp.TNat
1 + 2                 # 3 of type sp.TIntOrNat
sp.add(sp.int(1) + sp.nat(2)) # 3 of type sp.TInt

Subtraction ​

expr1 - expr2 Michelson SUB
Subtract two numerical values, expr1 and expr2.

Example ​

sp.int(1) - sp.int(2) # -1 of type sp.TInt
sp.nat(1) - sp.nat(2) # -1 of type sp.TInt
sp.int(2) - sp.int(1) #  1 of type sp.TInt
sp.nat(2) - sp.nat(1) #  1 of type sp.TInt

Negation ​

- expr Michelson NEG
Negate a numerical value, expr.

Example ​

value = - sp.nat(2) # -2 of type sp.TInt

Multiplication ​

expr1 * expr2, sp.mul(<expr1>, <expr2>) (Overloaded version) Michelson MUL
Multiply two numerical values, expr1 and expr2.

Example ​

value1 = sp.int(2) * sp.int(2) # 4 of type sp.TInt
value2 = sp.nat(2) * sp.nat(2) # 4 of type sp.TNat
value3 = sp.mul(sp.nat(2), sp.int(2)) # 4 of type sp.TInt

Division ​

expr1 % expr2 Michelson EDIV
Perform euclidean division and get the remainder, where expr1 is the dividend, and expr2 is the divisor.

Example ​

remainder = 11 % 2 # 1

Which is an alias of:

remainder = sp.snd(sp.ediv(11, 2).open_some()) # 1

expr1 // expr2 Michelson EDIV
Perform euclidean division and get the quotient, where expr1 is the dividend, and expr2 is the divisor.

Example ​

quotient = 11 // 2 # 5

Which is an alias of:

quotient = sp.fst(sp.ediv(11, 2).open_some()) # 5

sp.ediv(expr1, expr2) Michelson EDIV
Perform euclidean division, where expr1 is the dividend, and expr2 is the divisor.

When expr1 and expr2 are both of type sp.TNat, the returned value is of type sp.TOption(sp.TPair(sp.TNat, sp.TNat)).

In the remaining cases, the returned value is of type sp.TOption(sp.TPair(sp.TInt, sp.TNat)).

The first element of sp.TPair(sp.TInt, sp.TNat) is the quotient, whereas the second element is the remainder.

Example ​

(quotient, remainder) = sp.match_pair(sp.ediv(11, 2).open_some())

Logical Operations ​

Shift ​

expr1 << expr2 Michelson LSL
Logically left shift a natural number.

The operation expects expr1 and expr2 to be of type sp.TNat and to be less than or equal to 256. It produces the first number logically left-shifted by second number, which is of type sp.TNat.

expr1 >> expr2 Michelson LSR
Logically right shift a natural number.

The operation expects expr1 and expr2 to be of type sp.TNat and to be less than or equal to 256. It produces the first number logically right-shifted by second number, which is of type sp.TNat.

Or ​

expr1 | expr2 Michelson OR
Compute bitwise expr1 or expr2 for expr1 and expr2 of type sp.TNat.
Result is also of type sp.TNat.

And ​

expr1 & expr2 Michelson AND
Compute bitwise expr1 and expr2 for expr1 and expr2 of type sp.TNat.
Result is also of type sp.TNat.

Exclusive or ​

expr1 ^ expr2 Michelson XOR
Compute bitwise expr1 xor expr2 for expr1 and expr2 of type sp.TNat.
Result is also of type sp.TNat.

Int / Nat Operations ​

Cast nat to int ​

sp.to_int(n)
Convert a sp.TNat into an sp.TInt. This operation doesn't fail.

Example ​

intValue = sp.to_int(sp.nat(10)) # 10 of type sp.TInt

Michelson INT

Extract nat from int ​

sp.is_nat(i)
Convert a sp.TInt into an sp.TOption(sp.TNat). This operation doesn't fail.

sp.is_nat(i) == sp.some(n) when i is a non negative sp.TInt and sp.none otherwise.

Example ​

intValue = sp.is_nat(i)

sp.as_nat(i)
Convert an sp.TInt into a sp.TNat. This operation fails if not possible with the optional message, i.e., when i is negative.

natValue = sp.as_nat(i, message = None)

It is an alias of sp.is_nat(i).open_some(message = message).

Michelson ISNAT

Absolute value ​

abs(i)
Return the absolute value of i.
abs takes an sp.TInt and returns a sp.TNat.

Example ​

self.data.x = -10
natValue = abs(self.data.x) # equivalent to 10 of type sp.TNat

Michelson ABS