Forem: Patrick Collins

Top 10 Smart Contract & Solidity Developer Learning Resources

Patrick Collins — Mon, 08 Nov 2021 01:04:39 +0000

Learning to become a Smart Contract and Blockchain Developer can seem like a daunting task, but it doesn't have to be!

Just set aside some time each week, and get cracking on any of the tutorials and pieces of content below. Don't be afraid to ask a ton of questions, and don't feel imposter syndrome! Just by reading this article, you are already a welcomed member of the blockchain community.

If anytime you get stuck, feel free to refer to this document on how to get unstuck in the blockchain space. It applies to everything in open source!

In any case, let's go ahead and get started!

Additionally, I have a video on how to become a blockchain engineer you can check out for more information!

Helpful Tools

But BEFORE I give you the list, you need to know about these 3 resources.

These are helpful Q&A sites that you can ask questions to, and will make your life much better when going through these resources. Anyways, here are the top 10!

Top 10 Smart Contract & Solidity Developer Learning Resources

1. Cyfrin Updraft

The #1 web3, Solidity, Vyper, smart contract auditing & security, all-encompassing developer and security-focused platform on earth.

The content starts from "What is a blockchain" to "Solidity Basics" to "Advanced Deployment and Assembly" all the way down to "How to audit an AMM". This course is taught with love by some of the top people in the industry. This is a passion project data dump of everything you need to know to get started in web3, and know more than the average developer so you can make some amazing protocols.

Instructors

Myself: I'm a bit biased, but with the lead instructor being myself, who has the #1 and #2 most watched web3 developer educational courses on YouTube, and have been doing security and development in web3 for over 4 years.

Tincho: One of the top security researchers in web3, having found vulnerabilities in multi-billion dollar protocols like ENS, Lido, and Optimism.

2. Learn Solidity, Blockchain Development, and Smart Contracts | Powered by AI - Foundry Edition

My latest invention. If you get through this videos, you will be a master, guaranteed.

This course requires ZERO prior knowledge. None. It's in pure solidity, and will bring you from beginner to master. Foundry is the fastest smart contract and solidity framework, and we teach you all the skills you need to be successful in web3.

This is the most dense smart contract tutorial you will ever take. With the pinnacle project of deploying your own stablecoin!

Not sure what a stablecoin is? Well that's why you have to take this course!

Anyone interested in becoming a security researcher in blockchain will need to take this course first, as this sets you up for your security journey as well.

And not only that... but this course is powered by AI, and we teach you all the tips and tricks with artificial intelligence powered learning, getting you up to speed faster than ever before!

3. Learn Blockchain, Solidity, and Full Stack Web3 Development with JavaScript – 32-Hour Course

If you get through this videos, you will be full-stack a master, guaranteed.

Ideally, this is for engineers who want every single drop of knowledge I have acquired about blockchain development over the past 3 years, and prefer javascript. It covers all the fundamentals of solidity, and uses the exact same cutting edge tools as billion dollar defi giants like Aave, Synthetix, and Uniswap.

Ideally, this is for engineers with a little bit of javascript experience, but if you don't have any, we'll give you a ton of refreshers along the way. This course is for anyone with any level of coding experience, even none!

Additionally, we have a ton of optional front end and full stack tutorials. These will teach you how to build powerful apps and websites that use the smart contracts and blockchain applications you've made for ANY user!

3. Cryptozombies

For the longest time, Cryptozombies has been one of the go-to courses for learning blockchain & solidity. This gamified platform brings you step by step through solidity programming as you build your zombie army!

This course has a wonderful user interface that's fun for people of any age, and is one of the most approachable content on this list. The Cryptozombies team does a tremendous job showing NFTs, inheritance, and everything you'd need in basic solidity.

4. Solidity by Example

A more minimal approach to learning web3, this is a site for people who already have some familiarity with software engineering.

This site and YouTube channel have just the fundamental information, so you can jump right into coding!

5. Alchemy University

Put on by the Alchemy team, Alchemy University is a javascript focused education site, created in partnership with some of the best educators I've ever interacted with.

I used to have a group called Chainshot on my list, as they have always been underrated, but Alchemy recently aquired them to make this amazing site!

6. Consensys Bootcamp

This is another bootcamp that just always knocks it out of the park.

The Consensys team is one of the teams that has been around from basically the start of this whole thing. They consistently deliver on bringing in some of the best in the space to give guest lectures to the students, have top quality content, and are another bootcamp that I highly recommend to anyone looking to get into this space with a hands-on learning approach, and a team to guide them.

7. Speed Run Ethereum

From creating your own NFTs to mastering decentralized staking apps, Speed Run Ethereum offers a comprehensive and enjoyable learning experience for blockchain enthusiasts and developers alike. It's created by my friend Austin Griffith who is one of the most respected Web3 developer educators on the planet.

Join the BuidlGuidl community, a vibrant hub of Ethereum builders focused on crafting innovative products, prototypes, and tutorials that enrich the web3 ecosystem. Showcase your achievements by submitting your DEX, Multisig, or SVG NFT builds, and collaborate with fellow builders to elevate your Web3 portfolio. Embark on an exciting journey of learning and building with Speed Run Ethereum, and become a proficient Ethereum developer ready to shape the future of decentralized technologies.

