DEV Community: a_mature_dev

Web3: Should I use Infura / Alchemy or Run a Node?

a_mature_dev — Sat, 14 May 2022 00:23:45 +0000

Quick Recap on Web3

Unless you have been living under a rock, you would have come across the term Web3, through a blog post, news articles, or some other source. Trust me, Web3 has been shaking the internet as it exists today.

Web3 is the culmination of a vision of serverless internet, the decentralized web. An internet where users are in control of their own data, identity, and destiny.

The Web3 stack looks something like that

Network Layer — aka Blockchain, the backend
Interaction Layer — aka Node providers, the AWSes of the blockchain world
*Decentralized Applications *— Customer interfaces to access Web 3.0, the “apps”

This article focuses on the Interaction Layer, specifically in relation to EVM based Blockchains.

Reason: Cause you are starting out on the Web3 development cycle and you need to know as why is the layer 1important, who provides that service, do I need it, etc etc

There are 2 approaches to work with the interaction layer:

Using third-party service providers: Eg: Infura, Alchemy, QuickNode, OR
Running your own node client: Eg, Geth

As you would have already guessed, there are pros and cons to both the options. 90% of the dapp development happens using the option 2; but without much analysis into this subject.

The objective of this article is to let you know of the pros and cons and then to help you make a decision on should follow the herd or break free.

OPTION 1: Using A Node Service Provider

As the name suggests Node service provider runs node clients behind the scenes for you so that you don’t have to. Each of its clients can then participate in “using” the node (obviously, it is shared). Heard economies of scale?!?, yes that is what comes into play over here now.
These service providers typically provide an API key that you can use to communicate with the node. Yes, all your provider.getBalance(0x) and others comes here.
Using these nodes is usually a plug and play through their SDK
There are various node providers out there like Alchemy, Infura, QuickNode offering these services.

To understand it in a better manner, the following table consists of some of the most popular node providers and their features.

For more information, check out this page

Pros of Using the above mentioned service providers

Easy to Use; just plug and play using their own SDK or other Web3 JS libraries
Instant Availability
Back-up options available (should one node fail, the other comes up)
Technical Support Team available
No hassle of maintaining the Node Software; risks associated with Nodes
Fractionalized Costing {more on this later}

Cons

Third-party reliance (isn’t that exactly opposite to what blockchain ethos is all about)
Cost (may be, may be not?)

OPTION 2 :Running Your Own Node.

By running our own Node we mean that your server stores the entire blockchain. You may choose whether your Node should validate every block of data before adding it to the blockchain (yes yes, we are talking about mining, proof of work when it comes to Ethereum Blockchain).

Although, running own node can be considered good practice but is not recommended due to its cost and time taken for the installation process.

A Full Node sync can take around a month or two for downloading the whole blockchain
The Light Node sync can take up to several weeks

There exist multiple clients on the internet that allow you to run their own Node based on various programming languages like Go, Rust, Typescript, etc.

Some client examples

Pros of Using the above mentioned service providers

You are the master of your own destiny. No more, API keys, No more purchase a plan, API Call limits, etc

Cons

Costs
Maintenance

Lets talk about the Costs (financial and then the time costs)

Costs of using 3rd party service providers

Providers like Infura and Alchemy provide a free tier to use their services. Obviously, there are limits to the number of API calls that you can make under the “Free Tier”. Currently, Infura permits 100,000 requests per day in the free tier, while Alchemy permits 300 Million requests.

Of course, the above-mentioned numbers are not small numbers, should be doing any form of initial stage development; testing; tutorials etc. But as soon as you go live with the a DAPP, which will easily bust the above limits, you are sitting with costs from Infura / Alchemy.

According to some recent records, on average, Uniswap sends around 30 million requests, Akropolis sends 2 million requests whereas, Sushiswap sends around 25 million requests per day.

Now there is a lot of structuring involved. For eg, if we are designing a DAPP, we do not make our API endpoints public and hence, when our users connect to our DAPP, their wallet connects to a service provider. Hence, do not fret the above numbers straight away.

However, on average, we have witnessed that if you are maintaining a backend to analyse your smart contract data, performance and various other factors, you are definitely looking at ~$200 costs per month.

Costs of running your own node

Aspect 1: Financial (the easily measurable factor)

Hardware requirements to run your own node:

At least 2TB of SDD (yes, we are forward looking and are planning to run the full node)
4GB Ram (oh common, don’t be cheap with a 2GB ram now)
Connected to the internet 24*7
Intel NUC, 7th gen or higher (x86 processor)

On an average, based on the above requirements, we understand that it costs roughly ~600$ a month

Aspect 2: Manpower Costs

It would typically require one of your engineers to least spend 30 mins each day just to monitor the performance of the node; we are also expecting a here and there break-down and hence, more time involvement. This will cost us ~24 hours a month, ie, ~ $1,200 per month.

Conclusion

Running our own node can cost you an estimated cost of $22K / year, compared to an estimated cost of $2,400 / year on account of using 3rd party service providers.

Using a service provider can ease out the process and cut the whole time-consuming instructions. Nonetheless, reliability and some other factors do make the case for running your own node worth considering.

There you go! Now you have the pros and cons. It is, probably, now obvious why majority of the dapp developers in the world choose 3rd party service providers.

However, you need to understand that both of the approaches play a major role individually, and it only you who can determine which approach suits you best.

We would love to know your thoughts; we are open to learn and hence if you think we have missed out anything; more than happy to know.

Authors (open to feedback): Amateur-Dev and Pari Tomar

Upgrade your Smart Contract Deployment Script; impress the shi.t out!

a_mature_dev — Thu, 12 May 2022 06:21:10 +0000

This write-up takes into account our two earlier write-up: Part 1 and Part 2; wherein we have been learning about deployment of smart contracts.

