18 |
19 | {{ video.aggregate_likes }}
20 |
21 |
6 | {% for video in videos %}
7 | {% cycle '
23 | ' '' '' '' %}
8 |
' %}
21 | {% endfor %}
22 |
9 |
20 | {% cycle '' '' '' '
10 |
19 |
11 |
12 | 
13 |
14 |
15 |
18 |
13 |
31 |
14 |
30 | 15 | Packt Pub Decentralized Videos Sharing Application 16 |
17 | 29 |
6 |
12 |
16 |
17 |
22 |
45 |
23 |
43 |
44 |
6 |
12 |
63 |
13 | {% if upload_success %}
14 |
62 |
15 | Uploading video file is successful!
16 |
17 | {% endif %}
18 |
61 | 
4 |
5 | This is the code repository for [Hands-On Blockchain for Python Developers](https://www.packtpub.com/en-us/product/hands-on-blockchain-for-python-developers-9781805121367?utm_source=github&utm_medium=repository&utm_campaign=), published by Packt.
6 |
7 | **Empowering Python developers in the world of blockchain and smart contracts**
8 |
9 | ## What is this book about?
10 | We are living in the age of decentralized fi nance and NFTs. People swap tokens on Uniswap, borrow assets from Aave, send payments with stablecoins, trade art NFTs on OpenSea, and more. To build applications of this kind, you need to know how to write smart contracts.
11 |
12 | This book covers the following exciting features:
13 | * Understand blockchain and smart contracts
14 | * Learn how to write smart contracts with Vyper
15 | * Explore how to use the web3.py library and Ape Framework
16 | * Discover related technologies such as Layer 2 and IPFS
17 | * Gain a step-by-step guide to writing an automated market maker (AMM) decentralized exchange (DEX) smart contract
18 | * Build innovative, interactive, and token-gated Web3 NFT applications
19 |
20 | If you feel this book is for you, get your [copy](https://www.amazon.com/dp/1805121367) today!
21 |
22 | 
24 |
25 | ## Instructions and Navigations
26 | All of the code is organized into folders.
27 |
28 | The code will look like the following:
29 | ```
30 | from ape import accounts, project
31 | import os
32 | def main():
33 | password = os.environ["MY_PASSWORD"]
34 | dev = accounts.load("dev")
35 | dev.set_autosign(True, passphrase=password)
36 | contract = project.SimpleStorage.deploy(sender=dev)
37 | num_value = contract.retrieve.call()
38 | print(f"The num value is {num_value}")
39 | ```
40 |
41 | **Following is what you need for this book:**
42 | This blockchain book is for developers interested in understanding blockchain and smart contracts. It is suitable for both technology enthusiasts looking to explore blockchain technology and programmers who aspire to become smart contract engineers. Basic knowledge of GNU/Linux and Python programming is mandatory to get started with this book.
43 |
44 | With the following software and hardware list you can run all code files present in the book (Chapter 1-17).
45 | ### Software and Hardware List
46 | | Chapter | Software required | OS required |
47 | | -------- | ------------------------------------ | ----------------------------------- |
48 | | 1-17 | Python (minimum version 3.10 required) | Windows, Mac OS X, and Linux (Any) |
49 | | 1-17 | Vyper 0.3.10 (versions 0.4.x and above will not work) | Windows, Mac OS X, and Linux (Any) |
50 | | 1-17 | Ape Framework 0.7.23 (versions 0.8.x and above will not work) | Windows, Mac OS X, and Linux (Any) |
51 | | 1-17 | Modern browsers (Mozilla, Firefox, Chrome, etc) | Windows, Mac OS X, and Linux (Any) |
52 | | 1-17 | Remix | Windows, Mac OS X, and Linux (Any) |
53 | | 1-17 | Ganache | Windows, Mac OS X, and Linux (Any) |
54 | | 1-17 | Hardhat | Windows, Mac OS X, and Linux (Any) |
55 | | 1-17 | Geth | Windows, Mac OS X, and Linux (Any) |
56 | | 1-17 | Web3.py | Windows, Mac OS X, and Linux (Any) |
57 | | 1-17 | PySide 6 | Windows, Mac OS X, and Linux (Any) |
58 | | 1-17 | Kubo | Windows, Mac OS X, and Linux (Any) |
59 | | 1-17 | aioipfs | Windows, Mac OS X, and Linux (Any) |
60 | | 1-17 | Alchemy | Windows, Mac OS X, and Linux (Any) |
61 | | 1-17 | Infura | Windows, Mac OS X, and Linux (Any) |
62 | | 1-17 | Django | Windows, Mac OS X, and Linux (Any) |
63 | | 1-17 | FastAPI | Windows, Mac OS X, and Linux (Any) |
64 | | 1-17 | Node.js | Windows, Mac OS X, and Linux (Any) |
65 | | 1-17 | Pnpm | Windows, Mac OS X, and Linux (Any) |
66 | | 1-17 | React | Windows, Mac OS X, and Linux (Any) |
67 | | 1-17 | Wagmi | Windows, Mac OS X, and Linux (Any) |
68 | | 1-17 | MetaMask | Windows, Mac OS X, and Linux (Any) |
69 |
70 | ### Related products
71 | * Solidity Programming Essentials [[Packt]](https://www.packtpub.com/en-ar/product/solidity-programming-essentials-9781803231181?utm_source=github&utm_medium=repository&utm_campaign=9781839216862) [[Amazon]](https://www.amazon.com/dp/1803231181)
72 |
73 | * Applied Computational Thinking with Python [[Packt]](https://www.packtpub.com/en-IT/product/applied-computational-thinking-with-python-9781837632305?utm_source=github&utm_medium=repository&utm_campaign=9781803239545) [[Amazon]](https://www.amazon.com/dp/1837632308)
74 |
75 | ## Get to Know the Author
76 | **Arjuna Sky Kok**
77 | is a skilled software engineer with a passion for all things related to finance and
78 | technology. He lives in Jakarta, where he studied mathematics and programming at Binus University.
79 | Arjuna's academic achievements include double degrees in Computer Science and Mathematics.
80 | Currently, he is focusing his talent in the crypto space, as he believes that DeFi and NFT will serve as
81 | the foundation for future fi nance. He also has a keen interest in AI, especially Generative AI. Outside
82 | of work, Arjuna enjoys watching anime, listening to J-pop songs, and playing basketball.
83 |
--------------------------------------------------------------------------------
/chapter_17/token-gated-backend/token_gated_app.py:
--------------------------------------------------------------------------------
1 | from datetime import datetime, timedelta, timezone
2 | from string import Template
3 | import string
4 | import json
5 | import secrets
6 | import os
7 | from typing import Union
8 |
9 | from ape import Contract
10 | from ape import networks
11 | from ethpm_types import ContractType
12 |
13 | from fastapi import Depends, FastAPI, HTTPException, status
14 | from fastapi.security import OAuth2PasswordBearer
15 | from fastapi.middleware.cors import CORSMiddleware
16 | import jwt
17 | from pydantic import BaseModel
18 | from typing_extensions import Annotated
19 | from siwe import SiweMessage
20 | import siwe
21 |
22 | # to get a string like this run:
23 | # openssl rand -hex 32
24 | SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
25 | ALGORITHM = "HS256"
26 | ACCESS_TOKEN_EXPIRE_MINUTES = 30
27 |
28 | EIP_4361_STRING = Template("""
29 | packtpub.com wants you to sign in with your Ethereum account:
30 | $address
31 |
32 | I accept the PacktPub Terms of Service: https://www.packtpub.com/en-us/help/terms-and-conditions
33 |
34 | URI: http://127.0.0.1:8000/token
35 | Version: 1
36 | Chain ID: 1
37 | Nonce: $nonce
38 | Issued At: $nonce_time
39 | Resources:
40 | - https://github.com/PacktPublishing/Hands-On-Blockchain-for-Python-Developers--2nd-Edition
41 | """)
42 |
43 | nonces_data = {}
44 |
45 | oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
46 |
47 |
48 | class Token(BaseModel):
49 | access_token: str
50 | token_type: str
51 |
52 | class Nonce(BaseModel):
53 | nonce: str
54 | nonce_time: str
55 |
56 | class Crypto(BaseModel):
57 | address: str
58 | signature: str
59 |
60 | class User(BaseModel):
61 | address: str
62 |
63 | def create_access_token(data: dict, expires_delta: Union[timedelta, None] = None):
64 | to_encode = data.copy()
65 | if expires_delta:
66 | expire = datetime.now(timezone.utc) + expires_delta
67 | else:
68 | expire = datetime.now(timezone.utc) + timedelta(minutes=15)
69 | to_encode.update({"exp": expire})
70 | encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
71 | return encoded_jwt
72 |
73 | def generate_nonce(length=16):
74 | chars = string.ascii_letters + string.digits
75 | return ''.join(secrets.choice(chars) for _ in range(length))
76 |
77 |
78 | app = FastAPI()
79 |
80 | origins = [
81 | "http://localhost:5173",
82 | ]
83 |
84 | app.add_middleware(
85 | CORSMiddleware,
86 | allow_origins=origins,
87 | allow_credentials=True,
88 | allow_methods=["*"],
89 | allow_headers=["*"]
90 | )
91 |
92 |
93 | @app.get("/nonce/{address}")
94 | async def nonce(address: str) -> Nonce:
95 | nonce = generate_nonce()
96 | nonce_time = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
97 | nonces_data[address] = {"nonce": nonce, "nonce_time": nonce_time}
98 | return nonces_data[address]
99 |
100 | @app.post("/token")
101 | async def login_for_access_token(
102 | crypto: Crypto,
103 | ) -> Token:
104 | address = crypto.address
105 | nonce = nonces_data[address]["nonce"]
106 | nonce_time = nonces_data[address]["nonce_time"]
107 | signature = crypto.signature
108 | eip_string = EIP_4361_STRING.substitute(address=address, nonce=nonce, nonce_time=nonce_time)
109 | message = SiweMessage.from_message(message=eip_string, abnf=False)
110 | try:
111 | message.verify(signature=signature)
112 | access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
113 | access_token = create_access_token(
114 | data={"sub": address}, expires_delta=access_token_expires
115 | )
116 | return Token(access_token=access_token, token_type="bearer")
117 | except siwe.VerificationError:
118 | raise HTTPException(
119 | status_code=status.HTTP_401_UNAUTHORIZED,
120 | detail="Incorrect signature",
121 | headers={"WWW-Authenticate": "Bearer"},
122 | )
123 |
124 | async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
125 | credentials_exception = HTTPException(
126 | status_code=status.HTTP_401_UNAUTHORIZED,
127 | detail="Could not validate credentials",
128 | headers={"WWW-Authenticate": "Bearer"},
129 | )
130 | try:
131 | payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
132 | address: str = payload.get("sub")
133 | if address is None:
134 | raise credentials_exception
135 | except jwt.exceptions.InvalidSignatureError:
136 | raise credentials_exception
137 | exists = address in nonces_data
138 | if not exists:
139 | raise credentials_exception
140 | return User(address=address)
141 |
142 | async def get_current_active_user(
143 | current_user: Annotated[User, Depends(get_current_user)],
144 | ):
145 | return current_user
146 |
147 | @app.get("/me", response_model=User)
148 | async def read_users_me(
149 | current_user: Annotated[User, Depends(get_current_active_user)],
150 | ):
151 | return current_user
152 |
153 | BLOCKCHAIN_NETWORK = "local"
154 | BLOCKCHAIN_PROVIDER = "geth"
155 |
156 | @app.get("/content")
157 | async def read_content(
158 | current_user: Annotated[User, Depends(get_current_active_user)],
159 | ):
160 | with open('../token-gated-smart-contract/.build/HelloNFT.json') as f:
161 | contract = json.load(f)
162 | abi = contract['abi']
163 |
164 | nft_address = os.environ["NFT_ADDRESS"]
165 | with networks.ethereum[BLOCKCHAIN_NETWORK].use_provider(BLOCKCHAIN_PROVIDER):
166 | ct = ContractType.parse_obj({"abi": abi})
167 | NFTSmartContract = Contract(nft_address, ct)
168 | own_nft = NFTSmartContract.balanceOf(current_user.address) > 0
169 |
170 | if own_nft:
171 | return {"content": "Premium content"}
172 | else:
173 | return {"content": "Basic content"}
174 |
--------------------------------------------------------------------------------
/chapter_17/token-gated-blog/src/App.tsx:
--------------------------------------------------------------------------------
1 | import { useAccount, useConnect, useDisconnect, useSignMessage } from 'wagmi'
2 | import { useState, useEffect } from 'react';
3 |
4 | function App() {
5 | const account = useAccount()
6 | const { connectors, connect, status, error } = useConnect()
7 | const { disconnect } = useDisconnect()
8 | const { signMessageAsync } = useSignMessage()
9 | const message = `
10 | packtpub.com wants you to sign in with your Ethereum account:
11 | $address
12 |
13 | I accept the PacktPub Terms of Service: https://www.packtpub.com/en-us/help/terms-and-conditions
14 |
15 | URI: http://127.0.0.1:8000/token
16 | Version: 1
17 | Chain ID: 1
18 | Nonce: $nonce
19 | Issued At: $time
20 | Resources:
21 | - https://github.com/PacktPublishing/Hands-On-Blockchain-for-Python-Developers--2nd-Edition
22 | `;
23 |
24 | const [nonce, setNonce] = useState('')
25 | const [nonceTime, setNonceTime] = useState('')
26 | const [token, setToken] = useState('')
27 | const [signature, setSignature] = useState('')
28 | const [profile, setProfile] = useState('')
29 | const [content, setContent] = useState('')
30 | const fetchNonce = async () => {
31 | try {
32 | const address = account.addresses[0]
33 | const response = await fetch(`http://localhost:8000/nonce/${address}`,
34 | {method: 'GET',
35 | headers: {'Content-Type': 'application/json'},
36 | })
37 | const nonceData = await response.json()
38 | const nonceValue = nonceData.nonce
39 | const nonceTimeValue = nonceData.nonce_time
40 |
41 | setNonce(nonceValue)
42 | setNonceTime(nonceTimeValue)
43 | } catch (error) {
44 | console.error('Error fetching nonce:', error)
45 | }
46 | };
47 |
48 |
49 | return (
50 | <>
51 |
52 |
68 |
69 | Account
53 | 54 |
55 | status: {account.status}
56 |
57 | addresses: {JSON.stringify(account.addresses)} 58 |
59 | chainId: {account.chainId} 60 |
61 |
62 | {account.status === 'connected' && (
63 |
66 | )}
67 | 57 | addresses: {JSON.stringify(account.addresses)} 58 |
59 | chainId: {account.chainId} 60 |
70 |
83 |
84 | Connect
71 | {connectors.map((connector) => ( 72 | 79 | ))} 80 |{status}
81 | {error?.message}
82 |
85 |
94 |
95 | Nonce
86 | 92 |Nonce: {nonce}
93 |
96 |
118 |
119 | Sign Message
97 | 115 |Signature: {signature}
116 | Access Token: {token}
117 |
120 |
136 |
137 | Profile
121 | 134 |Profile: {profile}
135 |
138 |
154 |
155 | )
156 | }
157 |
158 | export default App
159 |
--------------------------------------------------------------------------------
/chapter_13/nft/contracts/HelloNFT.vy:
--------------------------------------------------------------------------------
1 | #pragma version ^0.3.0
2 |
3 | # Adapted from https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy
4 |
5 | from vyper.interfaces import ERC165
6 | from vyper.interfaces import ERC721
7 |
8 | implements: ERC721
9 | implements: ERC165
10 |
11 | event Transfer:
12 | _from: indexed(address)
13 | _to: indexed(address)
14 | _tokenId: indexed(uint256)
15 |
16 | event Approval:
17 | _owner: indexed(address)
18 | _approved: indexed(address)
19 | _tokenId: indexed(uint256)
20 |
21 | event ApprovalForAll:
22 | _owner: indexed(address)
23 | _operator: indexed(address)
24 | _approved: bool
25 |
26 | interface ERC721Receiver:
27 | def onERC721Received(
28 | _operator: address,
29 | _from: address,
30 | _tokenId: uint256,
31 | _data: Bytes[1024]
32 | ) -> bytes4: nonpayable
33 |
34 | name: public(String[32])
35 |
36 | symbol: public(String[32])
37 |
38 | idToOwner: HashMap[uint256, address]
39 |
40 | idToApprovals: HashMap[uint256, address]
41 |
42 | ownerToNFTokenCount: HashMap[address, uint256]
43 |
44 | ownerToOperators: HashMap[address, HashMap[address, bool]]
45 |
46 | minter: address
47 |
48 | baseURL: String[53]
49 |
50 | SUPPORTED_INTERFACES: constant(bytes4[2]) = [
51 | # ERC165 interface ID of ERC165
52 | 0x01ffc9a7,
53 | # ERC165 interface ID of ERC721
54 | 0x80ac58cd,
55 | ]
56 |
57 | @external
58 | def __init__():
59 | self.minter = msg.sender
60 | self.baseURL = "https://packtpub.com/metadata/"
61 | self.name = "Hello NFT"
62 | self.symbol = "HEL"
63 |
64 | @view
65 | @external
66 | def supportsInterface(interface_id: bytes4) -> bool:
67 | return interface_id in SUPPORTED_INTERFACES
68 |
69 | @view
70 | @external
71 | def balanceOf(_owner: address) -> uint256:
72 | assert _owner != empty(address)
73 | return self.ownerToNFTokenCount[_owner]
74 |
75 | @view
76 | @external
77 | def ownerOf(_tokenId: uint256) -> address:
78 | owner: address = self.idToOwner[_tokenId]
79 | assert owner != empty(address)
80 | return owner
81 |
82 | @view
83 | @external
84 | def getApproved(_tokenId: uint256) -> address:
85 | assert self.idToOwner[_tokenId] != empty(address)
86 | return self.idToApprovals[_tokenId]
87 |
88 | @view
89 | @external
90 | def isApprovedForAll(_owner: address, _operator: address) -> bool:
91 | return (self.ownerToOperators[_owner])[_operator]
92 |
93 | @view
94 | @internal
95 | def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
96 | owner: address = self.idToOwner[_tokenId]
97 | spenderIsOwner: bool = owner == _spender
98 | spenderIsApproved: bool = _spender == self.idToApprovals[_tokenId]
99 | spenderIsApprovedForAll: bool = (self.ownerToOperators[owner])[_spender]
100 | return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
101 |
102 | @internal
103 | def _addTokenTo(_to: address, _tokenId: uint256):
104 | assert self.idToOwner[_tokenId] == empty(address)
105 | self.idToOwner[_tokenId] = _to
106 | self.ownerToNFTokenCount[_to] += 1
107 |
108 | @internal
109 | def _removeTokenFrom(_from: address, _tokenId: uint256):
110 | assert self.idToOwner[_tokenId] == _from
111 | self.idToOwner[_tokenId] = empty(address)
112 | self.ownerToNFTokenCount[_from] -= 1
113 |
114 | @internal
115 | def _clearApproval(_owner: address, _tokenId: uint256):
116 | assert self.idToOwner[_tokenId] == _owner
117 | if self.idToApprovals[_tokenId] != empty(address):
118 | self.idToApprovals[_tokenId] = empty(address)
119 |
120 | @internal
121 | def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
122 | assert self._isApprovedOrOwner(_sender, _tokenId)
123 | assert _to != empty(address)
124 | self._clearApproval(_from, _tokenId)
125 | self._removeTokenFrom(_from, _tokenId)
126 | self._addTokenTo(_to, _tokenId)
127 | log Transfer(_from, _to, _tokenId)
128 |
129 | @external
130 | @payable
131 | def transferFrom(_from: address, _to: address, _tokenId: uint256):
132 | self._transferFrom(_from, _to, _tokenId, msg.sender)
133 |
134 | @external
135 | @payable
136 | def safeTransferFrom(
137 | _from: address,
138 | _to: address,
139 | _tokenId: uint256,
140 | _data: Bytes[1024]=b""
141 | ):
142 | self._transferFrom(_from, _to, _tokenId, msg.sender)
143 | if _to.is_contract:
144 | returnValue: bytes4 = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data)
145 | assert returnValue == method_id("onERC721Received(address,address,uint256,bytes)", output_type=bytes4)
146 |
147 | @external
148 | @payable
149 | def approve(_approved: address, _tokenId: uint256):
150 | owner: address = self.idToOwner[_tokenId]
151 | assert owner != empty(address)
152 | assert _approved != owner
153 | senderIsOwner: bool = self.idToOwner[_tokenId] == msg.sender
154 | senderIsApprovedForAll: bool = (self.ownerToOperators[owner])[msg.sender]
155 | assert (senderIsOwner or senderIsApprovedForAll)
156 | self.idToApprovals[_tokenId] = _approved
157 | log Approval(owner, _approved, _tokenId)
158 |
159 | @external
160 | def setApprovalForAll(_operator: address, _approved: bool):
161 | assert _operator != msg.sender
162 | self.ownerToOperators[msg.sender][_operator] = _approved
163 | log ApprovalForAll(msg.sender, _operator, _approved)
164 |
165 | @external
166 | def mint(_to: address, _tokenId: uint256) -> bool:
167 | assert msg.sender == self.minter
168 | assert _to != empty(address)
169 | self._addTokenTo(_to, _tokenId)
170 | log Transfer(empty(address), _to, _tokenId)
171 | return True
172 |
173 | @external
174 | def burn(_tokenId: uint256):
175 | assert self._isApprovedOrOwner(msg.sender, _tokenId)
176 | owner: address = self.idToOwner[_tokenId]
177 | assert owner != empty(address)
178 | self._clearApproval(owner, _tokenId)
179 | self._removeTokenFrom(owner, _tokenId)
180 | log Transfer(owner, empty(address), _tokenId)
181 |
182 | @view
183 | @external
184 | def tokenURI(tokenId: uint256) -> String[132]:
185 | return concat(self.baseURL, uint2str(tokenId))
186 |
--------------------------------------------------------------------------------
/chapter_14/nft_marketplace/contracts/HelloNFT.vy:
--------------------------------------------------------------------------------
1 | #pragma version ^0.3.0
2 |
3 | # Adapted from https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy
4 |
5 | from vyper.interfaces import ERC165
6 | from vyper.interfaces import ERC721
7 |
8 | implements: ERC721
9 | implements: ERC165
10 |
11 | event Transfer:
12 | _from: indexed(address)
13 | _to: indexed(address)
14 | _tokenId: indexed(uint256)
15 |
16 | event Approval:
17 | _owner: indexed(address)
18 | _approved: indexed(address)
19 | _tokenId: indexed(uint256)
20 |
21 | event ApprovalForAll:
22 | _owner: indexed(address)
23 | _operator: indexed(address)
24 | _approved: bool
25 |
26 | interface ERC721Receiver:
27 | def onERC721Received(
28 | _operator: address,
29 | _from: address,
30 | _tokenId: uint256,
31 | _data: Bytes[1024]
32 | ) -> bytes4: nonpayable
33 |
34 | name: public(String[32])
35 |
36 | symbol: public(String[32])
37 |
38 | idToOwner: HashMap[uint256, address]
39 |
40 | idToApprovals: HashMap[uint256, address]
41 |
42 | ownerToNFTokenCount: HashMap[address, uint256]
43 |
44 | ownerToOperators: HashMap[address, HashMap[address, bool]]
45 |
46 | minter: address
47 |
48 | baseURL: String[53]
49 |
50 | SUPPORTED_INTERFACES: constant(bytes4[2]) = [
51 | # ERC165 interface ID of ERC165
52 | 0x01ffc9a7,
53 | # ERC165 interface ID of ERC721
54 | 0x80ac58cd,
55 | ]
56 |
57 | @external
58 | def __init__():
59 | self.minter = msg.sender
60 | self.baseURL = "https://packtpub.com/metadata/"
61 | self.name = "Hello NFT"
62 | self.symbol = "HEL"
63 |
64 | @view
65 | @external
66 | def supportsInterface(interface_id: bytes4) -> bool:
67 | return interface_id in SUPPORTED_INTERFACES
68 |
69 | @view
70 | @external
71 | def balanceOf(_owner: address) -> uint256:
72 | assert _owner != empty(address)
73 | return self.ownerToNFTokenCount[_owner]
74 |
75 | @view
76 | @external
77 | def ownerOf(_tokenId: uint256) -> address:
78 | owner: address = self.idToOwner[_tokenId]
79 | assert owner != empty(address)
80 | return owner
81 |
82 | @view
83 | @external
84 | def getApproved(_tokenId: uint256) -> address:
85 | assert self.idToOwner[_tokenId] != empty(address)
86 | return self.idToApprovals[_tokenId]
87 |
88 | @view
89 | @external
90 | def isApprovedForAll(_owner: address, _operator: address) -> bool:
91 | return (self.ownerToOperators[_owner])[_operator]
92 |
93 | @view
94 | @internal
95 | def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
96 | owner: address = self.idToOwner[_tokenId]
97 | spenderIsOwner: bool = owner == _spender
98 | spenderIsApproved: bool = _spender == self.idToApprovals[_tokenId]
99 | spenderIsApprovedForAll: bool = (self.ownerToOperators[owner])[_spender]
100 | return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
101 |
102 | @internal
103 | def _addTokenTo(_to: address, _tokenId: uint256):
104 | assert self.idToOwner[_tokenId] == empty(address)
105 | self.idToOwner[_tokenId] = _to
106 | self.ownerToNFTokenCount[_to] += 1
107 |
108 | @internal
109 | def _removeTokenFrom(_from: address, _tokenId: uint256):
110 | assert self.idToOwner[_tokenId] == _from
111 | self.idToOwner[_tokenId] = empty(address)
112 | self.ownerToNFTokenCount[_from] -= 1
113 |
114 | @internal
115 | def _clearApproval(_owner: address, _tokenId: uint256):
116 | assert self.idToOwner[_tokenId] == _owner
117 | if self.idToApprovals[_tokenId] != empty(address):
118 | self.idToApprovals[_tokenId] = empty(address)
119 |
120 | @internal
121 | def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
122 | assert self._isApprovedOrOwner(_sender, _tokenId)
123 | assert _to != empty(address)
124 | self._clearApproval(_from, _tokenId)
125 | self._removeTokenFrom(_from, _tokenId)
126 | self._addTokenTo(_to, _tokenId)
127 | log Transfer(_from, _to, _tokenId)
128 |
129 | @external
130 | @payable
131 | def transferFrom(_from: address, _to: address, _tokenId: uint256):
132 | self._transferFrom(_from, _to, _tokenId, msg.sender)
133 |
134 | @external
135 | @payable
136 | def safeTransferFrom(
137 | _from: address,
138 | _to: address,
139 | _tokenId: uint256,
140 | _data: Bytes[1024]=b""
141 | ):
142 | self._transferFrom(_from, _to, _tokenId, msg.sender)
143 | if _to.is_contract:
144 | returnValue: bytes4 = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data)
145 | assert returnValue == method_id("onERC721Received(address,address,uint256,bytes)", output_type=bytes4)
146 |
147 | @external
148 | @payable
149 | def approve(_approved: address, _tokenId: uint256):
150 | owner: address = self.idToOwner[_tokenId]
151 | assert owner != empty(address)
152 | assert _approved != owner
153 | senderIsOwner: bool = self.idToOwner[_tokenId] == msg.sender
154 | senderIsApprovedForAll: bool = (self.ownerToOperators[owner])[msg.sender]
155 | assert (senderIsOwner or senderIsApprovedForAll)
156 | self.idToApprovals[_tokenId] = _approved
157 | log Approval(owner, _approved, _tokenId)
158 |
159 | @external
160 | def setApprovalForAll(_operator: address, _approved: bool):
161 | assert _operator != msg.sender
162 | self.ownerToOperators[msg.sender][_operator] = _approved
163 | log ApprovalForAll(msg.sender, _operator, _approved)
164 |
165 | @external
166 | def mint(_to: address, _tokenId: uint256) -> bool:
167 | assert msg.sender == self.minter
168 | assert _to != empty(address)
169 | self._addTokenTo(_to, _tokenId)
170 | log Transfer(empty(address), _to, _tokenId)
171 | return True
172 |
173 | @external
174 | def burn(_tokenId: uint256):
175 | assert self._isApprovedOrOwner(msg.sender, _tokenId)
176 | owner: address = self.idToOwner[_tokenId]
177 | assert owner != empty(address)
178 | self._clearApproval(owner, _tokenId)
179 | self._removeTokenFrom(owner, _tokenId)
180 | log Transfer(owner, empty(address), _tokenId)
181 |
182 | @view
183 | @external
184 | def tokenURI(tokenId: uint256) -> String[132]:
185 | return concat(self.baseURL, uint2str(tokenId))
186 |
--------------------------------------------------------------------------------
/chapter_17/token-gated-smart-contract/contracts/HelloNFT.vy:
--------------------------------------------------------------------------------
1 | #pragma version ^0.3.0
2 |
3 | # Adapted from https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy
4 |
5 | from vyper.interfaces import ERC165
6 | from vyper.interfaces import ERC721
7 |
8 | implements: ERC721
9 | implements: ERC165
10 |
11 | event Transfer:
12 | _from: indexed(address)
13 | _to: indexed(address)
14 | _tokenId: indexed(uint256)
15 |
16 | event Approval:
17 | _owner: indexed(address)
18 | _approved: indexed(address)
19 | _tokenId: indexed(uint256)
20 |
21 | event ApprovalForAll:
22 | _owner: indexed(address)
23 | _operator: indexed(address)
24 | _approved: bool
25 |
26 | interface ERC721Receiver:
27 | def onERC721Received(
28 | _operator: address,
29 | _from: address,
30 | _tokenId: uint256,
31 | _data: Bytes[1024]
32 | ) -> bytes4: nonpayable
33 |
34 | name: public(String[32])
35 |
36 | symbol: public(String[32])
37 |
38 | idToOwner: HashMap[uint256, address]
39 |
40 | idToApprovals: HashMap[uint256, address]
41 |
42 | ownerToNFTokenCount: HashMap[address, uint256]
43 |
44 | ownerToOperators: HashMap[address, HashMap[address, bool]]
45 |
46 | minter: address
47 |
48 | baseURL: String[53]
49 |
50 | SUPPORTED_INTERFACES: constant(bytes4[2]) = [
51 | # ERC165 interface ID of ERC165
52 | 0x01ffc9a7,
53 | # ERC165 interface ID of ERC721
54 | 0x80ac58cd,
55 | ]
56 |
57 | @external
58 | def __init__():
59 | self.minter = msg.sender
60 | self.baseURL = "https://packtpub.com/metadata/"
61 | self.name = "Hello NFT"
62 | self.symbol = "HEL"
63 |
64 | @view
65 | @external
66 | def supportsInterface(interface_id: bytes4) -> bool:
67 | return interface_id in SUPPORTED_INTERFACES
68 |
69 | @view
70 | @external
71 | def balanceOf(_owner: address) -> uint256:
72 | assert _owner != empty(address)
73 | return self.ownerToNFTokenCount[_owner]
74 |
75 | @view
76 | @external
77 | def ownerOf(_tokenId: uint256) -> address:
78 | owner: address = self.idToOwner[_tokenId]
79 | assert owner != empty(address)
80 | return owner
81 |
82 | @view
83 | @external
84 | def getApproved(_tokenId: uint256) -> address:
85 | assert self.idToOwner[_tokenId] != empty(address)
86 | return self.idToApprovals[_tokenId]
87 |
88 | @view
89 | @external
90 | def isApprovedForAll(_owner: address, _operator: address) -> bool:
91 | return (self.ownerToOperators[_owner])[_operator]
92 |
93 | @view
94 | @internal
95 | def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
96 | owner: address = self.idToOwner[_tokenId]
97 | spenderIsOwner: bool = owner == _spender
98 | spenderIsApproved: bool = _spender == self.idToApprovals[_tokenId]
99 | spenderIsApprovedForAll: bool = (self.ownerToOperators[owner])[_spender]
100 | return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
101 |
102 | @internal
103 | def _addTokenTo(_to: address, _tokenId: uint256):
104 | assert self.idToOwner[_tokenId] == empty(address)
105 | self.idToOwner[_tokenId] = _to
106 | self.ownerToNFTokenCount[_to] += 1
107 |
108 | @internal
109 | def _removeTokenFrom(_from: address, _tokenId: uint256):
110 | assert self.idToOwner[_tokenId] == _from
111 | self.idToOwner[_tokenId] = empty(address)
112 | self.ownerToNFTokenCount[_from] -= 1
113 |
114 | @internal
115 | def _clearApproval(_owner: address, _tokenId: uint256):
116 | assert self.idToOwner[_tokenId] == _owner
117 | if self.idToApprovals[_tokenId] != empty(address):
118 | self.idToApprovals[_tokenId] = empty(address)
119 |
120 | @internal
121 | def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
122 | assert self._isApprovedOrOwner(_sender, _tokenId)
123 | assert _to != empty(address)
124 | self._clearApproval(_from, _tokenId)
125 | self._removeTokenFrom(_from, _tokenId)
126 | self._addTokenTo(_to, _tokenId)
127 | log Transfer(_from, _to, _tokenId)
128 |
129 | @external
130 | @payable
131 | def transferFrom(_from: address, _to: address, _tokenId: uint256):
132 | self._transferFrom(_from, _to, _tokenId, msg.sender)
133 |
134 | @external
135 | @payable
136 | def safeTransferFrom(
137 | _from: address,
138 | _to: address,
139 | _tokenId: uint256,
140 | _data: Bytes[1024]=b""
141 | ):
142 | self._transferFrom(_from, _to, _tokenId, msg.sender)
143 | if _to.is_contract:
144 | returnValue: bytes4 = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data)
145 | assert returnValue == method_id("onERC721Received(address,address,uint256,bytes)", output_type=bytes4)
146 |
147 | @external
148 | @payable
149 | def approve(_approved: address, _tokenId: uint256):
150 | owner: address = self.idToOwner[_tokenId]
151 | assert owner != empty(address)
152 | assert _approved != owner
153 | senderIsOwner: bool = self.idToOwner[_tokenId] == msg.sender
154 | senderIsApprovedForAll: bool = (self.ownerToOperators[owner])[msg.sender]
155 | assert (senderIsOwner or senderIsApprovedForAll)
156 | self.idToApprovals[_tokenId] = _approved
157 | log Approval(owner, _approved, _tokenId)
158 |
159 | @external
160 | def setApprovalForAll(_operator: address, _approved: bool):
161 | assert _operator != msg.sender
162 | self.ownerToOperators[msg.sender][_operator] = _approved
163 | log ApprovalForAll(msg.sender, _operator, _approved)
164 |
165 | @external
166 | def mint(_to: address, _tokenId: uint256) -> bool:
167 | assert msg.sender == self.minter
168 | assert _to != empty(address)
169 | self._addTokenTo(_to, _tokenId)
170 | log Transfer(empty(address), _to, _tokenId)
171 | return True
172 |
173 | @external
174 | def burn(_tokenId: uint256):
175 | assert self._isApprovedOrOwner(msg.sender, _tokenId)
176 | owner: address = self.idToOwner[_tokenId]
177 | assert owner != empty(address)
178 | self._clearApproval(owner, _tokenId)
179 | self._removeTokenFrom(owner, _tokenId)
180 | log Transfer(owner, empty(address), _tokenId)
181 |
182 | @view
183 | @external
184 | def tokenURI(tokenId: uint256) -> String[132]:
185 | return concat(self.baseURL, uint2str(tokenId))
186 |
--------------------------------------------------------------------------------
/chapter_10/decentralized_videos/videos/models.py:
--------------------------------------------------------------------------------
1 | import os.path, json
2 | import asyncio
3 | import aioipfs
4 | import cv2
5 | import os
6 | from ape import accounts, Contract, project
7 | from ape import networks
8 | from ethpm_types import ContractType
9 | from ape_ethereum.transactions import Receipt
10 | from web3 import Web3, IPCProvider
11 | from decentralized_videos.settings import STATICFILES_DIRS, STATIC_URL, BASE_DIR, MEDIA_ROOT
12 |
13 | BLOCKCHAIN_NETWORK = "local"
14 | BLOCKCHAIN_PROVIDER = "geth"
15 |
16 | loop = asyncio.new_event_loop()
17 | asyncio.set_event_loop(loop)
18 |
19 | async def get(ipfs_path, download_path):
20 | client = aioipfs.AsyncIPFS()
21 |
22 | await client.get(ipfs_path, dstdir=download_path)
23 | await client.close()
24 |
25 | async def add(file_path):
26 | client = aioipfs.AsyncIPFS()
27 |
28 | files = [file_path]
29 | hash = None
30 | async for added_file in client.add(files):
31 | hash = added_file['Hash']
32 | await client.close()
33 | return hash
34 |
35 | class VideosSharing:
36 |
37 | def __init__(self):
38 | self.w3 = Web3(IPCProvider('/tmp/geth.ipc'))
39 | self.address = Web3.to_checksum_address(os.environ["VIDEO_SHARING_ADDRESS"])
40 |
41 | with open('../videos_sharing_smart_contract/.build/VideoSharing.json') as f:
42 | contract = json.load(f)
43 | self.abi = contract['abi']
44 |
45 | def recent_videos(self, amount=20):
46 | with networks.ethereum[BLOCKCHAIN_NETWORK].use_provider(BLOCKCHAIN_PROVIDER):
47 | ct = ContractType.parse_obj({"abi": self.abi})
48 | self.SmartContract = Contract(self.address, ct)
49 | events = self.SmartContract.UploadVideo.query("*", start_block=0)
50 |
51 | videos = []
52 | for event in events["event_arguments"]:
53 | video = {}
54 | video['user'] = event['_user']
55 | video['index'] = event['_index']
56 | video['path'] = self.get_video_path(video['user'], video['index'])
57 | video['title'] = self.get_video_title(video['user'], video['index'])
58 | video['thumbnail'] = self.get_video_thumbnail(video['path'])
59 | videos.append(video)
60 | videos.reverse()
61 | return videos[:amount]
62 |
63 | def get_video_path(self, user, index):
64 | with networks.ethereum[BLOCKCHAIN_NETWORK].use_provider(BLOCKCHAIN_PROVIDER):
65 | ct = ContractType.parse_obj({"abi": self.abi})
66 | self.SmartContract = Contract(self.address, ct)
67 | return self.SmartContract.videos_path(user, index)
68 |
69 | def get_video_title(self, user, index):
70 | with networks.ethereum[BLOCKCHAIN_NETWORK].use_provider(BLOCKCHAIN_PROVIDER):
71 | ct = ContractType.parse_obj({"abi": self.abi})
72 | self.SmartContract = Contract(self.address, ct)
73 | return self.SmartContract.videos_title(user, index)
74 |
75 | def get_video_thumbnail(self, ipfs_path):
76 | thumbnail_file = str(STATICFILES_DIRS[0]) + '/' + ipfs_path + '.png'
77 | url_file = STATIC_URL + '/' + ipfs_path + '.png'
78 | print(thumbnail_file)
79 |
80 | if os.path.isfile(thumbnail_file):
81 | return url_file
82 | else:
83 | return "https://bulma.io/images/placeholders/640x480.png"
84 |
85 | def get_video(self, user, index):
86 | video = {}
87 | ipfs_path = self.get_video_path(user, index)
88 | video_title = self.get_video_title(user, index)
89 | video_file = str(STATICFILES_DIRS[0]) + '/' + ipfs_path + '.mp4'
90 | thumbnail_file = str(STATICFILES_DIRS[0]) + '/' + ipfs_path + '.png'
91 | video['title'] = video_title
92 | video['user'] = user
93 | video['index'] = index
94 | with networks.ethereum[BLOCKCHAIN_NETWORK].use_provider(BLOCKCHAIN_PROVIDER):
95 | ct = ContractType.parse_obj({"abi": self.abi})
96 | self.SmartContract = Contract(self.address, ct)
97 | video['aggregate_likes'] = self.SmartContract.video_aggregate_likes(user, index)
98 |
99 | if os.path.isfile(video_file):
100 | video['url'] = STATIC_URL + '/' + ipfs_path + '.mp4'
101 | else:
102 | loop.run_until_complete(get(ipfs_path, str(BASE_DIR)))
103 | video['url'] = STATIC_URL + '/' + ipfs_path + '.mp4'
104 | os.rename(str(BASE_DIR) + '/' + ipfs_path, str(STATICFILES_DIRS[0]) + '/' + ipfs_path + '.mp4')
105 |
106 | if not os.path.isfile(thumbnail_file):
107 | self.process_thumbnail(ipfs_path)
108 |
109 | return video
110 |
111 | def upload_video(self, video_user, password, video_file, title):
112 | video_path = str(MEDIA_ROOT) + '/video.mp4'
113 | with open(video_path, 'wb+') as destination:
114 | for chunk in video_file.chunks():
115 | destination.write(chunk)
116 | ipfs_path = loop.run_until_complete(add(video_path))
117 | title = title[:19]
118 | with networks.ethereum[BLOCKCHAIN_NETWORK].use_provider(BLOCKCHAIN_PROVIDER):
119 | ct = ContractType.parse_obj({"abi": self.abi})
120 | self.SmartContract = Contract(self.address, ct)
121 | sender = accounts.load(video_user)
122 | sender.set_autosign(True, passphrase=password)
123 | self.SmartContract.upload_video(ipfs_path, title, sender=sender)
124 |
125 | def process_thumbnail(self, ipfs_path):
126 | thumbnail_file = str(STATICFILES_DIRS[0]) + '/' + ipfs_path + '.png'
127 | if not os.path.isfile(thumbnail_file):
128 | video_path = str(STATICFILES_DIRS[0]) + '/' + ipfs_path + '.mp4'
129 | cap = cv2.VideoCapture(video_path)
130 | cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
131 | _, frame = cap.read()
132 | cv2.imwrite(thumbnail_file, frame)
133 |
134 | def like_video(self, video_liker, password, video_user, index):
135 | with networks.ethereum[BLOCKCHAIN_NETWORK].use_provider(BLOCKCHAIN_PROVIDER):
136 | ct = ContractType.parse_obj({"abi": self.abi})
137 | self.SmartContract = Contract(self.address, ct)
138 | sender = accounts.load(video_liker)
139 | if self.SmartContract.video_has_been_liked(sender.address, video_user, index):
140 | return
141 | sender.set_autosign(True, passphrase=password)
142 | self.SmartContract.like_video(video_user, index, sender=sender)
143 |
144 |
145 | videos_sharing = VideosSharing()
146 |
--------------------------------------------------------------------------------
/chapter_15/vault/contracts/Vault.vy:
--------------------------------------------------------------------------------
1 | #pragma version ^0.3.0
2 |
3 | # From https://github.com/fubuloubu/ERC4626/blob/main/contracts/VyperVault.vy
4 |
5 | from vyper.interfaces import ERC20
6 | from vyper.interfaces import ERC4626
7 |
8 | implements: ERC20
9 | implements: ERC4626
10 |
11 | ##### ERC20 #####
12 |
13 | totalSupply: public(uint256)
14 | balanceOf: public(HashMap[address, uint256])
15 | allowance: public(HashMap[address, HashMap[address, uint256]])
16 |
17 | NAME: constant(String[11]) = "Hello Vault"
18 | SYMBOL: constant(String[6]) = "vHELLO"
19 | DECIMALS: constant(uint8) = 18
20 |
21 | event Transfer:
22 | sender: indexed(address)
23 | receiver: indexed(address)
24 | amount: uint256
25 |
26 | event Approval:
27 | owner: indexed(address)
28 | spender: indexed(address)
29 | allowance: uint256
30 |
31 | ##### ERC4626 #####
32 |
33 | asset: public(ERC20)
34 |
35 | event Deposit:
36 | depositor: indexed(address)
37 | receiver: indexed(address)
38 | assets: uint256
39 | shares: uint256
40 |
41 | event Withdraw:
42 | withdrawer: indexed(address)
43 | receiver: indexed(address)
44 | owner: indexed(address)
45 | assets: uint256
46 | shares: uint256
47 |
48 |
49 | @external
50 | def __init__(asset: ERC20):
51 | self.asset = asset
52 |
53 |
54 | @view
55 | @external
56 | def name() -> String[11]:
57 | return NAME
58 |
59 |
60 | @view
61 | @external
62 | def symbol() -> String[6]:
63 | return SYMBOL
64 |
65 |
66 | @view
67 | @external
68 | def decimals() -> uint8:
69 | return DECIMALS
70 |
71 |
72 | @external
73 | def transfer(receiver: address, amount: uint256) -> bool:
74 | self.balanceOf[msg.sender] -= amount
75 | self.balanceOf[receiver] += amount
76 | log Transfer(msg.sender, receiver, amount)
77 | return True
78 |
79 |
80 | @external
81 | def approve(spender: address, amount: uint256) -> bool:
82 | self.allowance[msg.sender][spender] = amount
83 | log Approval(msg.sender, spender, amount)
84 | return True
85 |
86 |
87 | @external
88 | def transferFrom(sender: address, receiver: address, amount: uint256) -> bool:
89 | self.allowance[sender][msg.sender] -= amount
90 | self.balanceOf[sender] -= amount
91 | self.balanceOf[receiver] += amount
92 | log Transfer(sender, receiver, amount)
93 | return True
94 |
95 |
96 | @view
97 | @external
98 | def totalAssets() -> uint256:
99 | return self.asset.balanceOf(self)
100 |
101 |
102 | @view
103 | @internal
104 | def _convertToAssets(shareAmount: uint256) -> uint256:
105 | totalSupply: uint256 = self.totalSupply
106 | if totalSupply == 0:
107 | return 0
108 |
109 | return shareAmount * self.asset.balanceOf(self) / totalSupply
110 |
111 |
112 | @view
113 | @external
114 | def convertToAssets(shareAmount: uint256) -> uint256:
115 | return self._convertToAssets(shareAmount)
116 |
117 |
118 | @view
119 | @internal
120 | def _convertToShares(assetAmount: uint256) -> uint256:
121 | totalSupply: uint256 = self.totalSupply
122 | totalAssets: uint256 = self.asset.balanceOf(self)
123 | if totalAssets == 0 or totalSupply == 0:
124 | return assetAmount # 1:1 price
125 |
126 | return assetAmount * totalSupply / totalAssets
127 |
128 |
129 | @view
130 | @external
131 | def convertToShares(assetAmount: uint256) -> uint256:
132 | return self._convertToShares(assetAmount)
133 |
134 |
135 | @view
136 | @external
137 | def maxDeposit(owner: address) -> uint256:
138 | return MAX_UINT256
139 |
140 |
141 | @view
142 | @external
143 | def previewDeposit(assets: uint256) -> uint256:
144 | return self._convertToShares(assets)
145 |
146 |
147 | @external
148 | def deposit(assets: uint256, receiver: address=msg.sender) -> uint256:
149 | shares: uint256 = self._convertToShares(assets)
150 | self.asset.transferFrom(msg.sender, self, assets)
151 |
152 | self.totalSupply += shares
153 | self.balanceOf[receiver] += shares
154 | log Transfer(empty(address), receiver, shares)
155 | log Deposit(msg.sender, receiver, assets, shares)
156 | return shares
157 |
158 |
159 | @view
160 | @external
161 | def maxMint(owner: address) -> uint256:
162 | return MAX_UINT256
163 |
164 |
165 | @view
166 | @external
167 | def previewMint(shares: uint256) -> uint256:
168 | assets: uint256 = self._convertToAssets(shares)
169 |
170 | # NOTE: Vyper does lazy eval on if, so this avoids SLOADs most of the time
171 | if assets == 0 and self.asset.balanceOf(self) == 0:
172 | return shares # NOTE: Assume 1:1 price if nothing deposited yet
173 |
174 | return assets
175 |
176 |
177 | @external
178 | def mint(shares: uint256, receiver: address=msg.sender) -> uint256:
179 | assets: uint256 = self._convertToAssets(shares)
180 |
181 | if assets == 0 and self.asset.balanceOf(self) == 0:
182 | assets = shares # NOTE: Assume 1:1 price if nothing deposited yet
183 |
184 | self.asset.transferFrom(msg.sender, self, assets)
185 |
186 | self.totalSupply += shares
187 | self.balanceOf[receiver] += shares
188 | log Transfer(empty(address), receiver, shares)
189 | log Deposit(msg.sender, receiver, assets, shares)
190 | return assets
191 |
192 |
193 | @view
194 | @external
195 | def maxWithdraw(owner: address) -> uint256:
196 | return MAX_UINT256 # real max is `self.asset.balanceOf(self)`
197 |
198 |
199 | @view
200 | @external
201 | def previewWithdraw(assets: uint256) -> uint256:
202 | shares: uint256 = self._convertToShares(assets)
203 |
204 | # NOTE: Vyper does lazy eval on if, so this avoids SLOADs most of the time
205 | if shares == assets and self.totalSupply == 0:
206 | return 0 # NOTE: Nothing to redeem
207 |
208 | return shares
209 |
210 |
211 | @external
212 | def withdraw(assets: uint256, receiver: address=msg.sender, owner: address=msg.sender) -> uint256:
213 | shares: uint256 = self._convertToShares(assets)
214 |
215 | # NOTE: Vyper does lazy eval on if, so this avoids SLOADs most of the time
216 | if shares == assets and self.totalSupply == 0:
217 | raise # Nothing to redeem
218 |
219 | if owner != msg.sender:
220 | self.allowance[owner][msg.sender] -= shares
221 |
222 | self.totalSupply -= shares
223 | self.balanceOf[owner] -= shares
224 |
225 | self.asset.transfer(receiver, assets)
226 | log Transfer(owner, empty(address), shares)
227 | log Withdraw(msg.sender, receiver, owner, assets, shares)
228 | return shares
229 |
230 |
231 | @view
232 | @external
233 | def maxRedeem(owner: address) -> uint256:
234 | return MAX_UINT256 # real max is `self.totalSupply`
235 |
236 |
237 | @view
238 | @external
239 | def previewRedeem(shares: uint256) -> uint256:
240 | return self._convertToAssets(shares)
241 |
242 |
243 | @external
244 | def redeem(shares: uint256, receiver: address=msg.sender, owner: address=msg.sender) -> uint256:
245 | if owner != msg.sender:
246 | self.allowance[owner][msg.sender] -= shares
247 |
248 | assets: uint256 = self._convertToAssets(shares)
249 | self.totalSupply -= shares
250 | self.balanceOf[owner] -= shares
251 |
252 | self.asset.transfer(receiver, assets)
253 | log Transfer(owner, empty(address), shares)
254 | log Withdraw(msg.sender, receiver, owner, assets, shares)
255 | return assets
256 |
257 |
--------------------------------------------------------------------------------
/chapter_15/vault/contracts/LendingVault.vy:
--------------------------------------------------------------------------------
1 | #pragma version ^0.3.0
2 |
3 | # From https://github.com/fubuloubu/ERC4626/blob/main/contracts/VyperVault.vy
4 |
5 | event Lend:
6 | _borrower: indexed(address)
7 | _amount: indexed(uint256)
8 |
9 | event Repay:
10 | _borrower: indexed(address)
11 | _amount: indexed(uint256)
12 |
13 | loan_amount: public(uint256)
14 | collateral: public(uint256)
15 | borrower: public(address)
16 | loan_taken: public(bool)
17 | interest: public(uint256)
18 | owner: public(address)
19 |
20 | from vyper.interfaces import ERC20
21 | from vyper.interfaces import ERC4626
22 |
23 | implements: ERC20
24 | implements: ERC4626
25 |
26 | ##### ERC20 #####
27 |
28 | totalSupply: public(uint256)
29 | balanceOf: public(HashMap[address, uint256])
30 | allowance: public(HashMap[address, HashMap[address, uint256]])
31 |
32 | NAME: constant(String[11]) = "Hello Vault"
33 | SYMBOL: constant(String[6]) = "vHELLO"
34 | DECIMALS: constant(uint8) = 18
35 |
36 | event Transfer:
37 | sender: indexed(address)
38 | receiver: indexed(address)
39 | amount: uint256
40 |
41 | event Approval:
42 | owner: indexed(address)
43 | spender: indexed(address)
44 | allowance: uint256
45 |
46 | ##### ERC4626 #####
47 |
48 | asset: public(ERC20)
49 |
50 | event Deposit:
51 | depositor: indexed(address)
52 | receiver: indexed(address)
53 | assets: uint256
54 | shares: uint256
55 |
56 | event Withdraw:
57 | withdrawer: indexed(address)
58 | receiver: indexed(address)
59 | owner: indexed(address)
60 | assets: uint256
61 | shares: uint256
62 |
63 |
64 | @external
65 | def __init__(asset: ERC20,
66 | _borrower: address,
67 | _loan_amount: uint256,
68 | _collateral: uint256,
69 | _interest: uint256):
70 | self.asset = asset
71 | self.loan_amount = _loan_amount
72 | self.collateral = _collateral
73 | self.borrower = _borrower
74 | self.interest = _interest
75 | self.owner = msg.sender
76 |
77 |
78 | @view
79 | @external
80 | def name() -> String[11]:
81 | return NAME
82 |
83 |
84 | @view
85 | @external
86 | def symbol() -> String[6]:
87 | return SYMBOL
88 |
89 |
90 | @view
91 | @external
92 | def decimals() -> uint8:
93 | return DECIMALS
94 |
95 |
96 | @external
97 | def transfer(receiver: address, amount: uint256) -> bool:
98 | self.balanceOf[msg.sender] -= amount
99 | self.balanceOf[receiver] += amount
100 | log Transfer(msg.sender, receiver, amount)
101 | return True
102 |
103 |
104 | @external
105 | def approve(spender: address, amount: uint256) -> bool:
106 | self.allowance[msg.sender][spender] = amount
107 | log Approval(msg.sender, spender, amount)
108 | return True
109 |
110 |
111 | @external
112 | def transferFrom(sender: address, receiver: address, amount: uint256) -> bool:
113 | self.allowance[sender][msg.sender] -= amount
114 | self.balanceOf[sender] -= amount
115 | self.balanceOf[receiver] += amount
116 | log Transfer(sender, receiver, amount)
117 | return True
118 |
119 |
120 | @view
121 | @external
122 | def totalAssets() -> uint256:
123 | return self.asset.balanceOf(self)
124 |
125 |
126 | @view
127 | @internal
128 | def _convertToAssets(shareAmount: uint256) -> uint256:
129 | totalSupply: uint256 = self.totalSupply
130 | if totalSupply == 0:
131 | return 0
132 |
133 | return shareAmount * self.asset.balanceOf(self) / totalSupply
134 |
135 |
136 | @view
137 | @external
138 | def convertToAssets(shareAmount: uint256) -> uint256:
139 | return self._convertToAssets(shareAmount)
140 |
141 |
142 | @view
143 | @internal
144 | def _convertToShares(assetAmount: uint256) -> uint256:
145 | totalSupply: uint256 = self.totalSupply
146 | totalAssets: uint256 = self.asset.balanceOf(self)
147 | if totalAssets == 0 or totalSupply == 0:
148 | return assetAmount # 1:1 price
149 |
150 | return assetAmount * totalSupply / totalAssets
151 |
152 |
153 | @view
154 | @external
155 | def convertToShares(assetAmount: uint256) -> uint256:
156 | return self._convertToShares(assetAmount)
157 |
158 |
159 | @view
160 | @external
161 | def maxDeposit(owner: address) -> uint256:
162 | return MAX_UINT256
163 |
164 |
165 | @view
166 | @external
167 | def previewDeposit(assets: uint256) -> uint256:
168 | return self._convertToShares(assets)
169 |
170 |
171 | @external
172 | def deposit(assets: uint256, receiver: address=msg.sender) -> uint256:
173 | shares: uint256 = self._convertToShares(assets)
174 | self.asset.transferFrom(msg.sender, self, assets)
175 |
176 | self.totalSupply += shares
177 | self.balanceOf[receiver] += shares
178 | log Transfer(empty(address), receiver, shares)
179 | log Deposit(msg.sender, receiver, assets, shares)
180 | return shares
181 |
182 |
183 | @view
184 | @external
185 | def maxMint(owner: address) -> uint256:
186 | return MAX_UINT256
187 |
188 |
189 | @view
190 | @external
191 | def previewMint(shares: uint256) -> uint256:
192 | assets: uint256 = self._convertToAssets(shares)
193 |
194 | # NOTE: Vyper does lazy eval on if, so this avoids SLOADs most of the time
195 | if assets == 0 and self.asset.balanceOf(self) == 0:
196 | return shares # NOTE: Assume 1:1 price if nothing deposited yet
197 |
198 | return assets
199 |
200 |
201 | @external
202 | def mint(shares: uint256, receiver: address=msg.sender) -> uint256:
203 | assets: uint256 = self._convertToAssets(shares)
204 |
205 | if assets == 0 and self.asset.balanceOf(self) == 0:
206 | assets = shares # NOTE: Assume 1:1 price if nothing deposited yet
207 |
208 | self.asset.transferFrom(msg.sender, self, assets)
209 |
210 | self.totalSupply += shares
211 | self.balanceOf[receiver] += shares
212 | log Transfer(empty(address), receiver, shares)
213 | log Deposit(msg.sender, receiver, assets, shares)
214 | return assets
215 |
216 |
217 | @view
218 | @external
219 | def maxWithdraw(owner: address) -> uint256:
220 | return MAX_UINT256 # real max is `self.asset.balanceOf(self)`
221 |
222 |
223 | @view
224 | @external
225 | def previewWithdraw(assets: uint256) -> uint256:
226 | shares: uint256 = self._convertToShares(assets)
227 |
228 | # NOTE: Vyper does lazy eval on if, so this avoids SLOADs most of the time
229 | if shares == assets and self.totalSupply == 0:
230 | return 0 # NOTE: Nothing to redeem
231 |
232 | return shares
233 |
234 |
235 | @external
236 | def withdraw(assets: uint256, receiver: address=msg.sender, owner: address=msg.sender) -> uint256:
237 | shares: uint256 = self._convertToShares(assets)
238 |
239 | # NOTE: Vyper does lazy eval on if, so this avoids SLOADs most of the time
240 | if shares == assets and self.totalSupply == 0:
241 | raise # Nothing to redeem
242 |
243 | if owner != msg.sender:
244 | self.allowance[owner][msg.sender] -= shares
245 |
246 | self.totalSupply -= shares
247 | self.balanceOf[owner] -= shares
248 |
249 | self.asset.transfer(receiver, assets)
250 | log Transfer(owner, empty(address), shares)
251 | log Withdraw(msg.sender, receiver, owner, assets, shares)
252 | return shares
253 |
254 |
255 | @view
256 | @external
257 | def maxRedeem(owner: address) -> uint256:
258 | return MAX_UINT256 # real max is `self.totalSupply`
259 |
260 |
261 | @view
262 | @external
263 | def previewRedeem(shares: uint256) -> uint256:
264 | return self._convertToAssets(shares)
265 |
266 |
267 | @external
268 | def redeem(shares: uint256, receiver: address=msg.sender, owner: address=msg.sender) -> uint256:
269 | if owner != msg.sender:
270 | self.allowance[owner][msg.sender] -= shares
271 |
272 | assets: uint256 = self._convertToAssets(shares)
273 | self.totalSupply -= shares
274 | self.balanceOf[owner] -= shares
275 |
276 | self.asset.transfer(receiver, assets)
277 | log Transfer(owner, empty(address), shares)
278 | log Withdraw(msg.sender, receiver, owner, assets, shares)
279 | return assets
280 |
281 |
282 | @external
283 | @payable
284 | def borrow():
285 | assert msg.sender == self.borrower, "Only the borrower can borrow the asset"
286 | assert msg.value == self.collateral, "Collateral is not enough"
287 | self.asset.transfer(msg.sender, self.loan_amount)
288 | self.loan_taken = True
289 |
290 | log Lend(msg.sender, self.loan_amount)
291 |
292 |
293 | @external
294 | def repay():
295 | assert msg.sender == self.borrower, "Only the borrower can repay the loan"
296 | assert self.loan_taken == True, "Loan has not been taken"
297 |
298 | cut: uint256 = self.interest * self.collateral / 100
299 | payback: uint256 = self.collateral - cut
300 |
301 | self.asset.transferFrom(msg.sender, self, self.loan_amount)
302 | send(msg.sender, payback)
303 |
304 | self.loan_taken = False
305 |
306 | log Repay(msg.sender, self.loan_amount)
307 |
--------------------------------------------------------------------------------
Content
139 | 152 |Content: {content}
153 |