8. LearnWeb3DAO

LearnWeb3DAO is like going to university for 4 years. They have a freshman, sophomore, junior, and senior track that will bring you end-to-end from start to finish.

And this is another course that you can get started 100% for free!

9. Ethernaut

One of the harder pieces in this space is Ethernaut. You need a little bit of a javascript background, but trudging your way through this course will teach you a lot of the ins and outs and "gotchas" of solidity, and is one of the quickest ways to become "advanced" in the ways of solidity.

This was created by the Openzeppelin team, who are top auditors and security researchers in the blockchain space, and they make contracts for people to fork into their own projects. Anyone in the blockchain space worth their "salt" knows who Openzeppelin is and how to work with their tools!

10. The Ethereum Org List

What better way to learn about web3 and Ethereum than from the community itself!

The Ethereum org website is JAM packed with content, tutorials, and submissions from around the globe, in exactly the manner you'd expect. You can find just about anything here to learn and grow.

11. useWeb3

useWeb3, like the Ethereum org website, is dedicated to being a living document of updated courses and content to teach people how to build in the blockchain space.

This open sourced project is constantly updated, and really any of the projects listed on their site is worthwhile for you to check and and put to the test!

12. There are so many!!

Ok, so I fibbed, this article has way more than just 10!!! Here is a list of tons of different places you can get started learning solidity, smart contracts, and blockchain. It doesn't matter where you go, just pick one, and go!

And so much more.

Well, as always, be sure to follow me on Twitter, YouTube, Medium, and GitHub, and I hope to see you in the community!

Learn Solidity, Blockchain, and Smart Contracts with this Full Free Course

Patrick Collins — Fri, 10 Sep 2021 03:40:10 +0000

FreeCodeCamp has just released an entire Solidity, Blockchain, and Smart Contract Course – Beginner to Expert Python Tutorial that goes over everything a successful smart contract needs to learn, all jam packed into 1 free 16 hour course.

Taught, by yours truly!

Each section comes with either additional reading or code samples all available in the giant mega GitHub repo associated with the course:

👩‍💻 GitHub Repo: https://github.com/smartcontractkit/full-blockchain-solidity-course-py

The GitHub Repo has everything you need to be successful in the tutorial and learn solidity.

You can also watch the amazing trailer for the video here.

⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️⭐️

Who is this for?

This course is for ANYONE looking to either get started being a smart contract engineer or get better. If you already have some knowledge, skip to the sections you like! That's why they are timestamped! If you know nothing, then start from the start.

If you don't want to become a developer, even YOU can learn a ton from watching specific sections like the "Welcome to Blockchain" section.

Course Layout

The course is divided into "lessons", which each teach foundational concepts for blockchain development.

⭐️ Course Contents ⭐
⌨️ (00:00:00) Introduction

We introduce the course, and what we are going to go over! We give some helpful resources on where to get help, how best to use the course, and how to pace yourself!

⌨️ (00:06:33) Lesson 0: Welcome To Blockchain

Foundational conceptual information about what blockchains actually are, what makes smart contracts so special, and how hybrid smart contracts and oracles make smart contracts even more impactful.

⌨️ (01:31:00) Lesson 1: Welcome to Remix! Simple Storage

We finally start coding solidity! We learn about the Remix IDE, a powerful tool to deploy our smart contracts. We learn a lot of the basic syntax of solidity. We also learn how to deploy our smart contracts! We build a contract that can store very specific data.

⌨️ (02:09:32) Lesson 2: Storage Factory

This shorter lesson we learn some advanced topics of solidity, like the factory pattern, where we can deploy smart contracts from other smart contracts. We build a contract that can deploy Simple Storage contracts!

⌨️ (02:26:35) Lesson 3: Fund Me

We turn up the heat in this tutorial, where we learn how to deal with paying for things, getting pricing information, working with oracles, and importing code from outside our projects. We build a sample project that can be used to help fund future projects!

⌨️ (03:26:48) Lesson 4: Web3.py Simple Storage

We level up our coding environments by moving from Remix to our own local text editors, and start using python and web3.py to build and deploy our smart contracts. We use the same Simple Storage contract that we've been learning with, but with web3.py! Web3.py is a foundational technology to the main one we are going to be using...

⌨️ (04:27:55) Lesson 5: Brownie Simple Storage

Here is where we learn the most powerful tool that we are going to "live" in for the rest of the course, Brownie! This is a smart contract development framework for building, testing, and deploying smart contracts easily. We learn the basics of testing as well, and the layout of a brownie project, yummy!

⌨️ (05:06:34) Lesson 6: Brownie Fund Me

We get even more familiar with brownie by going over our Fund Me project again, and learning things like verifying out contracts, importing dependencies, forking a blockchain, and more!

⌨️ (06:11:38) Lesson 7: SmartContract Lottery

Boom! A whole lottery application that we build from scratch! We learn how to set an entrance fee for our lottery, get a random number for a winner, Openzeppelin contracts, events & logging, and more!