This particular write-up is with the intention of demonstrating a better way for deployment of smart contracts. You can look at this new way of deployment of smart contracts, as an optional strategy; however, if you are shaping your career to become a professional smart contract developer — then I would recommend you to keep this is as a MUST Learn practice.

RECAP

Till now, we have been deploying smart contracts, using a simple script in our: /scripts folder. Our script to deploy our last NFT Smart Contract was as follows:

const { ethers } = require("hardhat");async function main() {
    const NFT = await ethers.getContractFactory("NFT");
    const deployedNFT = await NFT.deploy();
    console.log(`Contract deployed to address:          ${deployedNFT.address}`)
}main()
.then(() => process.exit(0))
.catch((error) => {
    console.error(error);
    process.exit(1);
});

Time to UPGRADE!

First: We are going to install hardhat-deploy from here. Depending on what you use, it will be either npm install or yarn add.

Second: Add require('hardhat-deploy') to our file hardhat-config.js

Our updated config file will look like this:


require('dotenv').config();
require('@nomiclabs/hardhat-ethers');
require('hardhat-deploy'); // <--- This is the new additionconst {API_URL, PRIVATE_KEY} = process.env;
....
....

Third: Create a new folder deploy in the root of the project and add the following file to it. Note the name of the file. It is critical.

// location of the file: ./deploy/00_deploy_NFT.jsconst func = async function (hre) {
  const { getNamedAccounts, deployments } = hre;
  const { deployer } = await getNamedAccounts();
  const { deploy } = deployments;
  await deploy("NFT", {
    from: deployer,
    log: true,
  });
}func.tags = ["NFT"];module.exports = func;

Your folder structure should look like this after the addition of the above file:

Voilà! You have upgraded yourself 🥳🥳🥳🥳🥳

Let’s see the magic of what we have done.

Open a terminal in the location of the folder and run the command: npx hardhat node —-no-deploy This will spin-off a hardhat node with a number of accounts that are to be used for the purpose of deployments
Open a new terminal in the same location of the folder and now run the following command: npx hardhat deploy —-network localhost
If all is done successfully, you should see the following in your terminal:

deploying "NFT" (tx: 0x5c8faff64acb214523566f9fa0d1168159c0c380d71cc5486828e34aff085a19)...: deployed at 0x5FbDB2315678afecb367f032d93F642f64180aa3 with 2525550 gas

AND, you will see a new folder in your directory structure with the name deployments. Something like this:

Dig into the files in the deployments folder and you will notice that it has saved the address to which the contract has been deployed, along with the other details. The details saved in the deployments folder are per chain to which the contracts are deployed.

We ran another command in our terminal npx hardhat deploy --network mumbai-matic to deploy our contract to the Mumbai Matic test network. Our directory structure afterwards was as follows:

As you will notice, we now have a new folder with the name mumbai-matic and also have the details saved in that directory.

There you go!!! You are now a better version of a blockchain developer.

We hope you like what we are doing over here. If you do, please do clap 👏 at the end of the article and yes, do share with your friends.

Also note: You can download and run the same code that we will using in our tutorial (aka tuts) from here 👉 Github repository. If you like out stuff, give us a star 🌟 on Github too.

Happy Coding!!!

Authors (open to feedback): 👇

Amateur-Dev and Pari Tomar

Mint 100s of NFTs in just 5 MINUTES using ERC1155 😊😊

a_mature_dev — Tue, 10 May 2022 13:27:18 +0000

In one of our previous articles, we minted our own NFT where we used the ERC721 contract, which INDEED was an awesome experience for us! Link to that article: 👉 here

Now! We will challenge it to make it more fun and faster!

In this article, we will use the ERC-1155 standard in order to mint our NFT.

Not only this, we will also try to mint our NFTs in less than 5 minutes.

You might be wondering, why use the ERC-1155 for minting our NFTs instead of the standard ERC-721, right?

There are some key differences that should address this question:

One Smart Contract for all: ERC-721 standard produces NFTs solely and forces developers to create a smart contract for each new token. On the other hand, ERC-1155 allows developers to develop a single smart contract that can be used to mint either fungible tokens or NFTs. Yes, this means, multiple of each of these tokens under one contract. It has the ability to support multiple states on the same address and contract. In simpler words, this means you can make in-game payments using a fungible token on that address and simultaneously transfer unique NFT assets as well.
Efficiency: ERC-721 allows a single operation for each transaction. It is expensive and time-consuming. Whereas, ERC-1155 allows multiple operations in a single transaction. Therefore, the transactions are cheaper and more efficient.

Unlike ERC-721, which utilizes significant space, ERC-1155 uses less storage space on a blockchain network. This is because ERC-1155 has the features of:
- Batch Transfer: Transfer multiple assets in a single call.
- Batch Approval: Approve all tokens to an address

This results in less space consumption on the blockchain network.

Now that we have seen some of the benefits of ERC-1155, let’s begin 🏃🏻

Tools we will be using🛠️

Remix IDE: It is a powerful open-source tool that helps you write Solidity contracts straight from the browse and speeds-up the whole development process. Though, in our opinion, this should be in no-manner your go-to strategy for working on projects.
IPFS: IPFS is a distributed system for storing and accessing files, websites, applications, and data. We will be using Pinata client to interact with IPFS. Pinata gives users the ability to upload, manage, and share their content whenever, wherever, and, with whomever they want
MetaMask: MetaMask is a chrome wallet that lets us interact with the blockchain. We will need our wallet details from Metamask. You have many other options, but we are just sticking to this for ease.

Please note, you will have to connect your Metamask to the Mumbai Matic Testnet network for the purpose of this Tuts. Read 👉 this so that you are connected to Mumbai Matic Testnet. Once that is done, you should fetch test tokens; for that head 👉 here

🏋️Now let’s get to the fun part 🏋️‍♀️

1. Write our Smart Contract

In order to write our smart contract, we are going to use Remix IDE to mint our NFTs faster than ever before! 🚅

