Are you ready to dive headfirst into the exciting world of blockchain technology? Buckle up because we're about to embark on an electrifying journey through the Tezos ecosystem, where you'll unlock the secrets of decentralized finance (DeFi), Proof of Stake, NFTs, and so much more!
We will start from the ground up and demystify the blockchain concept. Whether you're a beginner or a blockchain enthusiast, we've got something for everyone.
Ever wondered how Tezos maintains its secure and energy-efficient network? Uncover the inner workings of Proof of Stake consensus and learn how you can become a part of it.
Dive into the world of Non-Fungible Tokens (NFTs) and understand how Tezos is empowering artists, creators, and collectors to redefine ownership in the digital age.
Discover the future of finance as we explore how Tezos is revolutionizing the way we manage and exchange digital assets. Get ready to explore yield farming, lending, and much more!
Learn how to leverage Tezos' smart contract capabilities to design and deploy your very own decentralized applications. Whether it's a DeFi protocol, a gaming platform, or a revolutionary social network, you'll acquire the skills needed to bring your DApp ideas to life.
Understand how to integrate your DApps with existing Tezos projects and collaborate within the vibrant Tezos developer community. This is your chance to tap into the collective wisdom of Tezos enthusiasts and expand your horizons.
Explore real-world examples of Tezos DApps that are making waves in various industries. From finance to entertainment, Tezos DApps are driving innovation and redefining how we interact with technology.
Our interactive sessions and practical exercises will ensure you gain a deep understanding of smart contract and DApp development on Tezos. You'll leave with the confidence to create, deploy, and maintain your own Web3 project on the Tezos Blockchain.
So, if you've ever dreamt of creating the next big thing in the decentralized world and an the most advanced blockchain in the industry this tutorial is your golden ticket. Get ready to turn your DApp dreams into reality and be a pioneer in the Tezos ecosystem!
Join us for this dynamic Tezos journey, where you'll not only learn but also actively participate in shaping the decentralized future. The possibilities are limitless, and your imagination is your only constraint.
You'll be guided by seasoned experts who have a passion for blockchain and a knack for simplifying complex concepts. Their energy and enthusiasm are contagious, making learning a truly exhilarating experience.
Whether you're a developer or entrepreneur, or just someone curious about the blockchain revolution, this tutorial is tailor-made for you. By the end of this journey, you'll not only understand Tezos but also be equipped with the knowledge to make informed decisions in the rapidly evolving blockchain landscape.
So, grab your virtual seats, fuel up on curiosity, and let's embark on this Tezos adventure together! 🌐🚀
Get ready to unlock the power of Tezos and redefine what's possible in the world of blockchain. The future is decentralized, and you're about to become a part of it!
🚀 Let's ignite the decentralized revolution on Tezos! 🚀
🚀 And Much, Much More: From smart contracts to governance mechanisms, we've got a treasure trove of Tezos knowledge to share!
- Follow the repository: While going through the course be 100% certain to follow along with the github repository.
- Be Active in the community: Ask questions and engage with other developers going through the course in the discussions tab, be sure to go and say hello or gm! This space is different from the other industries, you don't have to be secretive; communicate, network and learn with others :)
- Learn at your own pace: It doesn't matter if it takes you a day, a week, a month or even a year. Progress >>> Perfection
- Take Breaks: You will exhaust your mind and recall less if you go all out and watch the entire course in one sitting. Suggested Strategy every 30 minutes take a 5 min break, and every 2 hours take a longer 30 min break
- Refer to Documentation: Things are constantly being updated, so whenever our instructors open up some documentation, open it your end and maybe even have the code sample next to you.
- Tezos: the blockchain website
- OpenTezos: explore the technical and economic concepts behind the Tezos Network
- Tezos Foundation Grant Program: a key activity of the Tezos Foundation is to deploy resources to entities and initiatives that will help to ensure the long-term success of the Tezos blockchain.
- Kukai Wallet: a specific Tezos Wallet
- SmartPy: a comprehensive solution for developing, testing, and deploying smart contracts on the Tezos blockchain
- Tezos Faucet: get Tez on the Ghostnet Network
-
Basic programming skills
-
🐍 Python Knowledge - it is helpful but not required
-
Prior blockchain experience
- Community Building
- New Features in Gaming
- New Art Scene for Artists
- New Financial Products
- Raising Funds:
- Introduction to the Tezos Blockchain
- History of Tezos
- Tezos, Tez, XTZ
- Overview of the Key Elements of Tezos
- Accounts
- Transactions
- Smart Contracts
- Blockchain
- Wallets
- Nodes
- Bakers
- Wallet Set Up
- Seed Phrase, Keys, Password
- Funding your Account with “Fake” Tez
- Transfer Tez between Accounts
- Check Operations on Tezos Blockchain Explorers
- Finality of Transactions
- Benefits of Developing on Tezos
- Being Part of the Tezos Ecosystem
- Smart Contracts with SmartPy
- Reminder: What is a Smart Contract
- Smart Contract Structure & Deployment
- Syntax
- Indentation Syntax
- Example: Store Value Contract
- Adding a Test Scenario
- Adding a Test Scenario to Contract
- Write and Deploy your First Smart Contract
- Deploy your Contract on Ghostnet
- Eternity and Immutability
- Entrypoints
- Accessing, Modifying the Storage
- Example: Flip Value Contract Accessing, Modifying the Storage
- Calling the Entrypoint from the Test
- Example Flip Value: Calling the Entrypoint from the Test
- Automating Tests
- Exercise: Count the Calls
- Solution: Count The Calls Solution
- Bonus: Count The Calls with Verifications
- Real tests: Full List of What we Can Do
- Importance of Testing
- Syntax: Entrypoint with a Parameter
- Example: Store Value with Entrypoint with Parameter
- Types: Int and Nat
- Type Inference
- Ways to Help Type Inference
- Exercise: Find the Bug and Fix it
- No Overflows
- Practical Limits and Storage Costs
- Exercise : Store Value with Entrypoint with Parameter
- Solution: Store Value with Entrypoint with Parameter
- Introduction to strings
- Exercise: Endless Wall Contract
- Solution: Endless Wall
- Introduction to Verifications
- Failures
- Comparisons in SmartPy
- Boolean Conditions in SmartPy
- Failures Should be Tested
- Example: Adding Verification to Store Value
- Errors Don’t Have to Be Strings
- Exercise: Endless Wall with Verifications
- Solution: Endless Wall with Verifications
- Interact with Endless Wall Contract
- Checking an Operation
- Recap
- Using trace()
- Syntax: Multiple Values in Storage & Parameter
- Example: Multiple Values in Storage & Parameter
- Exercise: Endless Wall with Counter
- Solution: Endless Wall with Counter
- History of Smart Contracts
- Introduction to Manipulating Addresses
- Addresses in SmartPy
- Addresses in Tests
- Example: storeValue with addresses
- Exercise: Endless Wall with Restrictions
- Solution: Endless Wall with Restrictions
- Smart Contracts are Powerful
- NFT Concept
- NFT Use Cases
- Exercise: Create Your Own Single NFT
- Single NFT Hints
- Solultion Create Your Own Single NFT
- Beyond a Basic NFT Contract
- Tez as a Tool for Trust
- Endless Wall with a Paywall
- Sending Funds to a Smart Contract
- Sending Tez: Transactions/Addresses
- Testing Transfers of Tez
- Example: EndlessWall with Paywall
- Adding Buy Feature to Single NFT Contract
- Trust Issue for Basic Transactions
- How the Blockchain Solves Trust Issue?
- Exercice: Adding Buy Feature to Single NFT Contract
- Solution: Adding Buy Feature to Single NFT Contract
- Introduction to Options
- Using Options
- Syntax Options
- Creating an Option
- Comparing Options
- Opening an Option
- Options in Tests
- Type of an Option
- Don’t Overuse Options
- Use Options if There is no Better Choice
- Exercise: NFT not for Sale
- Solution: NFT not for Sale
- Introduction to Blockchains and Time
- The Time Dilemma
- Timestamps
- Timestamp Type
- Syntax Timestamps
- Timestamps and Testing
- Example: Endless Wall with Deadline
- Exercise: NFT with Time Restriction
- Solution: NFT with Time Restriction
- Recap: Benefits of a Smart Contract
- Syntax: Arithmetic Operators
- Types: Arithmetic Operators
- Type Conversions: Nat, Int & Mutez
- Example: Arithmetic Operators
- Example: Mutez and Arithmetic Operators
- Pairs
- Type Conversions: Nat, Int & Mutez
- How to Compute a Price Percentage in SmartPy?
- Example: Yield Farming Contract, First Defi Contract
- Exercise: NFT with an Increasing Price
- Default() Entrypoint
- Exercise: Basic NFT with Royalties
- Solution: Basic NFT with Royalties
- Syntax: Inter-Contract Calls
- Example: NFT Joint Account
- Other Flaws Linked to Inter-Contract Calls
- Increasing Price /Royalties Contract Flaws
- A Powerful Approach: Wrapping an NFT
- NFTWrapper Contract Logic
- Exercise: Implement NFTWrapper
- Solution: Implement NFTWrapper
- Introduction to Records
- Syntax: Records
- Example 1: Records
- Example 2: NFT Joint Account with Records
- Exercise: Records
- Solution: Records
- Layouts
- Introduction to Maps / Big_Maps
- Syntax: Maps
- Storage and Gas Costs/Issues
- Some Sizes May Increase Indefinitely
- Big_Maps to Avoid Gas Limits
- Example: Truly endless wall
- If/else
- Exercise: Community Contract
- Solution: Community Contract
- Exercise: Contract for multiple NFTs
- Storage: Contract for Multiple NFTs
- Code Structure: Contract for Multiple NFTs
- Solution: Contract for multiple NFTs
- Flaw: Contract for Multiple NFTs
- Storage: Contract for Multiple NFTs
- Entrypoints: Contract for Multiple NFTs
- Solution: Contract for Multiple NFTs
- Archetype
- Example: Auction Contract with Archetype
- Ligo
- Example: Auction Contract with Ligo
- SmartPy
- Example: Auction Contract with SmartPy
##TODOS: MISSING: example 1 record: First Name, Last Name, Birthdate from lesson 19 inter-contract call ## ##Todos: Missing: Exercise Records : Add a login that the user can change at most once a year This also means storing the address of each user from lesson 19 inter-contract call ##
- Lists Syntax
- For loop Syntax
- When not to Use Lists
- Alternative to lists
- Alternative to Long Loops
- What Are On-Chain Views?
- Syntax: On-Chain Views
- On-Chain Views Used Off-Chain
- Other (older) Types of Views
- Introduction to Custom Types
- Syntax Custom Types
- Introduction To Sets
- Syntax: Sets
- Exercise: Membership Contract
- Membership Contract Structure
- Solution: Membership Contract
- When not to Use Sets
- Alternative to Sets
- Simple Variants
- Syntax: Variant
- Variants and Type Inference
- Match on Simple Variants
- Example: Simple Variant
- When to Use Simple Variants
- Example: When to Use Simple Variants
- Exercise: Simple Variant
- Solution: Simple Variant
- Variants with Parameters
- Syntax: Variants with Parameters
- Variants with Parameters: Checking the Value
- Variants: Unwrapping the Parameter
- Variants: match/with and parameters
- Example: Variants with parameters
- Recap Variant Syntax
- Variants with Parameters: When to Use
- Variant Internal Representation
- Exercise: Variant with parameters
- Solution: Variant with parameters
| Action | Code |
|---|---|
| Defining a variant type: | sp.variant(VariantName1 = type, ...) |
| Creating a value | sp.variant.VariantName1() sp.variant.VariantName2(value) |
| Checking if it’s a given variant | assert my_variant.is_variant.VariantName2() |
| Extracting the value | value = my_variant.unwrap.VariantName2() |
| Matching different cases | with sp.match(my_variant): with sp.case.VariantName1: result = 0 with sp.case.VariantName2 as value: result = value |
| In a test scenario (for now) | |
| Creating a value | sp.variant("VariantName1", ()) sp.variant("VariantName2", value) |
| Checking if it’s a given variant | assert my_variant.is_variant("VariantName2") |
| Extracting the value | my_variant.open_variant("VariantName2") |
- What Are Standards and FA2 Contracts?
- FA2 Standard
- FA2 Implementation: Storage
- FA2 Standard: balance_of
- FA2 Standard: Transfer
- FA2 Standard: update_operator
- FA2 Standard: Errors
- FA2 Contract
- Tzip 4 Views
- FA2 Standard: Template Implementation NFT Minimal
- NFT marketplace
- The Need for Off-Chain Data
- Fetching Off-Chain Data Wouldn't work
- Injecting Off-Chain Data by Calling Smart Contracts
- Setting up your own Off-Chain Service
- Letting the Source Send the Data
- Injecting Data Signed by the Source
- Exercise Oracle: Starting Template
- Exercise: Oracle Solution
- Trusted Execution Environments (TEEs)
- Strong Incentives to Inject Incorrect Data
- Avoiding a Single Source or Transmitter
- Combining multiple versions of the data
- Using Source Instead of Sender for Authentication
- Transferring Tez in a Call that Should Benefits Others
- Performing Unlimited Computations
-
Micropayments Contract Problem
-
Micropayments Contract Solution
-
Signing Data and verifying signed data
-
Signing Data and Verifying Signed Data Syntax
Action Code pack() packed_data = sp.pack(typed_data) unpack() typed_data = sp.unpack(packed_data, type_of_data).unwrap_some() make_signature() signature = sp.make_signature(alice.secret_key, packed_data) check_signature() signature = sp.make_signature(alice.secret_key, packed_data)
- Geocaching Game
- Checking passwords without storing them
- Using Hashing to Secure Passwords
- Geocaching contract: Find the Flaws
- Geocaching flaw 1: stuck funds
- Geocaching contract: Find the Flaws
- Geocaching Flaw 2: Stolen Prize
- BPEV Flaws
- Protecting Against BPEV Flaws
- Geocaching with Flaws
- Winning at any Price
- Winning at any Price: DOS
##TODO: Where to put Raffle_1, Raffle_2, Raffle_3
- Randomness Flaws
- Raffle: Basic Structure
- Randomness: Using sp.now?
- Randomness: Using Hashes?
- Randomness: Mixing Random-ish Values?
- Randomness: Using Oracles?
- Randomness: Decentralized Approach?
- Randomness: Commit & Reveal
- Commit & Reveal: Flaw
- Commit & Reveal: Forcing the Reveal
- Commit & Reveal: Implementation
- Solution:
- Exercise: How to Impersonate a Rich Person?
- Solution 1: Borrow some Tez?
- Solution 2: Use Collateral
- Lending Without Collateral
- Using a Single Transaction
- Flash Loan
- Exercise: Flash Loan Structure
- Solution: Membership Contract
- Solution: Flash Loan Membership
- Solution: Liquidity Pool
- Solution: Ledger Contract
- Solution: Membership Attack
- What are Fungible Tokens?
- Fungible Tokens Ledger
- Spending Fungible Tokens
- Exercise: Fungible Tokens Starting Template
- Solution: Fungible Tokens
- Token Standards
- Trading Tokens
- Trading Tokens at the Right Price
- Liquidity Pool
- Exchange Rate
- Exercise: Liquidity Pool Contract
- Exercise: Liquidity Pool Contract, Storage and Entry Points
- Exercise: Liquidity Pool Starting Code
- Solution Trading Tokens
- Arbitrage Opportunity
- Exercise Arbitrage: Starting Template
- Solution: Arbitrage
- Multiple Tokens
- Flaw: Manipulating Prices
- Attack: Manipulating Prices
- Exercise Manipulating Prices: Starting Code
- Exercise Manipulating Prices: Solution
- Preventing Attacks