⌨️ (08:21:02) Lesson 8: Chainlink Mix

This quick lesson shows the layout of the chainlink-mix which is a brownie mix that allows us to start a hybrid smart contract project right from the get-go!

⌨️ (08:23:25) Lesson 9: ERC20s, EIPs, and Token Standards

We learn how to create our own ERC20 blockchain token! We also learn about different versions of solidity, and more!

⌨️ (08:34:53) Lesson 10: Defi & Aave

An incredible dive into the world of #DeFi and what makes it so special. We learn how to interact with the Aave protocol and use it's composability for us to make incredibly powerful applications ourselves, even if it's 100% off-chain! We learn some advanced DeFi skills like short selling and depositing collateral.

⌨️ (09:50:20) Lesson 11: NFTs

Art, art, art!! 🎨 We learn how to create art on the blockchain, but with unlimited customization, allowing us to make games, generative art, and more! We make a few adorable randomized dogs and deploy them to the blockchain and Opensea.

⌨️ (11:49:15) Lesson 12: Upgrades

A very advanced tutorial on deploying contracts that can be upgraded using the transparent proxy pattern. This lesson goes a bit into Yul code, which is the low level code of solidity, and some of the dangers and advantages of delegatecall.

⌨️ (12:48:06) Lesson 13: Full Stack Defi

We now add a front-end! We don't go deep into how to create front-ends, so if you're a little new on typescript or javascript, you might want to watch FreeCodeCamps Typescript crash course.

⌨️ (16:14:16) Closing and Summary

At long last, we end this tutorial, and you leave being an amazing smart contract engineer! We talk about joining the community, where to go next, and how to live with this newfound skill of yours!

You can see a more detailed inventory in the GitHub repo, it's very thorough.

How to watch

This is a course that is long, so don't go through the whole thing in 1 go! 30 minutes at a time is perfect, and will give your brain plenty of time of absorb all the information you're getting and make you a better smart contract engineer.

Maybe even grab a buddy to keep each other accountable, by the end of the course, you'll have years of experience under your belt already! This course is an entire data dump of knowledge from years of working with smart contracts.

What should I be expected to use?

You'll want a text editor like Visual Studio Code and a number of dependencies installed. Don't worry, we go over everything!

Be sure to @ me at @patrickalphac if you enjoyed the content or learnt something. Joining the community is one of the best ways to continue learning, and put your skills to use!

Community

Twitter - Just get on Twitter and say hi to someone!
Brownie Discord
Ethereum Discord
Chainlink Discord
Reddit ethdev

Hackathons

Learning More

Using Brownie For To Deploy Smart Contracts

Patrick Collins — Sat, 23 Jan 2021 18:09:35 +0000

In this article, we are going to deploy smart contracts using Python. This means that, if you know some Python, this could be your transition into smart contract and blockchain development!

You can see the original blog from Medium.

Introduction

I love Python, it has such an amazing developer experience. There is something so sweet about being able to just write print("hi") and not having to do anything verbose like System.out.println("hi"). This sentiment is shared by many, including those in the fintech world. Many of the hedge funds I’ve worked with (and worked at) have used Python as their main language.

I wish I could take Python with me everywhere. And even though Solidity (Ethereum’s native smart contract language) isn’t Python, it has a lot of nice features, and can still be deployed with Python. When I first started working with Solidity, I used Remix, a strong web IDE that allows you to visualize your smart contracts. Remix is great and I still use it, but a lot of productivity can be accomplished outside of a single IDE. This was when I started to learn about Truffle and HardHat, which are Nodejs frameworks for deploying smart contracts.

These are the dominant frameworks I’ve seen by far, and this is all great but we don’t like Javascript, we like Python. So I was excited to find Brownie and web3.py; a Python framework to deploy smart contracts and an open-sourced repo for working with blockchains. We will be looking at both Brownie and Web3.py in this article.

Why Python?

There is a reason why so many data scientists, academics, and fintech institutions use Python. It’s such a versatile language, has an easy developer experience, and is jam-packed with packages to make life easier. Top defi projects are starting to realize this, with projects like yearn.finance using python to deploy all their production code. Yearn.finance is run by a group of really talented fintech engineers turned blockchain, and they took with them the tool that they know and love, Python. Also it doesn’t touch npm, but I’ll leave my distaste for javascript package managers for another article.

What is Brownie?

Brownie is an open-sourced Python smart contract framework created by Ben Hauser, aka “iamdefinitelyahuman”, and is a work of art. This is the tool that yearn.finance uses this framework to deploy and maintain contracts. You can start a project with a simple command, and start working with the code right away. What a “sweet” project name.

Deploy your First Smart Contract with Python

1. Install Brownie and bake

Brownie has a “baking” feature that allows you to start your repos with some baseline code since most projects need a lot of the same pieces, similar to create-eth-app.To get started, we just need to install Brownie the same way you install every other Python package.
pip install eth-brownie
We also need to install ganache-cli a package for deploying local blockchains. You’ll need to install npm and nodejs for this.

npm install -g ganache-cli

And boom! We are ready to go!