Therefore, if you are new to Remix IDE we highly recommend you to go through this video.

First of all, we are going to create a solidity file where we’ll be defining our contract and mint some Game of Thrones’ characters’ NFTs. 😮

Therefore, we are going to name our file as GameofThrones.sol

Second, we will import the ERC-1155 contract from Openzeppelin to use its functions in our contract.

Third, we will define our smart contract to mint our NFT that also inherits from Openzeppelin’s ERC1155 contract.

Your code should look similar to this 👇

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC1155/ERC1155.sol";

contract GameofThrones is ERC1155 { }

Then, we are going to specify some names and IDs for the NFTs, which we could use further for testing references.

For example, here we have assigned the IDs to the various character named variables.

By this we could say that the NFT with the ID 1 is JonSnow and so on.

uint256 public constant JonSnow = 1;
uint256 public constant CerseiLannister = 2;
uint256 public constant DaenerysTargaryen = 3;
uint256 public constant NightKing = 4;
uint256 public constant TyrionLannister = 5;
uint256 public constant AryaStark = 6;

Now, we will define the constructor where we are going to use the _mint function from the ERC1155 contract in order to mint our NFT.

Inside the _mint function, we are going to define some values:

The sender’s address
The tokens that we’re going to mint
The amount of tokens we want to mint
And the data of the token

And there’s one interesting thing, we have already uploaded our NFT Metadata to the IPFS to save our time.

IPFS is decentralized storage. And here we have used the Pinata IPFS which gives users the ability to store their data.

This is the folder storing the Metadata that we’re going to use for our NFTs. Therefore, here we have 6 different Metadata for the respective NFTs.

If you’re new to Pinata, we recommend you go through our previous article based on NFT, where we have covered how to upload the metadata of your NFT on Pinata IPFS.

Your constructor should look similar to this 👇

constructor() ERC1155("https://gateway.pinata.cloud/ipfs/QmXLdCoTPVZ8Vf5PrEZR1awPKR8PvxmyEakaR5ummPCPnh/{id}.json") {
        _mint(msg.sender, JonSnow, 100, "");
        _mint(msg.sender, CerseiLannister, 100, "");
        _mint(msg.sender, DaenerysTargaryen, 100, "");
        _mint(msg.sender, NightKing, 1, "");
        _mint(msg.sender, TyrionLannister, 100, "");
        _mint(msg.sender, AryaStark, 100, "");
}

Note that for Game of Thrones characters, all the characters are fungible tokens instead of the NightKing token, which is a non-fungible token as we minted only one of it.

The ERC1155 contract includes the optional extension IERC1155MetaDataURI. That’s where the URI function comes from: we will use it to retrieve the metadata URI.

Thus, if we replace the id with token ID 1 inside the MetadataURI we provided, we could get the metadata of the first NFT.

Result would look similar to this 👇

But OpenSea does not understand the way we encoded the id inside the MetadataURI.

Therefore we have to overwrite the URI function so it works a bit differently. And in order to do that, we are going to need some helper functions to work with the strings.

Therefore, we will import the Strings contract from Openzeppelin’s contract.

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Strings.sol";

And then add the following code inside your contract:

function uri(uint256 _tokenId) override public view returns (string memory) {
        return string(
            abi.encodePacked(
                "https://gateway.pinata.cloud/ipfs/QmXLdCoTPVZ8Vf5PrEZR1awPKR8PvxmyEakaR5ummPCPnh/",
                Strings.toString(_tokenId),
                ".json"
            )
        );
}

So here, we are writing our own implementation of the URI function and we want to take the token ID and then we want to concatenate the base URL and the required token ID (which is an integer) into the string.

By doing this, we will have our ERC-1155 contract ready to deploy!! 😃

Your smart contract should look like this👇

Therefore, now it's TIME to deploy our contract and view our NFTs on Opensea. 🤯

For your ease, you can use this ➡️ link 🔗 to directly load this contract in remix on your browser.

2. Deploy the Smart Contract on Mumbai Matic Testnet

Opensea supports various networks like Rinkeby, Mumbai Matic, etc. Thus, we’re going to use the Mumbai Matic Test network to mint our NFTs.

We will follow some steps to deploy our contract:

To deploy the contract, we’re going to use the Metamask wallet on the Mumbai Matic test network, so that once the contract is deployed, Opensea can grab it easily.
Switch to Mumbai Matic Test Network in your Metamask wallet and make sure you have some test Matic to perform the transaction. If you don’t have test Matic go 👉 here

Then, update the Remix IDE environment to Injected Web3 which you could find under the Deploy & Run Transactions section.
Once done, you can see that the account address shown in the Remix IDE is similar to your Metamask account.

Pick the contract which you want to deploy. In our case, we have the GameofThrones.sol
Now, once you’ll hit the Deploy button, you can see a Metamask window pop-up that asks us to confirm our transaction.

Hit the confirm button to mint our NFT on Opensea.

And there you gooo!!

You have minted your own NFTs. 😲😲😲

Without wasting any time, we will use this link to see our minted NFT on Opensea

https://testnets.opensea.io/<your-account-address>?tab=created

You can see mine here

Showcase your NFTs to your friends and don’t forget to tag us on Twitter at @uv_labs

We will surely retweet your NFT 🥳

And don’t worry, if you get any error messages, you can ask us too by tagging us on Twitter.

Do give us a star, clap if you liked our work.

Authors (open to feedback): 👇

Amateur-Dev and Pari Tomar

Learn to execute Flash Swaps ⚡on Uniswap by yourself

a_mature_dev — Wed, 04 May 2022 16:04:01 +0000

In the previous article, we understood how we can implement a swap between tokens using Uniswap.

In this article, we will be moving one level ahead by exploring Flash Swap by coding a flash swap contract and run tests on it!

We highly recommend you go through the previous article before.

What is a Flash Loan?

