Constants are variables that cannot change.
+# @pragma version ^0.4.0
+
+MY_CONSTANT: constant(uint256) = 123
+MIN: constant(uint256) = 1
+MAX: constant(uint256) = 10
+ADDR: constant(address) = 0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B
+
+@external
+@pure
+def deprecated_constants() -> (address, uint256, bytes32):
+ # 0.3 deprecated constants
+ # return (ZERO_ADDRESS, MAX_UINT256, EMPTY_BYTES32)
+ # 0.4
+ return (empty(address), max_value(uint256), empty(bytes32))
+
+@external
+@pure
+def getMyConstants() -> (uint256, uint256, address):
+ return (MIN, MAX, ADDR)
+__init__ is a special function that is executed only once when the contract is deployed.
# @pragma version ^0.4.0
+
+owner: public(address)
+name: public(String[10])
+createdAt: public(uint256)
+expiresAt: public(uint256)
+
+@deploy
+def __init__(name: String[10], duration: uint256):
+ # set owner to caller
+ self.owner = msg.sender
+ # set name from input
+ self.name = name
+ self.createdAt = block.timestamp
+ self.expiresAt = block.timestamp + duration
+Vyper contracts can deploy new contracts using the function create_forwarder_to.
create_forwarder_to is also known as "minimal proxy contract". How it works, we won't explain it here.
Here we will focus on how to use it to deploy new contracts.
+create_forwarder_toContractToDeploy. This is the "master copy." All deployed contracts will execute code from this master copy.deploy() passing the address of the master copy and any other arguments needed to setup the new contractHere is ContractToDeploy
ContractToDeploy.vy
+# @pragma version ^0.4.0
+
+owner: public(address)
+
+# __init__ is not called when deployed from create_forwarder_to
+@deploy
+def __init__():
+ self.owner = msg.sender
+
+# call once after create_forwarder_to
+@external
+def set_owner(owner: address):
+ assert self.owner == empty(address), "owner != zero address"
+ self.owner = owner
+
+# DANGER: never have selfdestruct in original contract used by create_forwarder_to
+# This function has been deprecated from version 0.3.8 onwards. The underlying
+# opcode will eventually undergo breaking changes, and its use is not recommended.
+@external
+def kill():
+ selfdestruct(msg.sender)
+Create.vy
+# @pragma version ^0.4.0
+
+interface ContractToDeploy:
+ def set_owner(owner: address): nonpayable
+
+event Log:
+ addr: address
+
+@external
+def deploy(master_copy: address, owner: address):
+ addr: address = create_minimal_proxy_to(master_copy)
+ extcall ContractToDeploy(addr).set_owner(owner)
+ log Log(addr)
+
+@external
+def deploy_test(master_copy: address):
+ addr: address = create_minimal_proxy_to(master_copy)
+ extcall ContractToDeploy(addr).set_owner(self)
+ log Log(addr)
+A contract can have a default function, executed when a function that does not exist is called. This is the same function as the fallback function in Solidity.
+This function is named __default__ and it is commonly used to receive Ether.
# @pragma version ^0.4.0
+
+event Payment:
+ sender: indexed(address)
+ amount: uint256
+
+@external
+@payable
+def __default__():
+ log Payment(msg.sender, msg.value)
+Add and remove liquidity from Curve pools
+# @pragma version ^0.4.0
+
+from ethereum.ercs import IERC20
+
+interface IStableSwap:
+ def add_liquidity(amounts: uint256[3], min_shares: uint256): nonpayable
+ def remove_liquidity(shares: uint256, min_amounts: uint256[3]): nonpayable
+ def remove_liquidity_one_coin(shares: uint256, i: int128, min_amount: uint256): nonpayable
+ def get_virtual_price() -> uint256: view
+
+DAI: constant(address) = 0x6B175474E89094C44Da98b954EedeAC495271d0F
+USDC: constant(address) = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
+USDT: constant(address) = 0xdAC17F958D2ee523a2206206994597C13D831ec7
+
+POOL: constant(address) = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7
+COINS: constant(address[3]) = [DAI, USDC, USDT]
+
+@internal
+def _safe_transfer(coin: address, to: address, amount: uint256):
+ res: Bytes[32] = raw_call(
+ coin,
+ concat(
+ method_id("transfer(address,uint256)"),
+ convert(to, bytes32),
+ convert(amount, bytes32),
+ ),
+ max_outsize=32,
+ )
+ if len(res) > 0:
+ assert convert(res, bool)
+
+@internal
+def _safe_transfer_from(coin: address, _from: address, to: address, amount: uint256):
+ res: Bytes[32] = raw_call(
+ coin,
+ concat(
+ method_id("transferFrom(address,address,uint256)"),
+ convert(_from, bytes32),
+ convert(to, bytes32),
+ convert(amount, bytes32),
+ ),
+ max_outsize=32,
+ )
+ if len(res) > 0:
+ assert convert(res, bool)
+
+@internal
+def _safe_approve(coin: address, to: address, amount: uint256):
+ res: Bytes[32] = raw_call(
+ coin,
+ concat(
+ method_id("approve(address,uint256)"),
+ convert(to, bytes32),
+ convert(amount, bytes32),
+ ),
+ max_outsize=32,
+ )
+ if len(res) > 0:
+ assert convert(res, bool)
+
+@external
+def add_liquidity(amounts: uint256[3], min_shares: uint256):
+ for i: uint256 in range(3):
+ if amounts[i] > 0:
+ self._safe_transfer_from(COINS[i], msg.sender, self, amounts[i])
+ self._safe_approve(COINS[i], POOL, amounts[i])
+
+ extcall IStableSwap(POOL).add_liquidity(amounts, min_shares)
+
+@external
+@view
+def calc_value_of_shares(shares: uint256) -> uint256:
+ return shares * staticcall IStableSwap(POOL).get_virtual_price() // 10**18
+
+@external
+def remove_liquidity(shares: uint256, min_amounts: uint256[3]):
+ extcall IStableSwap(POOL).remove_liquidity(shares, min_amounts)
+
+ for coin: address in [DAI, USDC, USDT]:
+ bal: uint256 = staticcall IERC20(coin).balanceOf(self)
+ self._safe_transfer(coin, msg.sender, bal)
+
+@external
+def remove_liquidity_one_coin(shares: uint256, i: int128, min_amount: uint256):
+ extcall IStableSwap(POOL).remove_liquidity_one_coin(shares, i, min_amount)
+
+ bal: uint256 = staticcall IERC20(COINS[i]).balanceOf(self)
+ self._safe_transfer(COINS[i], msg.sender, bal)
+Swap tokens on Curve
+# @pragma version ^0.4.0
+
+from ethereum.ercs import IERC20
+
+interface IStableSwap:
+ def exchange(i: int128, j: int128, dx: uint256, min_dy: uint256): nonpayable
+
+DAI: constant(address) = 0x6B175474E89094C44Da98b954EedeAC495271d0F
+USDC: constant(address) = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
+USDT: constant(address) = 0xdAC17F958D2ee523a2206206994597C13D831ec7
+
+POOL: constant(address) = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7
+COINS: constant(address[3]) = [DAI, USDC, USDT]
+
+@internal
+def _safe_transfer(coin: address, to: address, amount: uint256):
+ res: Bytes[32] = raw_call(
+ coin,
+ concat(
+ method_id("transfer(address,uint256)"),
+ convert(to, bytes32),
+ convert(amount, bytes32),
+ ),
+ max_outsize=32,
+ )
+ if len(res) > 0:
+ assert convert(res, bool)
+
+@internal
+def _safe_transfer_from(coin: address, _from: address, to: address, amount: uint256):
+ res: Bytes[32] = raw_call(
+ coin,
+ concat(
+ method_id("transferFrom(address,address,uint256)"),
+ convert(_from, bytes32),
+ convert(to, bytes32),
+ convert(amount, bytes32),
+ ),
+ max_outsize=32,
+ )
+ if len(res) > 0:
+ assert convert(res, bool)
+
+@internal
+def _safe_approve(coin: address, to: address, amount: uint256):
+ res: Bytes[32] = raw_call(
+ coin,
+ concat(
+ method_id("approve(address,uint256)"),
+ convert(to, bytes32),
+ convert(amount, bytes32),
+ ),
+ max_outsize=32,
+ )
+ if len(res) > 0:
+ assert convert(res, bool)
+
+@external
+def swap(i: int128, j: int128, dx: uint256, min_dy: uint256):
+ self._safe_transfer_from(COINS[i], msg.sender, self, dx)
+ self._safe_approve(COINS[i], POOL, dx)
+
+ extcall IStableSwap(POOL).exchange(i, j, dx, min_dy)
+
+ bal: uint256 = staticcall IERC20(COINS[j]).balanceOf(self)
+ self._safe_transfer(COINS[j], msg.sender, bal)
+When contract A delegates call to contract B, B's code will be executed inside contract A. This will update state variables and Ether balance inside contract A and not B.
Delegate call is commonly used to create an upgradable contract.
+Here is the contract that we will delegate call to.
+TestDelegateCall.vy
+# @pragma version ^0.4.0
+
+# State variables must be declared in the same order
+# as contract making the call
+x: public(uint256)
+y: public(uint256)
+
+@external
+def update_x(x: uint256):
+ # when this function is called with delegate call
+ # this will update self.x inside the calling contract
+ self.x = x + 1
+
+
+@external
+def update_y(y: uint256):
+ self.y = y * y
+DelegateCall.vy
+# @pragma version ^0.4.0
+
+x: public(uint256)
+y: public(uint256)
+
+@external
+def update_x(to: address, x: uint256):
+ raw_call(
+ to,
+ concat(
+ method_id("update_x(uint256)"),
+ convert(x, bytes32)
+ ),
+ is_delegate_call=True
+ )
+
+@external
+def update_y(to: address, y: uint256):
+ raw_call(
+ to,
+ concat(
+ method_id("update_y(uint256)"),
+ convert(y, bytes32)
+ ),
+ is_delegate_call=True
+ )
+Dynamic arrays are bounded arrays whose length can change. The length of the array cannot exceed the maximum length set where the array is declared.
+# @pragma version ^0.4.0
+
+# Dynamic array of type uint256, max 3 elements
+nums: DynArray[uint256, 3]
+
+@deploy
+def __init__():
+ self.nums.append(11)
+ self.nums.append(22)
+ self.nums.append(33)
+ # This will revert (Appending to array with max 3 elements)
+ # self.nums.append(44)
+
+ # Remove last element
+ self.nums.pop()
+
+ # Delete all elements
+ self.nums = []
+ # Set values
+ self.nums = [1,2,3]
+
+@external
+@pure
+def examples(xs: DynArray[uint256, 5]) -> DynArray[uint256, 8]:
+ ys: DynArray[uint256, 5] = [1,2,3]
+ # Copy xs into ys
+ for x: uint256 in xs:
+ ys.append(x)
+ return ys
+
+@external
+@pure
+def filter(addrs: DynArray[address, 5]) -> DynArray[address, 5]:
+ nonzeros: DynArray[address, 5] = []
+ for addr: address in addrs:
+ if addr != empty(address):
+ nonzeros.append(addr)
+ return nonzeros
+Use assert and raise to check inputs and validate state.
When an error occurs, it will halt the entire function call, undoing any changes.
+You will still need to pay gas for the failed transaction.
+# @pragma version ^0.4.0
+
+x: public(uint256)
+owner: public(address)
+
+@deploy
+def __init__():
+ self.owner = msg.sender
+
+@external
+def test_assert(x: uint256):
+ assert x >= 1, "x < 1"
+ # self.x will not be updated if there is an error from line above
+ self.x = x
+
+@external
+def test_raise(x: uint256):
+ # same check as above using "raise"
+ if x <= 1:
+ raise "x < 1"
+ self.x = x
+
+@internal
+def _test_error_bubbles_up(x: uint256):
+ assert x >= 1, "x < 1"
+ self.x = x
+
+@external
+def test_error_bubbles_up(x: uint256):
+ self._test_error_bubbles_up(x)
+ # self.x = 123 will not be executed if there is an error
+ # from function above
+ self.x = 123
+
+@external
+def set_owner(owner: address):
+ assert msg.sender == self.owner, "!owner"
+ assert owner != empty(address), "owner = zero"
+ self.owner = owner
+Events write logs to the blockchain, commonly used by application to monitor blockchain state and as a cheaper alternative to store data on the blockchain without using state variables.
+Events can be efficiently searched by indexing their arguments. Up to 3 parameters can be indexed.
+# @pragma version ^0.4.0
+
+# up to 3 index
+event Transfer:
+ # enables quick search of all Transfer events where sender is a certain address
+ sender: indexed(address)
+ # enables quick search of all Transfer events where receiver is a certain address
+ receiver: indexed(address)
+ amount: uint256
+
+@external
+def transfer(receiver: address, amount: uint256):
+ # some code ...
+ log Transfer(msg.sender, receiver, amount)
+
+@external
+def mint(amount: uint256):
+ # some code ...
+ log Transfer(empty(address), msg.sender, amount)
+
+@external
+def burn(amount: uint256):
+ # some code ...
+ log Transfer(msg.sender, empty(address), amount)
+There are 2 ways to loop through an array, using range and directly looping through array elements.
# @pragma version ^0.4.0
+
+@external
+@pure
+def for_loop():
+ # for loop through range
+ # sum from 0 to 9
+ s: uint256 = 0
+ for i: uint256 in range(10):
+ s += i
+
+ # for loop through array elements
+ # find minimum of nums
+ nums: uint256[5] = [4, 5, 1, 9, 0]
+ x: uint256 = max_value(uint256)
+ for num: uint256 in nums:
+ if x < num:
+ x = num
+
+ # continue - skip current iteration
+ # break - exit for loop
+ c: uint256 = 0
+ for i: uint256 in [1, 2, 3, 4, 5]:
+ # skip 2
+ if i == 2:
+ continue
+ # end loop at i = 4
+ if i == 4:
+ break
+ # otherwise increment c by 1
+ c += 1
+ # c = 2 (incremented at i = 1 and 3)
+
+@external
+@pure
+def sum(nums: uint256[10]) -> uint256:
+ s: uint256 = 0
+ for n: uint256 in nums:
+ s += n
+ return s
+# @pragma version ^0.4.0
+
+@external
+@pure
+def multiply(x: uint256, y: uint256) -> uint256:
+ return x * y
+
+@external
+@pure
+def divide(x: uint256, y: uint256) -> uint256:
+ # integer division
+ return x // y
+
+# A funciton that does nothing
+@external
+def doNothing():
+ # pass is useful when you want to compile the contract now,
+ # write the code later
+ pass
+
+# Functions can return multiple outputs
+@external
+@pure
+def multiOut() -> (uint256, bool):
+ return (1, True)
+
+@external
+@pure
+def addAndSub(x: uint256, y: uint256) -> (uint256, uint256):
+ return (x + y, x - y)
+Vyper supports the same hash function available in Solidity, keccack256.
# @pragma version ^0.4.0
+
+@external
+@pure
+def get_hash(addr: address, num: uint256, ) -> bytes32:
+ # input of keccak256 can be String, Bytes or bytes32
+ return keccak256(
+ # convert different data into Bytes
+ concat(
+ convert(addr, bytes32),
+ convert(num, bytes32),
+ convert("THIS IS A STRING", Bytes[16])
+ )
+ )
+
+@external
+@pure
+def get_message_hash(str: String[100]) -> bytes32:
+ return keccak256(str)
+@version specifies the compiler version of Vyper.
# @pragma version ^0.4.0
+
+# Create a string variable that can store maximum 100 characters
+greet: public(String[100])
+
+@deploy
+def __init__():
+ self.greet = "Hello World"
+# @pragma version ^0.4.0
+
+@external
+def if_else(x: uint256) -> uint256:
+ if x <= 10:
+ return 1
+ elif x <= 20:
+ return 2
+ else:
+ return 3
+
+@external
+@pure
+def abs_value(x: uint256, y: uint256) -> uint256:
+ if x >= y:
+ return x - y
+ return y - x
+Immutable variables are like constants except value are assigned when the contract is deployed.
+immutable variables?msg.senderimmutable?Like constants, immutable variables save run time gas
# @pragma version ^0.4.0
+
+OWNER: immutable(address)
+MY_IMMUTABLE: immutable(uint256)
+
+@deploy
+def __init__(val: uint256):
+ OWNER = msg.sender
+ MY_IMMUTABLE = val
+
+
+@external
+@view
+def get_my_immutable() -> uint256:
+ return MY_IMMUTABLE
+Use interface to call other smart contracts.
Here is the TestInterface self.contract that we will call.
TestInterface.vy
+# @pragma version ^0.4.0
+
+owner: public(address)
+eth: public(uint256)
+
+@external
+def set_owner(owner: address):
+ self.owner = owner
+
+@external
+@payable
+def send_eth():
+ self.eth = msg.value
+
+@external
+@payable
+def set_owner_and_send_eth(owner: address):
+ self.owner = owner
+ self.eth = msg.value
+Interface.vy
+# @pragma version ^0.4.0
+
+interface TestInterface:
+ # get address of owner
+ def owner() -> address: view
+ # set new owner
+ def set_owner(owner: address): nonpayable
+ # send ETH
+ def send_eth(): payable
+ # set owner and send ETH
+ def set_owner_and_send_eth(owner: address): payable
+
+# store contract having the above interface
+test: public(TestInterface)
+
+@deploy
+def __init__(test: address):
+ # store contract instance
+ self.test = TestInterface(test)
+ # if you need to get address from self.test
+ addr: address = self.test.address
+
+@external
+@view
+def get_owner() -> address:
+ return staticcall self.test.owner()
+
+@external
+@view
+def get_owner_from_addr(test: address) -> address:
+ # you can also call functions by passing in the address of the interface
+ return staticcall TestInterface(test).owner()
+
+@external
+def set_owner(owner: address):
+ extcall self.test.set_owner(owner)
+
+@external
+@payable
+def send_eth():
+ extcall self.test.send_eth(value=msg.value)
+
+@external
+@payable
+def set_owner_and_send_eth(owner: address):
+ extcall self.test.set_owner_and_send_eth(owner, value=msg.value)
+@internal functions can only be called inside the contract.
@external functions can only be called from outside the contract.
# @pragma version ^0.4.0
+
+# Internal functions can only be called inside this contract
+@internal
+@pure
+def _add(x: uint256, y: uint256) -> uint256:
+ return x + y
+
+@external
+@view
+def ext_func() -> bool:
+ return True
+
+# External functions can only be called from outside this contract
+@external
+@view
+def avg(x: uint256, y: uint256) -> uint256:
+ # cannot call other external function
+ # self.extFunc()
+
+ # can call internal functions
+ z: uint256 = self._add(x, y)
+
+ return (x + y) // 2
+
+@internal
+@pure
+def _sqr(x: uint256) -> uint256:
+ return x * x
+
+@external
+@view
+def sum_of_squares(x: uint256, y: uint256) -> uint256:
+ return self._sqr(x) + self._sqr(y)
+Functions declared with @payable can receive Ether.
# @pragma version ^0.4.0
+
+event Deposit:
+ sender: indexed(address)
+ amount: uint256
+
+@external
+@payable
+def deposit():
+ log Deposit(msg.sender, msg.value)
+
+@external
+@view
+def get_balance() -> uint256:
+ # Get balance of Ether stored in this contract
+ return self.balance
+
+owner: public(address)
+
+@external
+@payable
+def pay():
+ assert msg.value > 0, "msg.value = 0"
+ self.owner = msg.sender
+Use the built-in function print to debug smart contracts.
# @pragma version ^0.4.0
+
+@external
+def test_print():
+ x: uint256 = 123
+ # Set hardhat_compat = True when testing with Hardhat
+ print("print something here", x, hardhat_compat=True)
+Private state variables cannot be accessed from outside the contract.
+Public state variables can be read by anyone, including users and other contracts.
+# @pragma version ^0.4.0
+
+# publis state variable
+owner: public(address)
+# private state variable
+foo: uint256
+bar: public(bool)
+
+@deploy
+def __init__():
+ self.owner = msg.sender
+ self.foo = 123
+ self.bar = True
+raw_call is a low level function. It is used to call and send Ether to other functions.
For this example, we will write a contract that calls this contract below.
+TestRawCall.vy
+# @pragma version ^0.4.0
+
+
+sender: public(address)
+
+@external
+def test_add(x: uint256, y: uint256) -> uint256:
+ self.sender = msg.sender
+ return x + y
+
+@external
+def test_sub(x: uint256, y: uint256) -> uint256:
+ self.sender = msg.sender
+ return x - y
+RawCall.vy
+# @pragma version ^0.4.0
+
+@external
+def test_raw_call(to: address, x: uint256, y: uint256):
+ res: Bytes[32] = raw_call(
+ to, # address to call
+ # data to send in Bytes
+ concat(
+ method_id("test_add(uint256,uint256)"), # function to call
+ convert(x, bytes32), # first input
+ convert(y, bytes32), # secode input
+ ),
+ max_outsize=32, # max size of ouput, default 0
+ gas=100000, # optional, amount of gas to send, default forwards all gas
+ value=0, # optional, amount of ETH to send, default 0
+ )
+ z: uint256 = convert(res, uint256)
+
+@external
+@payable
+def send_eth(to: address):
+ # Example to send ETH
+ # data = b"", empty data
+ # value = msg.value, all of ETH that was sent to this function
+ raw_call(to, b"", value=msg.value)
+
+diff: public(uint256)
+
+@external
+def test_raw_call_sub(to: address, x: uint256, y: uint256):
+ res: Bytes[32] = raw_call(
+ to,
+ concat(
+ method_id("test_sub(uint256,uint256)"),
+ convert(x, bytes32),
+ convert(y, bytes32)
+ ),
+ max_outsize=32,
+ )
+
+ self.diff = convert(res, uint256)
+Vyper has a handy way to secure your contract from re-entrancy.
+A re-entrancy lock can be created on a function with @nonreentrant("lock").
Functions can be locked together by using the same name for the locks.
+# @pragma version ^0.4.0
+
+@external
+@nonreentrant
+def func():
+ # call back msg.sender
+ raw_call(msg.sender, b"", value=0)
+
+References types are data types that are passed by their reference, pointer to where the actual data is stored.
+# @pragma version ^0.4.0
+
+struct Person:
+ name: String[100]
+ age: uint256
+
+# Fixed sized list
+nums: public(uint256[10]) # must be bounded
+myMap: public(HashMap[address, uint256])
+person: public(Person)
+
+@deploy
+def __init__():
+ # This updates self.nums[0]
+ self.nums[0] = 123
+ self.nums[9] = 456
+ # Copies self.nums to array in memory.
+ # Does not modify referenced variable (self.nums)
+ arr: uint256[10] = self.nums
+ arr[0] = 123
+
+ # This updates self.myMap
+ self.myMap[msg.sender] = 1
+ self.myMap[msg.sender] = 11
+
+ # This updates self.person
+ self.person.age = 11
+ self.person.name = "Vyper"
+ # Person struct is copied into memory.
+ # Does not modify referenced variable (self.person)
+ p: Person = self.person
+ p.name = "Solidity"
+selfdestruct deletes the contract from the blockchain. It takes a single input, an address to send all of Ether stored in the contract.
# @pragma version ^0.4.0
+
+@external
+@payable
+def __default__():
+ pass
+
+@external
+def kill():
+ selfdestruct(msg.sender)
+There are two ways to send Ether from a contract, send and raw_call. Here we introduce the simpler function to use, send.
# @pragma version ^0.4.0
+
+# Receive Ether into this contract
+@external
+@payable
+def __default__():
+ pass
+
+@external
+def send_eth(to: address, amount: uint256):
+ # when Ether is sent to a contract it will call
+ # __default__ inside the receiving contract
+ # forwards 2300 gas
+ send(to, amount)
+
+@external
+def send_all(to: address):
+ send(to, self.balance)
+Critical math checks such as overflow, underflow and division by 0 can be skipped using unsafe functions
+# @pragma version ^0.4.0
+
+@external
+def test_add(x: uint256, y: uint256) -> uint256:
+ # 21510 gas
+ # return x + y
+
+ # 21472 gas
+ return unsafe_add(x, y)
+
+@external
+def test_sub(x: uint256, y: uint256) -> uint256:
+ # 21533 gas
+ # return x - y
+
+ # 21495 gas
+ return unsafe_sub(x, y)
+
+@external
+def test_mul(x: uint256, y: uint256) -> uint256:
+ # 21578 gas
+ # return x * y
+
+ # 21520 gas
+ return unsafe_mul(x, y)
+
+@external
+def test_div(x: uint256, y: uint256) -> uint256:
+ # 21578 gas
+ # return x // y
+
+ # 21543 gas
+ return unsafe_div(x, y)
+Some values available in Vyper
+boolint128uint256decimalsaddressbytes32BytesString# @pragma version ^0.4.0
+
+# Must be compiled with --enable-decimals
+
+b: public(bool)
+i: public(int128) # -2 ** 127 to (2 ** 127 - 1)
+u: public(uint256) # 0 to 2 ** 256 - 1
+dec: public(decimal) # -2 ** 127 to (2 ** 127 - 1), 10 decimal places
+addr: public(address)
+b32: public(bytes32)
+bs: public(Bytes[100])
+s: public(String[100])
+
+@deploy
+def __init__():
+ self.b = False
+ self.i = -1
+ self.u = 123
+ self.dec = 3.14
+ self.addr = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4
+ self.b32 = 0xada1b75f8ae9a65dcc16f95678ac203030505c6b465c8206e26ae84b525cdacb
+ self.bs = b"\\x01"
+ self.s = "Hello Vyper"
+Signing and verifying signature takes 3 steps.
+# @pragma version ^0.4.0
+
+# hash = get_hash("Hello Vyper!")
+# 0x5436c86f18e3d25a10e557ae125450118dd0a481ca22112b1977d55a676e4c91
+@external
+@pure
+def get_hash(str: String[100]) -> bytes32:
+ return keccak256(str)
+
+# get_eth_signed_hash(hash)
+# 0x045b623a8e8fb7b4fcfbd1ae07e7326d55303d7de4085c69b346bd130c1936da
+@external
+@pure
+def get_eth_signed_hash(hash: bytes32) -> bytes32:
+ return keccak256(
+ concat(
+ b'\\x19Ethereum Signed Message:\\n32',
+ hash
+ )
+ )
+
+# account = your account
+# hash = get_hash("Hello Vyper!")
+# signature = await ethereum.request({ method: "personal_sign", params: [account, hash]})
+@external
+@pure
+def recover_signer(eth_signed_hash: bytes32, sig: Bytes[65]) -> address:
+ r: uint256 = convert(slice(sig, 0, 32), uint256)
+ s: uint256 = convert(slice(sig, 32, 32), uint256)
+ v: uint256 = convert(slice(sig, 64, 1), uint256)
+ return ecrecover(eth_signed_hash, v, r, s)
+
+@external
+@pure
+def verify(sig: Bytes[65], str: String[100], _signer: address) -> bool:
+ hash: bytes32 = keccak256(str)
+ eth_signed_hash: bytes32 = keccak256(
+ concat(
+ b'\\x19Ethereum Signed Message:\\n32',
+ hash
+ )
+ )
+ r: uint256 = convert(slice(sig, 0, 32), uint256)
+ s: uint256 = convert(slice(sig, 32, 32), uint256)
+ v: uint256 = convert(slice(sig, 64, 1), uint256)
+ signer: address = ecrecover(eth_signed_hash, v, r, s)
+
+ return _signer == signer
+Both pure and view functions are read only function, they cannot write anything to the blockchain.
pure functions do not read any state or global variables
view functions can read state variables, global variables and call internal functions.
# @pragma version ^0.4.0
+
+num: public(uint256)
+
+# Pure functions does not read any state or global variables
+@external
+@pure
+def pureFunc(x: uint256) -> uint256:
+ return x
+
+
+# View functions might read state or global state, or call an internal function
+@external
+@view
+def viewFunc(x: uint256) -> bool:
+ return x > self.num
+
+
+@external
+@pure
+def sum(x: uint256, y: uint256, z: uint256) -> uint256:
+ return x + y + z
+
+
+@external
+@view
+def addNum(x: uint256) -> uint256:
+ return x + self.num
+Constants are variables that cannot change.
-# @version ^0.3.9
-
-MY_CONSTANT: constant(uint256) = 123
-MIN: constant(uint256) = 1
-MAX: constant(uint256) = 10
-ADDR: constant(address) = 0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B
-
-
-@external
-@pure
-def getBuiltInConstants() -> (address, uint256, bytes32):
- # Commonly used constants availabe in Vyper
- return (ZERO_ADDRESS, MAX_UINT256, EMPTY_BYTES32)
-
-
-@external
-@pure
-def getMyConstants() -> (uint256, uint256, address):
- return (MIN, MAX, ADDR)
-__init__ is a special function that is executed only once when the contract is deployed.
# @version ^0.3.9
-
-owner: public(address)
-name: public(String[10])
-createdAt: public(uint256)
-expiresAt: public(uint256)
-
-
-@external
-def __init__(name: String[10], duration: uint256):
- # set owner to caller
- self.owner = msg.sender
- # set name from input
- self.name = name
- self.createdAt = block.timestamp
- self.expiresAt = block.timestamp + duration
-Vyper contracts can deploy new contracts using the function create_forwarder_to.
create_forwarder_to is also known as "minimal proxy contract". How it works, we won't explain it here.
Here we will focus on how to use it to deploy new contracts.
-create_forwarder_toContractToDeploy. This is the "master copy." All deployed contracts will execute code from this master copy.deploy() passing the address of the master copy and any other arguments needed to setup the new contractHere is ContractToDeploy
ContractToDeploy.vy
-# @version ^0.3.9
-
-
-owner: public(address)
-
-
-# __init__ is not called when deployed from create_forwarder_to
-@external
-def __init__():
- self.owner = msg.sender
-
-
-# call once after create_forwarder_to
-@external
-def setup(owner: address):
- assert self.owner == ZERO_ADDRESS, "owner != zero address"
- self.owner = owner
-
-
-# DANGER: never have selfdestruct in original contract used by create_forwarder_to
-@external
-def kill():
- selfdestruct(msg.sender)
-Create.vy
-# @version ^0.3.9
-
-
-interface ContractToDeploy:
- def setup(owner: address): nonpayable
-
-
-event Log:
- addr: address
-
-
-@external
-def deploy(_masterCopy: address, owner: address):
- addr: address = create_forwarder_to(_masterCopy)
- ContractToDeploy(addr).setup(owner)
- log Log(addr)
-
-
-@external
-def deployTest(_masterCopy: address):
- addr: address = create_forwarder_to(_masterCopy)
- ContractToDeploy(addr).setup(self)
- log Log(addr)
-A contract can have a default function, executed when a function that does not exist is called. This is the same function as the fallback function in Solidity.
-This function is named __default__ and it is commonly used to receive Ether.
# @version ^0.3.9
-
-
-event Payment:
- sender: indexed(address)
- amount: uint256
-
-
-@external
-@payable
-def __default__():
- log Payment(msg.sender, msg.value)
-Add and remove liquidity from Curve pools
-# @version ^0.3.9
-
-from vyper.interfaces import ERC20
-
-
-interface IStableSwap:
- def add_liquidity(amounts: uint256[3], min_shares: uint256): nonpayable
- def remove_liquidity(shares: uint256, min_amounts: uint256[3]): nonpayable
- def remove_liquidity_one_coin(shares: uint256, i: int128, min_amount: uint256): nonpayable
- def get_virtual_price() -> uint256: view
-
-
-DAI: constant(address) = 0x6B175474E89094C44Da98b954EedeAC495271d0F
-USDC: constant(address) = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
-USDT: constant(address) = 0xdAC17F958D2ee523a2206206994597C13D831ec7
-
-POOL: constant(address) = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7
-COINS: constant(address[3]) = [DAI, USDC, USDT]
-
-
-@internal
-def _safeTransfer(coin: address, to: address, amount: uint256):
- res: Bytes[32] = raw_call(
- coin,
- concat(
- method_id("transfer(address,uint256)"),
- convert(to, bytes32),
- convert(amount, bytes32),
- ),
- max_outsize=32,
- )
-
- if len(res) > 0:
- assert convert(res, bool)
-
-
-@internal
-def _safeTransferFrom(coin: address, _from: address, to: address, amount: uint256):
- res: Bytes[32] = raw_call(
- coin,
- concat(
- method_id("transferFrom(address,address,uint256)"),
- convert(_from, bytes32),
- convert(to, bytes32),
- convert(amount, bytes32),
- ),
- max_outsize=32,
- )
-
- if len(res) > 0:
- assert convert(res, bool)
-
-
-@internal
-def _safeApprove(coin: address, to: address, amount: uint256):
- res: Bytes[32] = raw_call(
- coin,
- concat(
- method_id("approve(address,uint256)"),
- convert(to, bytes32),
- convert(amount, bytes32),
- ),
- max_outsize=32,
- )
-
- if len(res) > 0:
- assert convert(res, bool)
-
-
-@external
-def addLiquidity(amounts: uint256[3], min_shares: uint256):
- for i in range(3):
- if amounts[i] > 0:
- self._safeTransferFrom(COINS[i], msg.sender, self, amounts[i])
- self._safeApprove(COINS[i], POOL, amounts[i])
-
- IStableSwap(POOL).add_liquidity(amounts, min_shares)
-
-
-@external
-@view
-def calculateValueOfShares(shares: uint256) -> uint256:
- return shares * IStableSwap(POOL).get_virtual_price() / 10**18
-
-
-@external
-def removeLiquidity(shares: uint256, min_amounts: uint256[3]):
- IStableSwap(POOL).remove_liquidity(shares, min_amounts)
-
- for coin in COINS:
- bal: uint256 = ERC20(coin).balanceOf(self)
- self._safeTransfer(coin, msg.sender, bal)
-
-
-@external
-def removeLiquidityOneCoin(shares: uint256, i: int128, min_amount: uint256):
- IStableSwap(POOL).remove_liquidity_one_coin(shares, i, min_amount)
-
- bal: uint256 = ERC20(COINS[i]).balanceOf(self)
- self._safeTransfer(COINS[i], msg.sender, bal)
-Swap tokens on Curve
-# @version ^0.3.9
-
-from vyper.interfaces import ERC20
-
-
-interface IStableSwap:
- def exchange(i: int128, j: int128, dx: uint256, min_dy: uint256): nonpayable
-
-
-DAI: constant(address) = 0x6B175474E89094C44Da98b954EedeAC495271d0F
-USDC: constant(address) = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
-USDT: constant(address) = 0xdAC17F958D2ee523a2206206994597C13D831ec7
-
-POOL: constant(address) = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7
-COINS: constant(address[3]) = [DAI, USDC, USDT]
-
-
-@internal
-def _safeTransfer(coin: address, to: address, amount: uint256):
- res: Bytes[32] = raw_call(
- coin,
- concat(
- method_id("transfer(address,uint256)"),
- convert(to, bytes32),
- convert(amount, bytes32),
- ),
- max_outsize=32,
- )
-
- if len(res) > 0:
- assert convert(res, bool)
-
-
-@internal
-def _safeTransferFrom(coin: address, _from: address, to: address, amount: uint256):
- res: Bytes[32] = raw_call(
- coin,
- concat(
- method_id("transferFrom(address,address,uint256)"),
- convert(_from, bytes32),
- convert(to, bytes32),
- convert(amount, bytes32),
- ),
- max_outsize=32,
- )
-
- if len(res) > 0:
- assert convert(res, bool)
-
-
-@internal
-def _safeApprove(coin: address, to: address, amount: uint256):
- res: Bytes[32] = raw_call(
- coin,
- concat(
- method_id("approve(address,uint256)"),
- convert(to, bytes32),
- convert(amount, bytes32),
- ),
- max_outsize=32,
- )
-
- if len(res) > 0:
- assert convert(res, bool)
-
-
-@external
-def swap(i: int128, j: int128, dx: uint256, min_dy: uint256):
- self._safeTransferFrom(COINS[i], msg.sender, self, dx)
- self._safeApprove(COINS[i], POOL, dx)
-
- IStableSwap(POOL).exchange(i, j, dx, min_dy)
-
- bal: uint256 = ERC20(COINS[j]).balanceOf(self)
- self._safeTransfer(COINS[j], msg.sender, bal)
-When contract A delegates call to contract B, B's code will be executed inside contract A. This will update state variables and Ether balance inside contract A and not B.
Delegate call is commonly used to create an upgradable contract.
-Here is the contract that we will delegate call to.
-TestDelegateCall.vy
-# @version ^0.3.9
-
-# State variables must be declared in the same order
-# as contract making the call
-x: public(uint256)
-y: public(uint256)
-
-
-@external
-def updateX(x: uint256):
- # when this function is called with delegate call
- # this will update self.x inside the calling contract
- self.x = x + 1
-
-
-@external
-def updateY(y: uint256):
- self.y = y * y
-DelegateCall.vy
-# @version ^0.3.9
-
-
-x: public(uint256)
-y: public(uint256)
-
-
-@external
-def updateX(to: address, x: uint256):
- raw_call(
- to,
- concat(
- method_id("updateX(uint256)"),
- convert(x, bytes32)
- ),
- is_delegate_call=True
- )
-
-
-@external
-def updateY(to: address, y: uint256):
- raw_call(
- to,
- concat(
- method_id("updateY(uint256)"),
- convert(y, bytes32)
- ),
- is_delegate_call=True
- )
-Dynamic arrays are bounded arrays whose length can change. The length of the array cannot exceed the maximum length set where the array is declared.
-# @version ^0.3.9
-
-# Dynamic array of type uint256, max 3 elements
-nums: DynArray[uint256, 3]
-
-@external
-def __init__():
- self.nums.append(11)
- self.nums.append(22)
- self.nums.append(33)
- # This will revert (Appending to array with max 3 elements)
- # self.nums.append(44)
-
- # Remove last element
- self.nums.pop()
-
- # Delete all elements
- self.nums = []
- # Set values
- self.nums = [1,2,3]
-
-
-@external
-@pure
-def examples(xs: DynArray[uint256, 5]) -> DynArray[uint256, 8]:
- ys: DynArray[uint256, 5] = [1,2,3]
- # Copy xs into ys
- for x in xs:
- ys.append(x)
- return ys
-
-
-@external
-@pure
-def filter(addrs: DynArray[address, 5]) -> DynArray[address, 5]:
- nonzeros: DynArray[address, 5] = []
- for addr in addrs:
- if addr != ZERO_ADDRESS:
- nonzeros.append(addr)
- return nonzeros
-Use assert and raise to check inputs and validate state.
When an error occurs, it will halt the entire function call, undoing any changes.
-You will still need to pay gas for the failed transaction.
-# @version ^0.3.9
-
-x: public(uint256)
-owner: public(address)
-
-
-@external
-def __init__():
- self.owner = msg.sender
-
-
-@external
-def testAssert(x: uint256):
- assert x >= 1, "x < 1"
- # self.x will not be updated if there is an error from line above
- self.x = x
-
-
-@external
-def testRaise(x: uint256):
- # same check as above using "raise"
- if x <= 1:
- raise "x < 1"
- self.x = x
-
-
-@internal
-def _testErrorBubblesUp(x: uint256):
- assert x >= 1, "x < 1"
- self.x = x
-
-
-@external
-def testErrorBubblesUp(x: uint256):
- self._testErrorBubblesUp(x)
- # self.x = 123 will not be executed if there is an error
- # from function above
- self.x = 123
-
-
-@external
-def setOwner(owner: address):
- assert msg.sender == self.owner, "!owner"
- assert owner != ZERO_ADDRESS, "owner = zero"
- self.owner = owner
-Events write logs to the blockchain, commonly used by application to monitor blockchain state and as a cheaper alternative to store data on the blockchain without using state variables.
-Events can be efficiently searched by indexing their arguments. Up to 3 parameters can be indexed.
-# @version ^0.3.9
-
-# up to 3 index
-event Transfer:
- # enables quick search of all Transfer events where sender is a certain address
- sender: indexed(address)
- # enables quick search of all Transfer events where receiver is a certain address
- receiver: indexed(address)
- amount: uint256
-
-
-@external
-def transfer(receiver: address, amount: uint256):
- # some code ...
- log Transfer(msg.sender, receiver, amount)
-
-
-@external
-def mint(amount: uint256):
- # some code ...
- log Transfer(ZERO_ADDRESS, msg.sender, amount)
-
-
-@external
-def burn(amount: uint256):
- # some code ...
- log Transfer(msg.sender, ZERO_ADDRESS, amount)
-There are 2 ways to loop through an array, using range and directly looping through array elements.
# @version ^0.3.9
-
-
-@external
-@pure
-def forLoop():
- # for loop through range
- # sum from 0 to 9
- s: uint256 = 0
- for i in range(10):
- s += i
-
- # for loop through array elements
- # find minimum of nums
- nums: uint256[5] = [4, 5, 1, 9, 0]
- x: uint256 = MAX_UINT256
- for num in nums:
- if x < num:
- x = num
-
- # continue - skip current iteration
- # break - exit for loop
- c: uint256 = 0
- for i in [1, 2, 3, 4, 5]:
- # skip 2
- if i == 2:
- continue
- # end loop at i = 4
- if i == 4:
- break
- # otherwise increment c by 1
- c += 1
- # c = 2 (incremented at i = 1 and 3)
-
-
-@external
-@pure
-def sum(nums: uint256[10]) -> uint256:
- s: uint256 = 0
- for n in nums:
- s += n
- return s
-# @version ^0.3.9
-
-
-@external
-@pure
-def multiply(x: uint256, y: uint256) -> uint256:
- return x * y
-
-
-@external
-@pure
-def divide(x: uint256, y: uint256) -> uint256:
- return x / y
-
-
-# A funciton that does nothing
-@external
-def doNothing():
- # pass is useful when you want to compile the contract now,
- # write the code later
- pass
-
-
-# Functions can return multiple outputs
-@external
-@pure
-def multiOut() -> (uint256, bool):
- return (1, True)
-
-
-@external
-@pure
-def addAndSub(x: uint256, y: uint256) -> (uint256, uint256):
- return (x + y, x - y)
-Vyper supports the same hash function available in Solidity, keccack256.
# @version ^0.3.9
-
-
-@external
-@pure
-def getHash(addr: address, num: uint256, ) -> bytes32:
- # input of keccak256 can be String, Bytes or bytes32
- return keccak256(
- # convert different data into Bytes
- concat(
- convert(addr, bytes32),
- convert(num, bytes32),
- convert("THIS IS A STRING", Bytes[16])
- )
- )
-
-
-@external
-@pure
-def getMessageHash(_str: String[100]) -> bytes32:
- return keccak256(_str)
-@version specifies the compiler version of Vyper.
# @version ^0.3.0
-
-# Create a string variable that can store maximum 100 characters
-greet: public(String[100])
-
-@external
-def __init__():
- self.greet = "Hello World"
-# @version ^0.3.9
-
-
-@external
-def ifElse(x: uint256) -> uint256:
- if x <= 10:
- return 1
- elif x <= 20:
- return 2
- else:
- return 3
-
-
-@external
-@pure
-def absoluteValue(x: uint256, y: uint256) -> uint256:
- if x >= y:
- return x - y
- return y - x
-Immutable variables are like constants except value are assigned when the contract is deployed.
-immutable variables?msg.senderimmutable?Like constants, immutable variables save run time gas
# @version ^0.3.9
-
-OWNER: immutable(address)
-MY_IMMUTABLE: immutable(uint256)
-
-@external
-def __init__(_val: uint256):
- OWNER = msg.sender
- MY_IMMUTABLE = _val
-
-
-@external
-@pure
-def getMyImmutable() -> uint256:
- return MY_IMMUTABLE
-Use interface to call other smart contracts.
Here is the TestInterface self.contract that we will call.
TestInterface.vy
-# @version ^0.3.9
-
-
-owner: public(address)
-eth: public(uint256)
-
-
-@external
-def setOwner(owner: address):
- self.owner = owner
-
-
-@external
-@payable
-def sendEth():
- self.eth = msg.value
-
-
-@external
-@payable
-def setOwnerAndSendEth(owner: address):
- self.owner = owner
- self.eth = msg.value
-Interface.vy
-# @version ^0.3.9
-
-
-interface TestInterface:
- # get address of owner
- def owner() -> address: view
- # set new owner
- def setOwner(owner: address): nonpayable
- # send ETH
- def sendEth(): payable
- # set owner and send ETH
- def setOwnerAndSendEth(owner: address): payable
-
-
-# store contract having the above interface
-test: public(TestInterface)
-
-
-@external
-def __init__(test: address):
- # store contract instance
- self.test = TestInterface(test)
- # if you need to get address from self.test
- addr: address = self.test.address
-
-
-@external
-@view
-def getOwner() -> address:
- return self.test.owner()
-
-
-@external
-@view
-def getOwnerFromAddress(test: address) -> address:
- # you can also call functions by passing in the address of the interface
- return TestInterface(test).owner()
-
-
-@external
-def setOwner(owner: address):
- self.test.setOwner(owner)
-
-
-@external
-@payable
-def sendEth():
- self.test.sendEth(value=msg.value)
-
-
-@external
-@payable
-def setOwnerAndSendEth(owner: address):
- self.test.setOwnerAndSendEth(owner, value=msg.value)
-@internal functions can only be called inside the contract.
@external functions can only be called from outside the contract.
# @version ^0.3.9
-
-# Internal functions can only be called inside this contract
-@internal
-@pure
-def _add(x: uint256, y: uint256) -> uint256:
- return x + y
-
-
-@external
-@view
-def extFunc() -> bool:
- return True
-
-
-# External functions can only be called from outside this contract
-@external
-@view
-def avg(x: uint256, y: uint256) -> uint256:
- # cannot call other external function
- # self.extFunc()
-
- # can call internal functions
- z: uint256 = self._add(x, y)
-
- return (x + y) / 2
-
-
-@internal
-@pure
-def _sqr(x: uint256) -> uint256:
- return x * x
-
-
-@external
-@view
-def sumOfSquares(x: uint256, y: uint256) -> uint256:
- return self._sqr(x) + self._sqr(y)
-Functions declared with @payable can receive Ether.
# @version ^0.3.9
-
-
-event Deposit:
- sender: indexed(address)
- amount: uint256
-
-
-@external
-@payable
-def deposit():
- log Deposit(msg.sender, msg.value)
-
-
-@external
-@view
-def getBalance() -> uint256:
- # Get balance of Ether stored in this contract
- return self.balance
-
-
-owner: public(address)
-
-
-@external
-@payable
-def pay():
- assert msg.value > 0, "msg.value = 0"
- self.owner = msg.sender
-Use the built-in function print to debug smart contracts.
# @version ^0.3.9
-
-@external
-def test_print():
- x: uint256 = 123
- # Set hardhat_compat = True when testing with Hardhat
- print("print something here", x, hardhat_compat=True)
-
-
-Private state variables cannot be accessed from outside the contract.
-Public state variables can be read by anyone, including users and other contracts.
-# @version ^0.3.9
-
-# publis state variable
-owner: public(address)
-# private state variable
-foo: uint256
-bar: public(bool)
-
-
-@external
-def __init__():
- self.owner = msg.sender
- self.foo = 123
- self.bar = True
-raw_call is a low level function. It is used to call and send Ether to other functions.
For this example, we will write a contract that calls this contract below.
-TestRawCall.vy
-# @version ^0.3.9
-
-
-sender: public(address)
-
-
-@external
-def testAdd(x: uint256, y: uint256) -> uint256:
- self.sender = msg.sender
- return x + y
-
-
-@external
-def testSub(x: uint256, y: uint256) -> uint256:
- self.sender = msg.sender
- return x - y
-RawCall.vy
-# @version ^0.3.9
-
-
-@external
-def testRawCall(to: address, x: uint256, y: uint256):
- res: Bytes[32] = raw_call(
- to, # address to call
- # data to send in Bytes
- concat(
- method_id("testAdd(uint256,uint256)"), # function to call
- convert(x, bytes32), # first input
- convert(y, bytes32), # secode input
- ),
- max_outsize=32, # max size of ouput, default 0
- gas=100000, # optional, amount of gas to send, default forwards all gas
- value=0, # optional, amount of ETH to send, default 0
- )
-
- z: uint256 = convert(res, uint256)
-
-
-@external
-@payable
-def sendEth(to: address):
- # Example to send ETH
- # data = b"", empty data
- # value = msg.value, all of ETH that was sent to this function
- raw_call(to, b"", value=msg.value)
-
-
-diff: public(uint256)
-
-
-@external
-def testRawCallSub(to: address, x: uint256, y: uint256):
- res: Bytes[32] = raw_call(
- to,
- concat(
- method_id("testSub(uint256,uint256)"),
- convert(x, bytes32),
- convert(y, bytes32)
- ),
- max_outsize=32,
- )
-
- self.diff = convert(res, uint256)
-Vyper has a handy way to secure your contract from re-entrancy.
-A re-entrancy lock can be created on a function with @nonreentrant("lock").
Functions can be locked together by using the same name for the locks.
-# @version ^0.3.9
-
-
-@external
-@nonreentrant("lock")
-def func0():
- # call back msg.sender
- raw_call(msg.sender, b"", value=0)
-
-
-@external
-@nonreentrant("lock-2")
-def func1():
- raw_call(msg.sender, b"", value=0)
-
-
-@external
-@nonreentrant("lock-2")
-def func2():
- raw_call(msg.sender, b"", value=0)
-References types are data types that are passed by their reference, pointer to where the actual data is stored.
-# @version ^0.3.9
-
-
-struct Person:
- name: String[100]
- age: uint256
-
-
-# Fixed sized list
-nums: public(uint256[10]) # must be bounded
-myMap: public(HashMap[address, uint256])
-person: public(Person)
-
-
-@external
-def __init__():
- # This updates self.nums[0]
- self.nums[0] = 123
- self.nums[9] = 456
- # Copies self.nums to array in memory.
- # Does not modify referenced variable (self.nums)
- arr: uint256[10] = self.nums
- arr[0] = 123
-
- # This updates self.myMap
- self.myMap[msg.sender] = 1
- self.myMap[msg.sender] = 11
-
- # This updates self.person
- self.person.age = 11
- self.person.name = "Vyper"
- # Person struct is copied into memory.
- # Does not modify referenced variable (self.person)
- p: Person = self.person
- p.name = "Solidity"
-selfdestruct deletes the contract from the blockchain. It takes a single input, an address to send all of Ether stored in the contract.
# @version ^0.3.9
-
-
-@external
-@payable
-def __default__():
- pass
-
-
-@external
-def kill():
- selfdestruct(msg.sender)
-
-
-@external
-def burn():
- selfdestruct(ZERO_ADDRESS)
-There are two ways to send Ether from a contract, send and raw_call. Here we introduce the simpler function to use, send.
# @version ^0.3.9
-
-
-# Receive Ether into this contract
-@external
-@payable
-def __default__():
- pass
-
-
-@external
-def sendEther(to: address, amount: uint256):
- # when Ether is sent to a contract it will call
- # __default__ inside the receiving contract
- # forwards 2300 gas
- send(to, amount)
-
-
-@external
-def sendAll(to: address):
- send(to, self.balance)
-Critical math checks such as overflow, underflow and division by 0 can be skipped using unsafe functions
-# @version ^0.3.9
-
-
-@external
-def test_add(x: uint256, y: uint256) -> uint256:
- # 21510 gas
- # return x + y
-
- # 21472 gas
- return unsafe_add(x, y)
-
-
-@external
-def test_sub(x: uint256, y: uint256) -> uint256:
- # 21533 gas
- # return x - y
-
- # 21495 gas
- return unsafe_sub(x, y)
-
-
-@external
-def test_mul(x: uint256, y: uint256) -> uint256:
- # 21578 gas
- # return x * y
-
- # 21520 gas
- return unsafe_mul(x, y)
-
-
-@external
-def test_div(x: uint256, y: uint256) -> uint256:
- # 21578 gas
- # return x / y
-
- # 21543 gas
- return unsafe_div(x, y)
-Some values available in Vyper
-boolint128uint256decimalsaddressbytes32BytesString# @version ^0.3.9
-
-b: public(bool)
-i: public(int128) # -2 ** 127 to (2 ** 127 - 1)
-u: public(uint256) # 0 to 2 ** 256 - 1
-dec: public(decimal) # -2 ** 127 to (2 ** 127 - 1), 10 decimal places
-addr: public(address)
-b32: public(bytes32)
-bs: public(Bytes[100])
-s: public(String[100])
-
-
-@external
-def __init__():
- self.b = False
- self.i = -1
- self.u = 123
- self.dec = 3.14
- self.addr = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4
- self.b32 = 0xada1b75f8ae9a65dcc16f95678ac203030505c6b465c8206e26ae84b525cdacb
- self.bs = b"\\x01"
- self.s = "Hello Vyper"
-Signing and verifying signature takes 3 steps.
-# @version ^0.3.9
-
-
-# hash = getHash("Hello Vyper!")
-# 0x5436c86f18e3d25a10e557ae125450118dd0a481ca22112b1977d55a676e4c91
-@external
-@pure
-def getHash(_str: String[100]) -> bytes32:
- return keccak256(_str)
-
-
-# getEthSignedHash(hash)
-# 0x045b623a8e8fb7b4fcfbd1ae07e7326d55303d7de4085c69b346bd130c1936da
-@external
-@pure
-def getEthSignedHash(_hash: bytes32) -> bytes32:
- return keccak256(
- concat(
- b'\\x19Ethereum Signed Message:\\n32',
- _hash
- )
- )
-
-
-# account = your account
-# hash = getHash("Hello Vyper!")
-# signature = await ethereum.request({ method: "personal_sign", params: [account, hash]})
-@external
-@pure
-def recoverSigner(ethSignedHash: bytes32, sig: Bytes[65]) -> address:
- r: uint256 = convert(slice(sig, 0, 32), uint256)
- s: uint256 = convert(slice(sig, 32, 32), uint256)
- v: uint256 = convert(slice(sig, 64, 1), uint256)
- return ecrecover(ethSignedHash, v, r, s)
-
-
-@external
-@pure
-def verify(sig: Bytes[65], _str: String[100], _signer: address) -> bool:
- _hash: bytes32 = keccak256(_str)
- ethSignedHash: bytes32 = keccak256(
- concat(
- b'\\x19Ethereum Signed Message:\\n32',
- _hash
- )
- )
- r: uint256 = convert(slice(sig, 0, 32), uint256)
- s: uint256 = convert(slice(sig, 32, 32), uint256)
- v: uint256 = convert(slice(sig, 64, 1), uint256)
- signer: address = ecrecover(ethSignedHash, v, r, s)
-
- return _signer == signer
-Both pure and view functions are read only function, they cannot write anything to the blockchain.
pure functions do not read any state or global variables
view functions can read state variables, global variables and call internal functions.
# @version ^0.3.9
-
-num: public(uint256)
-
-# Pure functions does not read any state or global variables
-@external
-@pure
-def pureFunc(x: uint256) -> uint256:
- return x
-
-
-# View functions might read state or global state, or call an internal function
-@external
-@view
-def viewFunc(x: uint256) -> bool:
- return x > self.num
-
-
-@external
-@pure
-def sum(x: uint256, y: uint256, z: uint256) -> uint256:
- return x + y + z
-
-
-@external
-@view
-def addNum(x: uint256) -> uint256:
- return x + self.num
-