We are going to use the chainlink-mix to get started, since many of these top defi projects use Chainlink to get their asset data.

brownie bake chainlink-mix
cd chainlink

And a quick ls command will show us the layout of the project
How to deploy a smart contract with python

Brownie project layout

build : This is where the project keeps track of your deployed smart contracts and compiled contracts
contracts : The source code of your contracts, typically written in solidity or vyper
interfaces : A layout of interfaces you’ll need to work with deployed contracts. Every interaction with a contract needs an ABI and an address. Interfaces are great ways to get a contract’s ABI
scripts : Scripts we create to automate processes of working with our contracts
tests : Tests
brownie-config.yaml : This is where we have all the information for brownie to understand how to work with our smart contract. What blockchain do we want to deploy to? Are there any special parameters we want to set? All these are set in the config file.

requirements.txt , README.md , LICENSE , and .gitignore can be ignored, for now, you’ll find out what they are for as you practice.

2. Setup your environment variables

If you’re familiar with blockchain development, you know that local blockchains, testnet blockchains, and mainnet blockchains are all different things. We will be deploying to a testnet so we can interact with a real live blockchain.
You’ll need a WEB3_INFURA_PROJECT_ID which can be retrieved by making an Infura account. This will be what we use to connect to our testnetwork.
You’ll also want to get a metamask or other web3 ethereum wallet and fund it with some ETH. For this demo, we want to use the Kovan testnetwork.

If you’ve never used metamask, feel free to follow along in this video! You can skip the part about funding with LINK, we only need testnet ETH. We also will not be using Ropsten (as shown in the video) but Kovan. If you already have a wallet, grab some Kovan Ether from the faucet.

Install, Configure, and Fund Metamask

Once you have a metamask wallet, you can export your private key to your PRIVATE_KEY environment variable.
Read here on setting environment variables. If this still confuses you and this is just a test wallet, feel free to just replace PRIVATE_KEY in the code with your private key, and WEB3_INFURA_PROJECT_ID.

3. Deploy your smart contract

In our scripts folder, we have a script called 01_deploy_price_consumer_v3.py , this will deploy our Smart Contract that reads in the price of Ethereum in USD. If you want to see an easier walkthrough of what this contract does and how to deploy it, feel free to check out the Chainlink tutorial on deploying a price feed contract.
brownie run is the command we can use to run a script. If you run just brownie you can see a list of all commands.

brownie run scripts/price_feed_scripts/01_deploy_price_consumer_v3.py --network kovan

--network kovan allows us to set the network we want to work with. We are working with the kovan testnet for this demo. You’ll need Kovan ETH to do this! You’ll get a big output, but eventually will settle with something like:

Running 'scripts/price_feed_scripts/01_deploy_price_consumer_v3.py::main'...
Transaction sent: 0x23d1dfa3937e0cfbab58f8d5ecabe2bfffc28bbe2349527dabe9289e747bac56
Gas price: 20.0 gwei   Gas limit: 145600   Nonce: 1339
PriceFeed.constructor confirmed - Block: 22721813   Gas used: 132364 (90.91%)
PriceFeed deployed at: 0x6B2305935DbC77662811ff817cF3Aa54fc585816

If this worked properly, we can go to kovan etherscan and find the contract we deployed. The link above shows the contract deployed in this example.

4. Read off your smart contract

Now that we have deployed a smart contract, we can read the price of ETH from the contract we just deployed. We will be using another script that we have:
brownie run scripts/price_feed_scripts/02_read_price_feed.py --network kovan

And we will get an output like:

Brownie v1.12.2 - Python development framework for Ethereum
ChainlinkProject is the active project.
Running 'scripts/price_feed_scripts/read_price_feed.py::main'...
Reading data from 0x6B2305935DbC77662811ff817cF3Aa54fc585816
62322000000
Where 62322000000 is the current price of ETH in USD! Solidity doesn’t understand decimals, and we know that this example has 8 decimals, so the price is $623.22 .

And you’ve just deployed your first smart contract using python with Brownie!

Using web3.py

Brownie uses a tool called web3.py to make your life easier, but if you’re savvy you can always work with the contracts directly without a framework. Web3.py is a raw package that we can use to work more directly with contracts.
For this, we will just need our Kovan infura project id as above.
Remember, to interact with any smart contract, you need two things:

The contract ABI
The contract address

Brownie takes care of a lot of these pieces behind the scenes, but we can do it manually as well. Here is what reading from that contract on-chain looks like with web3.py.
First, we need to install web3.py.

pip install web3

Then we can run the following in a file.

web3 = Web3(Web3.HTTPProvider('https://kovan.infura.io/v3/<infura_project_id>')) 
abi = '[{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"description","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint80","name":"_roundId","type":"uint80"}],"name":"getRoundData","outputs":[{"internalType":"uint80","name":"roundId","type":"uint80"},{"internalType":"int256","name":"answer","type":"int256"},{"internalType":"uint256","name":"startedAt","type":"uint256"},{"internalType":"uint256","name":"updatedAt","type":"uint256"},{"internalType":"uint80","name":"answeredInRound","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestRoundData","outputs":[{"internalType":"uint80","name":"roundId","type":"uint80"},{"internalType":"int256","name":"answer","type":"int256"},{"internalType":"uint256","name":"startedAt","type":"uint256"},{"internalType":"uint256","name":"updatedAt","type":"uint256"},{"internalType":"uint80","name":"answeredInRound","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]' 
addr = '0x9326BFA02ADD2366b30bacB125260Af641031331' 
contract = web3.eth.contract(address=addr, abi=abi) 
latestData = contract.functions.latestRoundData().call() print(latestData)