Unlike Traditional Loans, in Flash Loans, funds are borrowed and returned in one transaction. This is a MUST.

In Defi, traders (usually through bots) keep looking out for arbitrage opportunities to gain benefits by trading between platforms supplying different prices for the same asset.

This is where the Flash Loans comes into the picture (albeit usually).

With the help of Flash Loan, traders can borrow a large sum of money to execute an arbitrage trade.

How does Flash Loan Arbitrage work?

Consider a situation, where Ethan buys a book for $10 from the Bookstore and then sells that book to Jennifer for $20. In this situation, Ethan buys a book using his money and then straight away doubles it by selling it to Jennifer.

This is exactly how trading arbitrage works.

But unlike Ethan, who used his own money for buying the book from the bookstore, here we could simply use Flash Loans to borrow $10 and then execute a trade, similar to selling the book and then repay the loan (yes, all in 1 single transaction).

Lets dive in coding our own Flash swap contract and test it out!! 😎

1. Create a project and install dependencies

Use the following commands on your CLI to initialize your project.

mkdir Flash_swap && cd Flash_swap
npm init -y

Now, install the required dependencies that we’ll be using for the project.

Use the command provided below and run it on your CLI to install them.

npm install --save hardhat @nomiclabs/hardhat-ethers @nomiclabs/hardhat-waffle ethers @uniswap/v2-core dotenv hardhat chai

2. Initialize your Hardhat Project

Run the command npx hardhat on your CLI and create an empty hardhat config file, since we’re going to build everything from scratch.

Customize your hardhat config:

Because we are going to fork the mainnet to test the Flashswap. Therefore, your hardhat config should look something similar to this:

Note: Replace the <key> component of the URL with your personal Alchemy API key.

Also, if you’re new to mainnet forking, read our article based on it and then follow along with this article.

3. Write a smart contract for Flash swap

Create directories for contracts and tests for better code organisation.

Use the following code in your CLI.

mkdir contracts && mkdir tests

In order to write the flash swap contract, create a file inside the contracts directory and name it flashswap.sol

Writing the smart contract:

First, import the interfaces required and create a contract named as flashSwap.

We will import Uniswap’s interface to use its functions. You can get the interface using this link.

We have also imported IUniswapV2Callee interface. Uniswap will call this function when we execute the flash swap. Technically this is the callback function that Uniswap will call.

It should look similar to this:

Next, we create our contract flashSwap which inherits from IUniswapV2Callee. Solidity supports inheritance between smart contracts, where multiple contracts can be inherited into a single contract. The contract from which other contracts inherit features is known as a base contract, while the contract which inherits the features is called a derived contract.

This contract will have 2 functions:

testFlashSwap(): This is the function we will use to call to trigger the flash swap transaction.
uniswapV2Call(): This is the function that the Uniswap calls

Writing the **testFlashSwap* function:*

This function will take 2 parameters (A) the token that is to be borrowed from Uniswap {the address| and (B) the amount we want to borrow.

First thing that we’ll do is, check that the pair contract for _tokenBorrow and WETH exists. We can do that by calling the getPair function on UniswapV2Factory NOTE: In Uniswap v2, all token pairs are with WETH as one of the coin and hence, to check if a particular token is available on Uniswap, we simply check its availability with WETH. More on what is WETH —> https://weth.io/

address pair = IUniswapV2Factory(UniswapV2Factory).getPair(_tokenBorrow, WETH);
require(pair != address(0), "!pair");

{Please note, we have defined WETH as a variable in our contract already. Please refer to our entire contract at the end}

Inside the UniswapV2Pair, we have 2 tokens, token0, and token1.

We now will check if _tokenBorrow is equal to _token0 or not.

If the values are equal, then amount0Out will be the _amount argument that we pass to the function, otherwise, it would be equal to zero.

Similarly, we will check the same for _token1.

address token0 = IUniswapV2Pair(pair).token0();
address token1 = IUniswapV2Pair(pair).token1();
uint256 amount0Out = _tokenBorrow == token0 ? _amount : 0;
uint256 amount1Out = _tokenBorrow == token1 ? _amount : 0;

As a result, either you’ll have amount0Out equal to _amount and amount1Out equal to 0 or vice-versa.

Then we pass these amount values in Uniswap’s swap function.

bytes memory data = abi.encode(_tokenBorrow, _amount);
IUniswapV2Pair(pair).swap(amount0Out, amount1Out, address(this), data);

As you’ll notice, this is the exact same function that we call to perform a simple swap on Uniswap. Refer to our previous article over here.

The only difference is the last input. If it is empty, then Uniswap will try a simple swap execution.

If it is not empty, that is it has any data, then it would trigger a flashswap.

To pass in the input, we will encode the tokenBorrow and amount as bytes and then pass it to the swap function.

The testFlashSwap function should look similar to:

Let’s write the **uniswapV2Call:* 🤩*

Basic housekeeping: Right now, anyone can access this function, therefore the first thing that we’re going to do is check that this function can only be called by the pair contract. And then, we’ll also check that the sender is equal to the pair contract. For that, use the following code:

address token0 = IUniswapV2Pair(msg.sender).token0();
address token1 = IUniswapV2Pair(msg.sender).token1();
// call uniswapv2factory to getpair 
address pair = IUniswapV2Factory(UniswapV2Factory).getPair(token0, token1);
require(msg.sender == pair, "!pair");

Decoding data: Then, we will decode the data that is passed to us by Uniswap, this is not a mandatory step, but encouraged to do so.

(address tokenBorrow, uint amount) = abi.decode(_data, (address, uint));

Computing fee: Uniswap charges 0.3% for any form of swap. Using the following code, we are computing the fee that our contract will have to bear for undertaking the flashswap.

uint fee = ((amount * 3) / 997) + 1;
uint amountToRepay = amount + fee;

Repayment: Lastly, we have to pay Uniswap the borrowed token including the fee. It can be achieved by using the following code.

IERC20(tokenBorrow).transfer(pair, amountToRepay);

That completes our uniswapV2Call function, which would look similar to the following image:

Now, our flashSwap contract is complete, and should be similar to this:

4. Let’s write some Test Script for our Contract

First of all, we will import the necessary libraries, ERC20 abi, and will also create a basic structure of our test script.

Use the following reference to get a better understanding:

Now, we will define the address of the contract which we’re going to impersonate and the USDC address.

We will also define the amount that we’re going to borrow.

Use the following:

const USDCHolder = "0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE";
const USDCAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
const borrowAmount = 1000000000; // since USDC is 6 decimals, this corresponds to 1000 USDC Coins

Next, we will begin with the before block use the contract we created and deploy it.

before(async () => {
        const TestFlashSwapFactory = await ethers.getContractFactory("flashSwap");
        TestFlashSwapContract = await TestFlashSwapFactory.deploy();
        await TestFlashSwapContract.deployed();
});

Finally, we write our test script to check our Flash swap execution.

A: First, we will impersonate the account which we want to use:

await hre.network.provider.request({
            method: "hardhat_impersonateAccount",
            params: [USDCHolder],
});
const impersonateSigner = await ethers.getSigner(USDCHolder);

B: Then, we will define the USDC Contract

const USDCContract = new ethers.Contract(USDCAddress, ERC20ABI, impersonateSigner)

C: We already knew that Uniswap charges a fee to implement a Flash Swap. Therefore, we will calculate the value of the fee.

const fee = Math.round(((borrowAmount * 3) / 997)) + 1;

D: We need to understand that, since our contract just got deployed in the before block, it does not have any Ether or any USDC. Then, once the flash loan is implemented, the contract has to return the borrowed amount plus the fee.

Therefore, we have to transfer the amount of the fee from the impersonated account to our contract, in order to complete the trade.

Therefore, we will use the following command to transfer the fee to the contract:

await USDCContract.connect(impersonateSigner).transfer(TestFlashSwapContract.address, fee)

D: Then, we will call the testFlashSwap function which we have defined in our contract.

await TestFlashSwapContract.testFlashSwap(USDCContract.address, borrowAmount)

E: It’s time to check whether the Flashswap executed was correct or not. For that, we will check whether the balance of our contract, after the flashswap and the payment of the exact fee that we computed is 0, as it should be, or not.

const TestFlashSwapContractBalance = await USDCContract.balanceOf(TestFlashSwapContract.address)
expect(TestFlashSwapContractBalance.eq(BigNumber.from("0"))).to.be.true;

Your final test script should look like this:

Finally, run your test in your CLI using the command npx hardhat test tests/flashswaptest

The result should look like this:

Voila 🥳🥳🥳 ****Our flashswap passed with flying colours 🤣

Summary

Flash swap allows you to borrow any ERC20 token on Uniswap and execute any code logic, as long as you repay the same token or any other token of the same value plus the fee in the same transaction.

Hope you like our efforts and try and run this by yourselfs. :)