Running the above will print the latest price of ETH in USD to our console. If you have an issue, be sure to check the Chainlink documentation to see if something is off.

Conclusion

You can learn more about Web3.py and Brownie from their documentation. Both of these projects are open-sourced so anyone can contribute!
Feel free to check out this video which explains it some more!

This New Technology Is Changing Fintech

Patrick Collins — Wed, 23 Dec 2020 04:16:10 +0000

Introduction

Fintech is a popular buzzword. Why? Because it powers our money. Our banks, our assets, our investments all run through the tools that engineers have been building for years to make our monetary systems easy and powerful.

But what if I told you that fintech as you know it is in for a massive makeover?

That fintech has already started handing over market share to a new technology. That the skills needed to run a successful hedge fund, asset manager, data vendor, are going through the spin cycle of reform. Many of these pieces you see today, like python, devops, and algorithmic modeling will persist, but on a totally different platform.

We will go over what defi is, and how you can join.

If you know some #python, you'll want to stick around.

What is DeFi

Defi is proving to be the force that is going to be:

More secure
More transparent
Faster
Less corrupt

This year, we've seen an explosion from the defi scene, going from nearly nothing to nearly $15b in assets under management be decentralized protocols.

So what is defi?

Defi stands for "Decentralized Finance", and is a concept where non-custodial smart contracts hold your asset and automatically execute without a centralized intermediate. Meaning you don't have a banker who can freeze your assets anymore. You don't have an exchange where a trade takes 4 days to settle. You are finally truly in charge of your assets.

How is that possible?

Smart Contract platforms like Ethereum allow engineers to build applications that have no centralized authority and automatically execute. Everything is transparent on-chain and every can see the code. Imagine a commons that is tragedy resistant but instead of a plain or common, you have a computational system. This allows for people to truly own their asset.

More and more protocols are running in defi, and for good reason. The value add that blockchain/smart contract platforms have around transparency and security is huge, but the other massive thing is the current yield.

We are currently in a low-interest rate environment, where banks give next to nothing for holding your money. A defi protocol can do the same thing, and for nearly the same security net you 5% - 10% APY. In a traditional finance world, this is insane. Professional hedge funds don't make anywhere near that even on a short term basis.

Some of these platforms are doing revolutionary work. You can see the top projects at the moment on Defipulse, a platform that tracks defi project growth.

Aave is a decentralized borrowing and lending platforms, and has a tool called a "flash loan", which allows you to borrow as much as you want without any collateral. This is only possible with blockchain, but it allows you to be a whale for a very short period of time.

Synthetix is a decentralized protocol that allows for tokenizing assets into synthetic tokens. Meaning you can have your TSLA shares be a cryptocurrency and be traded with ease.

I've written a lot about Synthetix because the current stock market and securities buying world is fraught with corruption. The faster we can get these protocols to scale the better. If you want to read more about the power Synthetix will have, check this article out.

yearn.finance is the best-decentralized algotrader out there. It finds the highest APY of the various protocols and moves everyone's money to them in a way that maximized yield. In the traditional fintech world, this is a bigger issue than insider trading. A hedge fund not practicing best execution is a way bigger threat than insider trading.

Set Protocol build your own defi strategies and become an asset manager through just your public strategy on-chain. Anyone can set up a strategy.

How you can get involved

I ended above with two projects that current fintech engineers love. Yearn.finance and Set Protocol. Both are the current best iterations of decentralized algoritmic trading.

Imagine wanting to start a hedge fund with an amazing strategy but not having the capital to pay for a fancy lawyer to get all the paperwork started. You can get started without any of that with a strategy on one of these platforms. I love python, as does a lot of the algorithmic trading world and yearn.finance is a project run by ex-traditional fintech engineers, and they brought python with them.

This will be your guide to get a boilerplate strategy going.

Getting started with Python

Install the following:

python
pip
npm
brownie (see below)

pip install brownie

ganache

npm install -g ganache-cli

export WEB3_INFURA_PROJECT_ID=YourProjectID

Sign up for Etherscan and generate an API key. This is required for fetching source codes of the mainnet contracts we will be interacting with. Store the API key in the ETHERSCAN_TOKEN environment variable.

export ETHERSCAN_TOKEN=YourApiToken

Then download the mix:

brownie bake yearn-strategy

Working with contracts

Open the Brownie console. This automatically launches Ganache on a forked mainnet. Ganache is a fake blockchain that will run locally on your computer. This will simulate working with the real Ethereum network.

brownie console

Create variables for the Yearn Vault and Want Token addresses. These were obtained from the Yearn Registry. Also, loan the Yearn governance multisig.