Of course! If you get any error, you can ask us by tagging @uv_labs on Twitter.

Again, all the code that we just ran through is over here 👉 Github repository. Do give us a star if you liked our work.

Converting GitHub to your local IDE #Productivity

a_mature_dev — Tue, 05 May 2020 07:35:42 +0000

This is a cross-post so to say. This is just putting out a blog post of the video that has been done up by LevelUp Tutorials over here.

Objective of this post:

This is more like a productivity post. I am a big-time sucker for productivity-improving tools. Now, at present, I am running multiple development projects. There is Zapper.fi (aka DeFiZap), then I have my day job, and lastly various side projects most of them related to blockchain stuff, to keep improving my knowledge base and stuff.

So with that in place, I keep finding my help navigating through Github more often than not. In this post, I am listing down the amazing tools that were (for me) discovered by Scott Tolinski.

Note

You MUST note that each of these tools is chrome extensions which modify the manner in which you will be surfing GitHub.com.

Tool 1: GitHub Dark Theme

Now this one needs no explanation; the name suffices to say what it does. I love it, it just makes me so comfortable looking at the dark GitHub; somehow it adds to the 'feel home factor' (more on this feel below). It is available over here.

Tool 2: File Icon for GitHub and GitLab

Again another super simple cool tool that needs no explanation. Just look at the screenshot below (as they say, a picture says a 1000 words):

It just makes the browsing experience so easy!

This one is available over here

Tool 3: Enhanced GitHub

Did you ever come across a thought "Oh man, I wish, I could just download this one file from this repo, rather than clone the entire repo" or like "oh man, I need to copy the contents of this file, damn, click raw and then select all and then copy"; "damn, I need something to make this easier for me". Well, I think, I keep bumping into this request everyday and boom! Enhanced GitHub solves this!!

One more screenshot:

oh man, I cannot explain how much I love this tool!

This one is available over here

Tool 4: Octotree

As this tool defines itself, it converts Github to Github on steroids. Boy-o-boy, this tool is so cool. It practically converts my Github to like VSCode window. Here take a look:

Damn bruh! Is that not sick! I can browse through files like magic and have a mind map of what is happening where. This crazy cool tool is available here. Looking at GitHub as if it is VSCode makes me feel home, makes me feel I have so much control over the code.

Tool 5: Sourcegraph

Last in my list, but in no fashion the least is Sourcegraph.

I am browsing through code and then there is a funny import or require, and I am like, ok, now what's written in that file; Sourcegraph just makes jumping to the relevant file so easy. Again, similar to my VSCode experience; something again that makes me feel home.

The last screenshot that I would like to share:

Crazy right! This marvelous magical tool is available over here.

I hope you like all of the above and use it. If you have any other cool tools to use, please comment out below. As I mentioned above, I am into productivity tools; would love to use anything that supports by laziness ;)

Cheers!

Flash Loans | Make profit in almost 14 secs - if you are smart enough. People have already started doing it.

a_mature_dev — Sun, 23 Feb 2020 07:00:38 +0000

Assumption:
Another one of my quick notes => I assume that you (the reader) understands Blockchain [Ethereum specifically], smart contracts and DeFi (aka decentralised finance). If not, this will be tough to follow and hence, advisable to dig about these first and come back over here.

DeFi - in one sentence (almost):

Traditional financial system of (a) lending, (b) borrowing, (c) doing something with the borrowed money, (d) repaying loans - but only by and for blockchain assets, through smart contracts.

What is a Flash Loan?

A loan (yes, like a very traditional loan) that is taken out and paid out in 1 blockchain transaction [typically in ~14 secs].

Why Flash Loans?

From the lenders' point of view: almost safe (my bet is 100%), principal and interest is received back instantly (well, ~14 secs and interest income.

From the borrowers' point of view: Can borrow a very very high amount, as far as I know what I am doing, no collateral required, no collateral required (again!!!), instant.

How does it work?

Blockchain Transaction:

On the Ethereum blockchain, everything that happens is a transaction. For eg:

If Alice sends Bob an Ether (aka ETH) it is a transaction.
If I write a smart contract that will the ETH that I give it and transfer it to Alice and Bob in two equal halves, it is a transaction.
If a Smart Contract
- takes ETH,
- looks up the price of gold on the LSE,
- buys appropriate amount of Gold Tokens,
- holds it for 30 mins,
- relooks at the value of gold on LSE,
- sells the Gold Tokens,
- gives out the proceeds back to the user who deposited the ETH,
- after computing a brokerage and then transferring the brokerage to my account - it is also a transaction (1 Single transaction).

of the above three examples, the last two can be a single transaction or can be broken into multiple transactions; they do not have to be 1 single transaction - it is the manner in which the transaction is defined and designed in a Smart Contract.

Flash Loan Capable Smart Contracts (the core of this entire article / blog post)

So flash loan smart contracts are written up in a manner that anyone (literally anyone; Yes, any darn one!) can (for ease of understanding), submit a transaction which will require some amount to begin with (this is the loan / principal), do something, and pay back the loan (with some interest) at the end of the single transaction.

More simply put, flash loan is an algorithm {loan algo}, to which I will submit my algorithm {my algo}, which will check that units that the loan algo gives (LHS) is equal to the units that it gets back and the end of the execution of my algo (RHS).

Implications

Now that you have some skeleton understanding of what a flash loan is and how it works - let us think and see some use cases / implications:

Eg Use Case You see a potential arbitrage opportunity

buy Stock A on local stock exchange in you local currency,
transfer stock to a global custodian
exchange stock units for its Global Depository Receipt (aka GDR)
sell GDR in a foreign market
convert foreign currency to local currency
make arbitrage gains due to exchange rate difference All executed in a matter of seconds!

could you do this in a traditional financial world? Answer: (if you are like me, a common man and not a highly rich dude and not much of an infrastructure required to execute the above): NO, you cannot.

could you do this on the Ethereum blockchain? Answer: (if you can write a smart contract): Hell YA! You can!

Any restrictions? Answer: No
Any KYC? Answer: No
Any limit on amount? Answer: No (mostly)

Conclusion Answer: I can (you can)(anyone can) do transactions worth MILLIONS of USD!! make gains, faster than it would have take to load an average webpage.

Eg REAL WORLD transactions:
Eg 1: Transaction 1 - click me!
Eg 2:
Eg 3:

I would like to know what your thoughts are on Flash Loans - are you

My Opinion: WOW, this is going to take the financial system to a whole new level! I take this to be in the likes of the Apple iPhone to the mobile-phone universe: things will not be the same ever again!

Written with StackEdit.

ERC20 vs ERC777 | Quick Understanding and why ERC777 is not being used

a_mature_dev — Sat, 15 Feb 2020 07:00:55 +0000

Why not ERC777?

Assumption: This is one of my short and quick articles. There is a assumption over here that you (the reader) is aware of Blockchain, Ethereum, Solidity and Tokens. If you do not understand these terms this article will not be of much help to you. You should dig-up these terms and possibly come back over here.

Background

The Ethereum blockchain is filled with tons and tons of tokens. Pretty much every fungible token is as per the ERC20 Standard (some of them may be ERC223, which is an extension of the ERC20 token standard).

I have been working with loads of such tokens at DeFiZap.com. One of the biggest issue that an ERC20 Token has is that it lacks (of what I would call) hooks / event triggers. Let me explain through an example below:

If Alice were to send Ether to a Smart Contract, the Smart Contract will be made aware of this incoming Ether (through various functions). This made aware nature of the Ether within the Ethereum blockchain is what I call, hooks / event triggers.

However, if Alice were to send Dai to a Smart Contract; the Smart Contract will NOT be made aware of this transfer.

Why not made aware?

To understand why the Smart Contract will NOT be made aware, we will have to understand ONE of the CORE ideas of an ERC20 Token. The long story short version is that the word 'transfer' is actually the root cause (that is how I see it).

Essentially, an ERC20 Tokens does not literally move from one wallet address to another (or smart contract to smart contract); only the so-called owner of the ERC20 is changed inside the Smart Contract that is the issuer of the ERC20. In simple sense, if someone in Monaco has allocated a Ferrari in my name, a transfer would just be like the Ferrari stays there, only the name of the owner of that Ferrari is changed from my name to (lets say) Spider-Man. Now, sadly our dear Friendly Neighbourhood Spider-Man was not informed of this and thus, was NOT made aware.

So what is the issue with that?

As is the case above, since Spider-Man did not know, he did not come to collect the car and drive it off to his own world. Same way, if the Smart Contract or a Wallet is not aware that is owns the ERC20 Token it cannot do anything.

What would the Smart Contract do with it anyway?