>>> vault = Vault.at("0xBFa4D8AA6d8a379aBFe7793399D3DdaCC5bBECBB")  # yvDAI (v0.2.2)
>>> token = Token.at("0x6b175474e89094c44da98b954eedeac495271d0f")  # DAI
>>> gov = "ychad.eth"  # ENS for Yearn Governance Multisig

Deploy the Strategy.sol contract.

>>> strategy = Strategy.deploy(vault, {"from": accounts[0]})
Transaction sent: 0xc8a35b3ecbbed196a344ed6b5c7ee6f50faf9b7eee836044d1c7ffe10093ef45
  Gas price: 0.0 gwei   Gas limit: 6721975
  Flashloan.constructor confirmed - Block: 9995378   Gas used: 796934 (11.86%)
  Flashloan deployed at: 0x3194cBDC3dbcd3E11a07892e7bA5c3394048Cc87

This will be your first transaction on-chain, nice work!

Approve the strategy for the Vault. We must do this because we only approved Strategies can pull funding from the Vault.

# 1000 DAI debt limit, no rate limit, 50 bps strategist fee
>>> vault.addStrategy(strategy, Wei("1000 ether"), 2 ** 256 - 1, 50, {"from": gov})
Transaction sent: 0xa70b90eb9a9899e8f6e709c53a436976315b4279c4b6797d0a293e169f94d5b4
  Gas price: 0.0 gwei   Gas limit: 6721975
  Transaction confirmed - Block: 9995379   Gas used: 21055 (0.31%)

Now we are ready to put our strategy into action!

>>> harvest_tx = strategy.harvest({"from": accounts[0]})  # perform as many time as desired...

Strategy.sol is where you can implement your own strategy and get started working with decentralized "algotrading".

Be sure to check out the repo to learn more about how it works, the community around it. Once you build something awesome, be sure to make some noise! The community love meeting new people.

Getting Gas Prices In Solidity

Patrick Collins — Wed, 25 Nov 2020 17:54:18 +0000

Introduction

When making transactions in the ethereum chain, you always have to set a gas price to do so. Generally, your wallet will have some sort of estimator to decide the gas price. This is great, but what happens if you NEED to get your transaction processed quickly? You'll need a way to estimate the fast gas price so your transaction can get through.

What is gas?

Gas in solidity is a special unit of computational work and storage it costs to execute on-chain interactions and state changes. So if you do some addition, that will cost less gas than if you do addition, multiplication, and division.

1 unit of gas costs ethereum. This is why you pay a fee whenever you make a transaction on-chain, you are asking the system to perform some computational work. However, the ETH that you need to pay to do that 1 unit of gas, changes depending on the congestion of the network.

When a lot of people want their transactions processed, miners will prioritize the transactions that are offering more gas. This is known as the gas price.

The fee you pay is going to be the amount of gas times the cost of gas.

Sending transactions

When sending transactions, you need to estimate this price of gas so you'll have roughly a good idea when your transaction will get through. Maybe you have a massive transaction and you want it to settle quickly. When looking at your code, you can choose how much gas to send.

Sample code

Let's look at some code that shows sending a transaction. We will be using ethers.js to send our transaction.

const main = async () => {
    let contract = new ethers.Contract(address, abi, wallet)
    let contractWithSigner = contract.connect(wallet)
    let tx = await contractWithSigner.executeThisFunctionQuick()
    console.log(tx.hash)
    await tx.wait()
}

In this function, we are calling executeThisFunctionQuick, but we are not giving the transaction any input about how much gas it should use, and therefore, it has no idea how quickly it should send this information. This is really bad, since we need this to go through.

Having your contract depend on a centralized data provider, can, can cause issues since now your application depends on them being up and honest. So the best solution for this is to the fast gas Chainlink price feed. You'll pull in the fast gas information, and then run your contract with it. You can find out more about Chainlink price feeds in the Chainlink documentation.

First, let's grab some default information to get going.

const aggregatorV3InterfaceABI = [{ "inputs": [], "name": "decimals", "outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "description", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "uint80", "name": "_roundId", "type": "uint80" }], "name": "getRoundData", "outputs": [{ "internalType": "uint80", "name": "roundId", "type": "uint80" }, { "internalType": "int256", "name": "answer", "type": "int256" }, { "internalType": "uint256", "name": "startedAt", "type": "uint256" }, { "internalType": "uint256", "name": "updatedAt", "type": "uint256" }, { "internalType": "uint80", "name": "answeredInRound", "type": "uint80" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "latestRoundData", "outputs": [{ "internalType": "uint80", "name": "roundId", "type": "uint80" }, { "internalType": "int256", "name": "answer", "type": "int256" }, { "internalType": "uint256", "name": "startedAt", "type": "uint256" }, { "internalType": "uint256", "name": "updatedAt", "type": "uint256" }, { "internalType": "uint80", "name": "answeredInRound", "type": "uint80" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "version", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }]
const priceFeedAddr = "0x562C092bEb3a6DF77aDf0BB604F52c018E4f2814" // swap this for the fast gas address
let priceFeed = new ethers.Contract(priceFeedAddr, aggregatorV3InterfaceABI, wallet)
let gasPrice = 30000000000

We need the ABI and address of the fast gas aggregator contract so we can interact with the contract, then we can pop back into our main function.

Before we go calling our executeThisFunctionQuick we want to get the fast gas price into our contract.

roundData = await priceFeed.latestRoundData()
    // gasPrice = roundData['1'] // this is what you'll use
    console.log("Gas Price is now " + gasPrice)
    let overrides = {
        // The price (in wei) per unit of gas
        gasPrice: gasPrice, // Set the price based on the fast gas here
    }

This will tell us what a safe fast gas is to set. Then, all we have to do is add the overrides object to our call. This will override the default of the gasPrice value.

let tx = await contractWithSigner.executeThisFunctionQuick(overrides)

And that's it! Now we can be sure that our transactions in our code will be sent out in a fast secure manner.

To see a full example, check out my gist on making a simple contract call with gas cost estimation as well.

Fetch Real-Time Price Data in Solidity

Patrick Collins — Fri, 30 Oct 2020 00:56:03 +0000

Introduction

Fetching data from outside Ethereum or whatever blockchain platform is something that most smart contract engineers need to really empower their dApps. Fetching reliable real-time price data in solidity can be the difference between having a powerful DeFi protocol and a quick "Get poor quick" scheme.

We've seen a number of incredibly successful defi projects already pull in real-world price data such as Aave, Synthetix, and yearn.finance. These are protocols at the moment that are securing billions of dollars in the defi space.

Having reliable price data means you can make protocols involving borrowing, lending, trading, synthetic assets, backing collateral, and so much more. Get the price data wrong, and you now have a chance to ruin millions of people's lives.

And just in time for Halloween, a nice spooky platform.

I'm having too much fun in this post already.

Price Data Quality

Whether you're fetching your data from a Stock API, Crypto API, or your cousin Larry is uploading coin prices for you, you're going to want to know where your price data is coming from, and you'll want to have that data decentralized if you're going to put it in a smart contract.

So if Larry really wants to be the price oracle for you, just make sure he isn't the only one to do it.

In our smart contracts, we need the data to be decentralized, otherwise we might as well just not build the application in blockchain. Having a centralized data provider in a decentralized system defeats the purpose of building on a decentralized platform in the first place!

So we want to pull from a network of Chainlink oracles to keep our data reliable and decentralized, and have the network pull data from multiple Cryptocurrency API and (if we want another asset class) Stock API providers.

There are currently two approaches, each approach involves using a blockchain oracle.

1. Chainlink Price Feeds

Chainlink Price Feeds are the easiest, most decentralized, and reliable way to fetch real-time price data in your solidity smart contracts. They pull data in from a network of Chainlink nodes and update and aggregate an answer on chain. You can see the responses of all the nodes so you know if any is being malicious.

The function to get the data is just a simple view function as well, so you don't even need to spend any gas to fetch the most recent price!

Here is a sample of how to get the latest ETH/USD price on Kovan, you can try deploying it on remix with this link.

pragma solidity ^0.6.7;

import "@chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol";

contract PriceConsumerV3 {

    AggregatorV3Interface internal priceFeed;

    /**
     * Network: Kovan
     * Aggregator: ETH/USD
     * Address: 0x9326BFA02ADD2366b30bacB125260Af641031331
     */
    constructor() public {
        priceFeed = AggregatorV3Interface(0x9326BFA02ADD2366b30bacB125260Af641031331);
    }

    /**
     * Returns the latest price
     */
    function getLatestPrice() public view returns (int) {
        (
            uint80 roundID, 
            int price,
            uint startedAt,
            uint timeStamp,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();
        // If the round is not complete yet, timestamp is 0
        require(timeStamp > 0, "Round not complete");
        return price;
    }
}

Once you deploy the contract on kovan, you can just call the getLatestPrice function, and boom, you've just fetched the price data!

This works because we know the proxy contract of the currency pair. We can find a list of supported pairs in the chainlink documentation. We can even get the fast gas price in solidity! Meaning, inside your smart contracts you can estimate how much it will cost in gas to make a certain execution.

The feeds.chain.link page has a number of visualizations to show more information on the price pairs, included when it was last updated, what the nodes are responding with, gas costs, and more.

2. Chainlink API Calls

If you've read my previous blog on getting off-chain data in ethereum, you know that with Chainlink you can access any API of data source.

It's no different for fetching price data, you simply make several decentralized Chainlink API calls, and aggregate them on chain. If you haven't made a Chainlink API call before, I recommend either checking out my last blog or going through the example walkthrough.

Click here for a demo on remix that shows you how to get stock price data from Alpha Vantage on Ropsten.

You'd want to do this multiple times with multiple nodes and data providers to make sure that it's decentralized. If you do this, you'll basically have yourself a price feed.

Summary

These are some of the tools a number of the defi giants use to get data into their protocols. Let's see what you build out there! Be sure to ping me at @patrickalphac on twitter once you do, we'd love to see what you've built!

Also, join the Chainlink developers discord to join the community, learn, and grow!

Off-chain Data in Ethereum

Patrick Collins — Wed, 28 Oct 2020 23:56:51 +0000

Introduction

For my first article on Dev.to, I figured I'd speak a little about something I'm familiar with, data & blockchain! And in particular, accessing off-chain data in ethereum and all blockchains.

Getting off-chain data has been an issue for ethereum engineers for a long time. Smart contracts weren't able to do anything more interesting than token transfers. This is great, but it doesn't allow for ethereum to do what it was ultimately designed to do - create smart contracts.

Why?

Because off-chain data in ethereum doesn't work in a deterministic system!!

If you clicked that link above, you'll see them talk about API calls in blockchain. Blockchains work because all nodes in the system can come to a consensus. Consensus is how all nodes agree upon a value. In a system such as blockchain, were all information is contained, this is really easy.

Verifying off-chain data and on-chain

5 + 5 = 10

This simple math problem is something that's easy for all nodes on the network to understand. All nodes can add 5 together, and if a node returns a result other than 10, they can easily exclude that node's blocks.

However if we have something like:

API call result from API Y + API call result from API Z = 10

Then no node on the platform will ever come to a consensus! APIs are updated, changed, depreciated, and hacked, so depending on when a node goes to verify this sequence, each node will get wildly different results. This breaks the determinism of the blockchain and means that as part of the native system getting off-chain data doesn't work.

But.... but we want smart contracts to empower the world right? How can we do that if a smart contract can't even tell me who is president right now?

Enter oracles

Blockchain Oracle

A blockchain oracle is any entity that brings off-chain data on-chain, or sends on-chain data to the real world. They are the middleware between the real world and the blockchain.

They make a transaction on-chain with the off-chain data, and boom! We now have a way to validate the data on-chain, all other nodes just validate the data of the transaction the same way they validate every other transaction.

Cool! So we are all set right?

Nope. You're forgetting about a big issue.

Decentralism

Smart contracts are meant to be decentralized. This means, they have no central point of failure, now if we pull our data from one node, guess what we are doing? We are adding a centralized point of failure.

So how do we address this?

We pull from a lot of nodes!

The same principle that makes blockchain work with many nodes securing the system is the principle that powers the idea of decentralized oracles. We also want to pull from multiple off-chain data sources so our ethereum contracts can stay decentralized.

What this looks like

Chainlink is the standard for decentralized oracles on ethereum and blockchains in general. As a chain agnostic technology chainlink is compatible with any chain, but let's look at an ethereum example.

Make any API call

For this, you'll need the following:

Metamask/a eth wallet
Testnet LINK
Testnet ETH

You can follow the guide here to get all this setup.

This link also has a guide on how to do the rest as well!

Step 1. Decide what data you want

This can be as easy as picking an out an API. For this, let's say we want to get the volume data of ETH/USD from Cryptocompare. Here is the API we will be using.

Note, that the return type is important, we will be writing this tutorial in solidity so we know we want to get the volume as a uint256.

https://min-api.cryptocompare.com/data/pricemultifull?fsyms=ETH&tsyms=USD

Step 2. Pick your oracle

First, let's pick an independent chainlink oracle/node to pull our data from. For this, we will just be showing you how to pull from a single node. This is just a centralized example! To decentralize it you just replicate this across multiple independent nodes and then aggregate the responses on-chain.

You can choose your nodes on node listing services like market.link. You'll want to switch to a testnet like kovan since we will be testing this on kovan!

You can look up the data that you want to get, for example you can search for get > uint256 and see the oracles that return that data. You'll want to grab the oracle address, and then the jobid of the job that returns the uint256 and makes an httpget call.

For our demo, we will use:

address oracle = 0x2f90A6D021db21e1B2A077c5a37B3C7E75D15b7e;
bytes32 jobId = "29fa9aa13bf1468788b7cc4a500a45b8";

And this is on Kovan.

Step 3. Setup your remix

Hit this link!

This will bring you directly to remix, where you can compile & deploy your contract! From here, you can follow the Chainlink documentation to get the rest of it sent and your first Chainlink API call made!

Summary

I hope this gave you some insight into off-chain data and how Chainlink oracles power the web. These decentralized oracles are currently powering many of the top projects in defi, and this technology is securing billions of dollars.

More and more engineers are joining hackathons to build awesome projects, join the community, and become apart of something great.

Hope to see you in the technical discord!

Main image above from phive2015 from Getty Images Pro

Chainlink Hackathon

Patrick Collins — Tue, 25 Aug 2020 17:06:51 +0000

The Chainlink project is proud to announce the Chainlink hackathon! Let's build the next generation of universally connected smart contracts.

Totaling $40k+ in prizes, this is Chainlink's biggest hackathon of the year. Get the opportunity to learn and work with some of the best in the business and build something stellar. We've seen MAJOR adoption of blockchain in the past few months, with Defi rocketing up over $6B. This is your chance, to be apart of the history of the #4IR. This is the window of opportunity to be apart of something great!

Truffle, Loopring, DappU, Aave, Tezos, Gelato, ENS, and more are joining as some of the esteemed sponsors - we're looking forward to seeing some awesome projects!