While there are tons of uses, one of the most common is to swap it for something else. For eg, converting Dai to cDAI.

HackyWay used currently?

The way the above made aware is currently resolved is (a) allowing the cDAI Smart Contract to use the DAI that I own (through a function known as approve) and (b) informing cDAI (through a function call) that you are now approved to use my DAI, please take it, swap it and issue cDAI to me (and literally, to my name in your ownership register). That means two (2) transactions.

What is the issue?

Bluntly, I do not like 2 transactions.

Why ERC777?

Easy to guess, similar to ERC20, ERC777 is also a standard for developing tokens on the Ethereum Blockchain. The standard has built in provisions for the made aware hooks.

Adoptability

Now, since the first time I read about ERC777 I fell in love with it. I design Smart Contracts that deal with ERC20 and as of now, I have to keep asking my users to approve my smart contract address first and then call a function my smart contract that will do what they need to do.

Hence, I was so much pushing for all token designers to look into ERC777 and use that standard. The odd part is that the standard has been in out since 2017 and yet not 1 token in the market uses ERC777. This made me wonder why, till obviously, I went ahead to work on my own ERC777.

Answer

ERC777 is a larger and comprehensive scheme. One of the drawback of gaining the functionality of the hooks / event triggers is the manner in which the recipient smart contract is designed. Essentially, the recipient smart contract (note!!!, it this drawback is only applicable to smart contracts and NOT to EOA wallets)need to have a function which will listen to such transfer.

Sadly, the world has moved on and no-one in the legacy smart contract world ever designed their contracts with this functionality. Now, since those contracts are not upgradable, they will never be in compliant with ERC777 standard. Thus, with that said, we now know why no one is using the powerful, yet powerless ERC777 coin standard.

Defining Roles in Smart Contract

a_mature_dev — Tue, 04 Feb 2020 04:48:15 +0000

This is a quick and short article that I wanted to get out of my drafts. There is a big presumption over here that you are aware of what blockchain and smart contract is. If you are not aware of these concepts, I will have to request you to hunt these concepts down or put in a comment below and I will guide you through it.

Why do we need Roles?

Fact: Blockchain is like an immutable database.

Given this fact, if you are a dev who is into developing smart contracts specially for the ethereum world, then you are already aware that smart contracts are (by strict definition) not upgradable. That is to say, once they are deployed they will stay there forever and you will not have the option to modify the code.

With that in mind, Smart Contract developers design different methods in which some functions within the Smart Contracts are only available to certain wallet/public addresses.

This is mostly from a security point of view.

EG: The most commonly used type of Smart Contract where only a few accounts are permitted to do certain actions are "Multi-Sig Wallets".

What are Roles?

In the simplest terms, Roles are like what you would see in a movie/act/play/game. Each wallet address is assigned a character and each character has a limited set of power or an advantage, depending on what and how you define that character in the Smart Contract.

How to do it?

Without a doubt, you are free to define your own mechanisms to implement this; however, I find OpenZeppelin's Roles based framework really useful for asap development.

Quick Code Example

pragma solidity ^0.5.0;

import "@openzeppelin/contracts-ethereum-package/contracts/access/Roles.sol";

///@author amateurdev

contract TestingRoles  {
    using Roles for Roles.Role;

    // state variables
    Roles.Role private _adders;
    Roles.Role private _subtractors;

    uint16 public ini_number;

    constructor(address adder, address subtractor, uint16 _ini_number)
        public
    {
        ini_number = _ini_number;
        _adders.add(adder);
        _subctractors.add(subtractor);
    }

    function add(uint16 _number) public returns (uint256) {
        require(_adders.has(msg.sender), "It is not an adder");
        ini_number = ini_number + _number;
        return ini_number;
    }

    function sub(uint16 _number) public returns (uint256) {
        require(_subtractors.has(msg.sender), "It is not an subtractor");
        require(_number <= ini_number);
        ini_number = ini_number - _number;
        return ini_number;
    }

}

The above code is a real quick smart contract which will help you test out the power of the Open Zeppelin's Roles Library/Contract.

Essentially, what we are doing is:

at the time of deployment of this contract
defining two addresses (ideally should be different) one of which has the 'power' to add and the other one has the 'power' to subtract
setting up an initial value of the test/dummy number

Post the deployment, (obviously) only the adders will be able to add and only the subtractors will be able to reduce the number.

I am not going into how to deploy it or test it, with the objective to not drag this article.

How is this helpful?

(a) I cannot thank enough to Open Zeppelin and their team for doing the basic groundwork. Using Open Zeppelin's infrastructure, the development time for Smart Contract is like half of what it would take otherwise. Above is a quick example of that.

(b) I keep facing situations where I have to develop Smart Contracts in which different parties are involved which have different vested interests. Thus, using the above, I am able to define functions that can be used by the respective parties within their limitations.

What is the Libra Coin and Network. Quick Bullet pointers

a_mature_dev — Wed, 18 Sep 2019 03:07:37 +0000

High-level overview

Main Governing body is the Council
Libra reserve is the membership fee that the entities have to pay to be a part of the council
The reserve fee is US$10 million
The reserve will be giving out interest return to the members
Every1 in the organization/council must interact with the Libra blockchain using the Libra core software
Libra Core software is open source
The Council also has something known as an Advisory Board - these are external / no-conflict-of-interest educational institutions
The Network will be maintained and run by a Validator Node - which initially will be formed by the first participants in the Council
Libra Users will have a hexadecimal addresses
Calibra - FB's digital wallet platform
This will be used to submit the transaction to the network
It will be integrated to all the FB products (eg Instagram)
To make sure that Libra is Open Source, there is a likely hood that there will be other wallets as well

Little Deeper Dive

Libra Association and the Reserve

The documentation and the framework is still in discussion mode
Stable Coin:
- Backed by the membership fee collected
  - 1 : 1 asset-backed ("Basket of Fiat Currencies")
  - Most of the assets will be low volatility assets, eg, Government Debts
- New Libra Coins will be minted on 1:1 deposit of fiat currencies by any user of the FB / Libra network [Question, how will the unstable currencies be valued to be able to mind LC]
- There will be very less direct interaction with the reserve; a portion of the LC from the reserves will be sold to Authorized Resellers
- The AR will then be one of the important points of functioning in the local market
- It is expected that the AR will be responsible for managing the compliance with local regulations

Regulatory

Couple of Global regulatory organizations have expressed concerns
India, China, and Germany have explicitly mentioned that they will NOT be permitting the use of LC within their geography
China is apparently working on its on own cryptocurrency (though is is surprising and not surprising for its own reason!!!)

Technical Part

Libra Core is written Rust
Rust has garnered a lot of attention due to its speed
Transactions will Gas for execution
Transaction will have:
- Sender Address
- Program (A Move Language Byte Code)
- Gas Price
- Maximum Gas Amount
- Sequence Number
Proof of Stake
Likely hood of having randomness in selecting a leader validator node
LibraBFT:
- All calls to the network will be through Admission Control; which will be made available only through the Council
- Admission Control will accept 2 kinds of calls: Query and Transactions
Move Programming Language
- Unique Ownership Any resource within the network cannot be copied, it can only 'move' within the network
- `No 3rd Party "Modules" (loosely read Smart Contracts) will not be accepted immediately

Hope you liked this quick bullet point discussion. Feel free to throw in any question that you may have on Libra Coin. Personally, I am quite excited about it and would love for it to come to life.

Written with StackEdit.

Deploy your webpage in just 1 (ONE) command

a_mature_dev — Wed, 18 Sep 2019 03:00:51 +0000

TL;DR

Create an account on Zeit
Install the NOW npm package
Go to the repo that you want to deploy, in the terminal
Execute the command now
Vola!! You should be done.

Background

I started to learn to code sometime back. Sticking to the traditions, my journey began with dipping my toes in HTML → CSS → JavaScript and beyond.

As many may agree, self-learning coding is a little tough. While you need to be disciplined, the most painful is to know what to learn to code and when. More often than not, I would find myself staring at a topic that I did not know anything about and then there I go in the rabbit hole.

Deployment of Projects

During this entire learning process, which is still on btw, the one thing that I wanted to be a pro at is the deployment of my projects.

You can safely assume that I spent countless hours trying to nail it. Long story short, after a lot and lot of time spent, the following helped me in seeing my projects come to life:

Github Pages (for static websites)
Heroku (for complicated NodeJS or Flask projects)
- First through the deployment of docker containers (as for some reason this felt the easiest), and then through
- Heroku Git (Yes! It's very likely I went the reverse order from learning the complicated route first)

Now, both the above routes (only from the perspective of deployment) have its own learning curve and trust me, as a new coder and super eager to see my project come to life on the internet, I was somewhere, irritated with the learning.

Introduction to `ZEIT Now`

I was playing out with Svelte - just the hello world to begin with - and during this playing around, their documentation gave this command - to deploy your app follow the command now and I was intrigued.

ZEIT Now is a cloud platform for static sites and serverless functions. It enables developers to host websites and web services that deploy instantly, scale automatically, and requires no supervision, all with no configuration.

So what is this one command to deploy

now - that is it to deploy your project. However, minor steps to reach that stage are:

you need to have an account with zeit
in the terminal you need to have done now login

once these 2 steps are done, you are all set

Use the command now in the terminal and it will prepare your site and make it live in almost 1 min.

Next Steps

After this stage, I was tempted to getting my site a proper domain name and make it live as a production website. Since Zeit gives you the option to buy a domain and connect it to your webpage. I will be writing a separate blog on this topic; it is a bit more technical.

Till then, have fun and keep coding!!

Signing-off
Amateur-Dev

Written with StackEdit.

DEV Community: a_mature_dev

Web3: Should I use Infura / Alchemy or Run a Node?

Lets talk about the Costs (financial and then the time costs)

Costs of using 3rd party service providers

Costs of running your own node

Conclusion

Upgrade your Smart Contract Deployment Script; impress the shi.t out!

Mint 100s of NFTs in just 5 MINUTES using ERC1155 😊😊

*Tools we will be using*🛠️

1. Write our Smart Contract

2. Deploy the Smart Contract on Mumbai Matic Testnet

Learn to execute Flash Swaps ⚡on Uniswap by yourself

What is a Flash Loan?

How does Flash Loan Arbitrage work?

1. Create a project and install dependencies

2. Initialize your Hardhat Project

3. Write a smart contract for Flash swap

4. Let’s write some Test Script for our Contract

Summary

Converting GitHub to your local IDE #Productivity

Flash Loans | Make profit in almost 14 secs - if you are smart enough. People have already started doing it.

DeFi - in one sentence (almost):

What is a Flash Loan?

Why Flash Loans?

How does it work?

Blockchain Transaction:

Flash Loan Capable Smart Contracts (the core of this entire article / blog post)

Implications

ERC20 vs ERC777 | Quick Understanding and why ERC777 is not being used

Why not ERC777?

Background

Why not made aware?

So what is the issue with that?

What would the Smart Contract do with it anyway?

HackyWay used currently?

What is the issue?

Why ERC777?

Adoptability

Answer

Defining Roles in Smart Contract

Why do we need Roles?

What are Roles?

How to do it?

Quick Code Example

How is this helpful?

What is the Libra Coin and Network. Quick Bullet pointers

High-level overview

Little Deeper Dive

Libra Association and the Reserve

Regulatory

Technical Part

Deploy your webpage in just *1 (ONE)* command

TL;DR

Background

Deployment of Projects

Introduction to ZEIT Now

So what is this one command to deploy

Next Steps

Tools we will be using🛠️

Deploy your webpage in just 1 (ONE) command

Introduction to `ZEIT Now`