DEV Community: amoweolubusayo

Navigating the Future of Tech: Should Software Engineers Focus on AI or Blockchain in 2023?

amoweolubusayo — Thu, 26 Jan 2023 03:38:16 +0000

As technology continues to evolve at a rapid pace, software engineers are faced with the decision of which emerging field to focus on in order to stay ahead of the curve. Two technologies that have gained significant traction in recent years are blockchain and AI. Both offer unique opportunities and challenges, and choosing which one to focus on in 2023 will depend on a variety of factors.

Blockchain technology is best known for its use in the creation of digital currencies like Bitcoin, but it has the potential to be used in a wide range of applications beyond just finance. Blockchain technology is essentially a decentralized, digital ledger that can be used to record transactions across a network of computers. It is secure, transparent, and tamper-proof, making it well-suited for use in industries such as finance, supply chain management, and voting systems.

AI, on the other hand, is a set of technologies that allow machines to learn and make decisions based on data. It encompasses a wide range of techniques, including machine learning, natural language processing, and computer vision. AI is being used in a wide range of applications such as self-driving cars, personal assistants, and medical diagnosis.

So, which one should software engineers focus on in 2023? The answer is not clear cut, as it depends on the engineer's interest, expertise and the industry they are working in.

If an engineer is interested in finance, supply chain management, or voting systems, then blockchain technology may be the best choice. Blockchain technology is still in its early stages and there is a lot of room for innovation and growth in this space. Companies such as ChainGuardian, ConsenSys, and BlockFi are building blockchain-based solutions in these areas and are worth keeping an eye on.

On the other hand, if an engineer is interested in areas such as self-driving cars, personal assistants, or medical diagnosis, then AI may be the better choice. AI is being used in these areas to great effect and is expected to continue to be a major growth area in the coming years. Companies such as Google, Microsoft, and NVIDIA are investing heavily in AI and are worth keeping an eye on.

Both blockchain and AI are promising technologies with a lot of potential. Software engineers should focus on the technology that aligns with their interests and expertise, as well as the industry they are working in. Keep an eye on the companies that are building solutions in these areas, as they are likely to be at the forefront of innovation and growth in the coming years.

Building in the Bear Market: The Resilience of Decentralized Finance Projects

amoweolubusayo — Thu, 26 Jan 2023 03:16:20 +0000

Over the past few years, we've seen an explosion of DeFi projects and protocols, each with its own unique approach to creating a more open and accessible financial system. Some of the most popular DeFi projects include decentralized exchanges (DEXs) like Uniswap and SushiSwap, lending platforms like Aave and Compound, and yield farming protocols like Yearn Finance and Curve.

Despite the bear market that has gripped the industry, many DeFi projects are still actively building and making progress on their platforms. In this article, we'll take a look at some of the most promising DeFi projects that are still making headway in the bear market, and explore what they're doing to continue building and growing.

Aave

One of the most promising DeFi projects still making progress in the bear market is Aave. Aave is a decentralized lending platform that allows users to borrow and lend cryptocurrencies in a trustless and decentralized manner. The platform is built on the Ethereum blockchain and uses smart contracts to facilitate lending and borrowing. Aave has a feature called "flash loans," which allows users to borrow funds for a very short period of time, typically just a few minutes. This feature has the potential to open up a whole new set of use cases for DeFi lending and borrowing.

MakerDAO

Another DeFi project that is still building in the bear market is MakerDAO. MakerDAO is a decentralized stablecoin platform that allows users to collateralize their assets and mint a stablecoin called DAI. The platform is also built on the Ethereum blockchain and uses smart contracts to facilitate the collateralization and minting process. MakerDAO has been making steady progress on its platform, and has a feature called "Multi-Collateral DAI (MCD)." This feature allows users to collateralize a wider range of assets, including real-world assets such as commodities and real estate.

Uniswap

Uniswap is another DeFi project that is still building in the bear market. Uniswap is a decentralized exchange (DEX) that allows users to trade cryptocurrencies in a trustless and decentralized manner. The platform is also built on the Ethereum blockchain and uses smart contracts to facilitate trading. Uniswap has been making steady progress on its platform, and has a feature called "Uniswap v3" which has been designed to improve scalability and reduce the trading fees.

In summary, the bear market has not stopped several DeFi projects from building and making progress. Aave, MakerDAO, and Uniswap are examples of projects that have been actively working on their platforms and launching new features. Despite the current market conditions, these projects have a strong community, great teams and a clear vision which make them promising projects to still look out for in the DeFi space.

Top 3 Optimistic Rollup L2 projects

amoweolubusayo — Sun, 24 Jul 2022 05:06:00 +0000

Before we go into discussing optimistic rollups, some base knowledge is needed. One of which is blockchain scaling.

Blockchain scaling

Ethereum as a case study has grown to a level where the blockchain has hit some capacity limits. As a result, Ethereum network usage has become more expensive, necessitating scaling. The whole point of scaling actually is to increase transaction throughput (the number of transactions per second) and speed (faster finality) without compromising security or decentralization.

Scaling a blockchain ecosystem can be done in one of two ways

Increasing the capacity of transactions on the blockchain itself.
Modifying how you utilize the blockchain.

You can read more about scaling here

The second point highlighted involves users conducting the majority of their activity off-chain in an L2 ( Layer 2 ) protocol rather than directly placing all activity on the blockchain.

Rollups

Rollups is one of the types of layer-2 scaling. It can be refered to as a layer 2 hybrid scheme. The concept of Rollup is that Rollups keep some data per transaction on-chain while moving computation and state storage off-chain.

Here is a diagram that shows how rollups work

Source: vitalik.ca

Rollup Types

The two types of rollups are:

Optimistic rollups: also called fraud proofs
ZK rollups: also called validity proofs

Optimistic rollups

In optimistic rollups, the rollup contract records each batch's hash and the history of each state's roots. Optimistic rollups by default don't perform any computation. Instead, they suggest the new state to Mainnet after a transaction.

Optimistic Rollup L2 projects

Here are three projects that use the Optimistic Rollup Technology

Arbitrum

Arbitrum is a suite of Ethereum scaling solutions that enables high-throughput, low cost smart contracts while maintaining trustlessly security. Arbitrum supports all EVM language and natively supports all Ethereum tooling. Arbitrum Rollup differs from Ethereum in terms of price: transactions on Arbitrum only cost a small portion. It is quick and easy to port contracts from Ethereum to Arbitrum; no new software or code changes are required.

Website: https://arbitrum.io
Documentation: https://developer.offchainlabs.com
Explorer: https://explorer.arbitrum.io

Optimism

Optimism is a Layer 2 scaling protocol for Ethereum applications thus it makes transactions cheap. Optimism is intended to be an expansion of Ethereum. The CanonicalTransactionChain is a unique Ethereum smart contract that houses all Optimism blocks. Code in the CanonicalTransactionChain ensures that new Ethereum transactions cannot change the list of existing blocks. Users can send any messages between smart contracts on Optimism and Ethereum.

Website: https://www.optimism.io
Documentation: https://community.optimism.io/docs
Explorer: https://optimistic.etherscan.io

Boba Network

The foundation of Boba is actually the optimistic rollup created by Optimism. In addition to its emphasis on enhancing computing, Boba has it's own unique features such as: providing a swap-based system for quick exits from L2 to L1 (the standard exit period of rollups is 7 days) and an additional cross-chain messaging such as a message-relayer-fast.

Website: https://boba.network
Documentation: https://docs.boba.network
Explorer: https://blockexplorer.boba.network

A lot of developers are building on all 3 that I reviewed in this article. To get started with them, you can try out by deploying a contract. The following resources will help:

Conclusion

In this article, we have discussed blockchain scaling, the need for it, the various ways of scaling, rollups, optimistic rollups and finally projects whose technology are based on optimistic rollups.

I hope this article helped to keep things in perspective for someone out there.

References

https://vitalik.ca/general/2021/01/05/rollup.html
https://ethereum.org/en/developers/docs/scaling
https://l2beat.com

Staking. What happens behind the scenes. Brief code walkthrough and mathematical calculation

amoweolubusayo — Sat, 11 Jun 2022 11:07:29 +0000

Hello again. I'm here to talk DeFi. Have you ever had to stake? Wonder what happens behind the scenes? I have staked on platforms like Binance and I have always wondered how the calculations were done. Haven't staked before? No worries. I will give a brief description of what staking means.

Think of staking as mining but using lesser resources. So like you know people mine bitcoin for example and are rewarded for it, for humor purposes only, some people also mine the famous PI in hope for rewards. Staking works similarly but instead of mining, you lock your crypto in order to receive rewards. Your locked crypto helps to secure and assist in operations of a blockchain network.

After doing some research, I got to know about what I would call The MasterChef Algorithm.

In this article, I will be taking you through Pancakeswap's MasterChef contract briefly as well as the basic Mathematical calculation involved in staking.

As it turns out, most staking contracts implement the MasterChef contract. Now, let's proceed to understanding basic variable meanings.

contract MasterChef is Ownable {
    using SafeMath for uint256;
    using SafeBEP20 for IBEP20;

    struct UserInfo {
        uint256 amount;
        uint256 rewardDebt;
 }

 struct PoolInfo {
        IBEP20 lpToken;           
        uint256 allocPoint;    
        uint256 lastRewardBlock; 
        uint256 accCakePerShare; 
    }

From this code above, there is a struct called

UserInfo

. This represents a user who has come in to stake.

unit256 amount
unit256 rewardDebt

amount here stands for how many Liquidity Pool(LP) tokens the user has provided.

Notice we also have rewardDebt. Reward debt is basically the reward that a user isn't entitled to.

The next struct is the

PoolInfo

This stands for the information of each pool. This pool is where tokens are locked in a smart contract

IBEP20 lpToken
uint256 allocPoint
uint256 lastRewardBlock
uint256 accCakePerShare

lpToken here stands for the contract address of LP token.

allocPointhere means that: How many tokens (which in this case is CAKE) is to be distributed to this pool? How many allocation points is assigned to this pool?

lastRewardBlock here means that: What block number was the token (CAKE) distributed to last?

accCakePerShare here means the Accumulated token (CAKEs) per share

  function enterStaking(uint256 _amount) public {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        updatePool(0);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accCakePerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
               safeCakeTransfer(msg.sender, pending);
            }
        }
        if(_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accCakePerShare).div(1e12);

}

This function above is a call to stake CAKE tokens to MasterChef and this function below is a call to Withdraw CAKE tokens from STAKING.

function leaveStaking(uint256 _amount) public {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(0);
        uint256 pending = user.amount.mul(pool.accCakePerShare).div(1e12).sub(user.rewardDebt);
        if(pending > 0) {
            safeCakeTransfer(msg.sender, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accCakePerShare).div(1e12);

        syrup.burn(msg.sender, _amount);
        emit Withdraw(msg.sender, 0, _amount);
    }

With this code, let's do a little simulation.

Assuming that on every block, the reward a user can get is $1.

RewardsPerBlock = $1

User A deposits $100 on block 0
User B deposits $400 on block 10

We need to note these variables

RewardsPerBlock = Reward you can get per block
NumberOfBlocks = Number of blocks
TotalTokens = Total Tokens present in the block 
DepositUserA = How much User A deposited
ShareUserA = Share for User A
AccumulatedRewardUserA = Accumulated Reward for User A

ShareUserA = DepositUserA / TotalTokens
AccumulatedRewardUserA = (RewardsPerBlock * NumberOfBlocks * ShareUserA) + AccumulatedRewardUserA previously

From block 0 to block 10, User A gets 100% of their rewards, which is calculated like this

Block 0 - Block 10 

RewardsPerBlock = $1
NumberOfBlocks = 10
TotalTokens = $100
DepositUserA = $100
ShareUserA = 100/100 = 1
AccumulatedRewardUserA = (1 * 10 * 1) + 0 = $10

Now on block 10, a new User B who is just joining the pool deposits $400. It might interest you to know that User B will also get 100% of rewards from block 0 to 10. However, it becomes a debt. Some other contract use timestamp instead of a debt. If User B decides to harvest at block 15, User B's reward will be calculated as

Reward(Block 10 to Block 15) - Reward(Block 0 to Block 10)

The Reward(Block 0 to Block 10) in this case is the rewardDebt

Let's move to block 15. At block 15, User A wants to harvest their reward.

From block 10 to block 15, can you guess how much reward User A will get?

Block 10 - Block 15 
Remember there is now User B 

RewardsPerBlock = $1
NumberOfBlocks = 5
TotalTokens = $100 + $400 = $500
DepositUserA = $100
ShareUserA = 100/500 = 1/5 
AccumulatedRewardUserA = (1 * 5 * 1/5) + 10 = $1 + $10 = $11


DepositUserB = $400
ShareUserB = 400/500 = 4/5
AccumulatedRewardUserB =  (1 * 5 * 4/5) + 0 = $4

UserA will now 'harvest' the AccumulatedRewardUserA thus getting $11.

After harvest, the pool needs to balance so AccumulatedRewardUserA = $0

Let's move to block 20. At block 20, User B wants to harvest their reward.

Block 15 - Block 20 

RewardsPerBlock = $1
NumberOfBlocks = 5
TotalTokens = $100 + $400 = $500
DepositUserB = $400
ShareUserB = 400/500 = 4/5 
AccumulatedRewardUserB = (1 * 5 * 4/5) + 4 = $4 + $4 = $8

UserB will now 'harvest' the AccumulatedRewardUserB thus getting $8.

After harvest, the pool needs to balance so AccumulatedRewardUserB = $0

Let's move to block 30. At block 30, Both User A and User B wants to harvest their reward.

Block 20 - Block 30 

RewardsPerBlock = $1
NumberOfBlocks = 10
TotalTokens = $100 + $400 = $500

DepositUserA = $100
ShareUserA = 100/500 = 1/5 
AccumulatedRewardUserA = (1 * 10 * 1/5) + 0 = $2 

DepositUserB = $400
ShareUserB = 400/500 = 4/5 
AccumulatedRewardUserB = (1 * 10 * 4/5) + 0 = $8

The Total Number of harvested reward
User A = AccumulatedRewardUserA (Block 15) + AccumulatedRewardUserA (Block 30)
User A = $11 + $2 = $13

User B = AccumulatedRewardUserB (Block 20) + AccumulatedRewardUserB (Block 30)
User B = $8 + $8 = $16

User A harvested $13 as reward in total
User B harvested $16 as reward in total

With this base knowledge, you can chose to add your own customizable feature to your DeFi app.

This article is just gives the basic overview of the Algorithm. You will get more insight by implementing a contract of your own. I encourage you to do that.

Final Words

I hope this makes sense and you now understand staking better. Feel free to drop a comment or question. I'm willing to interact.

References
https://dev.to/heymarkkop/understanding-sushiswaps-masterchef-staking-rewards-1m6f

https://github.com/pancakeswap/pancake-farm/blob/master/contracts/MasterChef.sol

Front running in DeFi and protective measures

amoweolubusayo — Sat, 04 Jun 2022 12:29:58 +0000

So, I started looking at the DeFi space. I have found it interesting so far understanding the technicalities involved in trading especially on Dexs.

This article however will be a less technical which is a little drift from my recent articles as I will be concentrating on one of the common problems traders face using exchanges.

I hope you find this insightful!

Preamble

Have you ever experienced a scenario where you received less than you expected after a trade? Yes? You might just have been front runned.

In this article, I would talk about front running, how to be protected from front running as well as what protocols can do.

Front running in DeFi

Front running is the act of taking advantage of advanced information or prior knowledge of transactions to buy or sell assets. A front runner capitalizes on the way transactions are ordered within a block to take out profit from another trader thereby leading to losses for this trader involved.

On the Ethereum blockchain, there is the problem of front-running where anyone who runs a full-node Ethereum client can see unconfirmed transactions and send transactions with a higher gas price. Actually, front-runners do not even need to run a full node to see transactions. They can have a bot that monitors pending transactions in the mempool or use any infrastructure such as the ones I wrote in this article here Top 5 Web3 infrastructure. Bots are also able to quote a higher gas price. Bots operate in milliseconds so imagine the speed in reading a transaction from the memory pool, calculating the optimal transaction size, configuring transactions and then executing them.

Sadly, front running is such a common practice on Ethereum-based DEXs.

How can we be protected from Front running?

Players involved: DEXs, users, protocols.

What can DEXs do?

Fast Matching orders: Orders can be matched in every block with very fast block times so that there is very little room for front-running to happen

Provide off-chain privacy: Privacy should be taken seriously in markets such as DeFi.

What can users do?

Overpay on Gas: As a user, try to go for the ‘fast’ gas option on your wallet of choice, this way there would be no time for front runners to formulate an order. If you wish to place a large value order, this approach is recommended.

Place value smaller orders: You can also place smaller value orders. Front runners take into consideration gas fees on both entering and exiting the market, so you are most likely safe by trading low cash volume.

What I think protocols can do on the long run

Protocols should consider building untraceable blockchain node infrastructure such that node requests are somewhat hidden from people who wish to manipulate the market.

They can do this by building tools that guarantees no monitoring of blockchain requests. In traditional blockchain, the requests to node providers can be tracked and monitored thus compromising privacy and giving front runners an unfair advantage from your metadata. Protocols can look into building tools with 0 monitoring of blockchain requests.

Any other thoughts are welcome too! Kindly comment below.

I would be posting more DeFi- related articles in the coming weeks/months. Stay tuned…

Upgrading Smart Contracts using OpenZeppelin Upgrade Plugin

amoweolubusayo — Sat, 21 May 2022 16:41:43 +0000

A bit of intro

When I came across upgradeable contracts, I was taken aback a bit. Upgrade? Why is upgrade a topic when smart contracts are designed to be immutable by default? Once a contract is created on the blockchain, there is no way to change it. You might have the same questions/thoughts as I had or even more. While researching how to write an upgradeable contract, I had a bit of a challenge understanding and finding a well-explanatory guide which is why I will be discussing some fundamentals in this article alongside showing you how to write a simple upgradeable smart contract using the openzepplin plugin.

The Why

Some scenarios call for modification of contracts. Relating it to regular daily lives, two parties who have signed a contract can decide to change agreements, perhaps they have to remove some terms or add some more or fix mistakes. As long as they both consent to it, it can be changed. On a blockchain such as Ethereum, it's possible that a bug was found in a smart contract that has already been deployed to production or more functionalities are just required. It could be anything really. It definitely calls for an upgrade.

OpenZeppelin

OpenZeppelin is the leading company when it comes to securing products, automating, and operating decentralized applications. They protect leading organizations by performing security audits on their systems and products. They have a library of modular, reusable, secure smart contracts for the Ethereum network, written in Solidity. Thanks to the OpenZeppelin Upgrades Plugin, it's quite easy to modify a contract while still preserving important things like address, state, and balance.

The How

Smart contracts can be upgraded using a proxy. Basically, there are two contracts:

Contract 1 (proxy/point of access): This contract is a proxy or a wrapper that will be interacted with directly. It is also in charge of sending transactions to and fro the second contract that I would be talking about next.
Contract 2 (logic contract): This contract contains the logic.

One thing to note is that the proxy never changes, however, you can swap the logic contract for another contract meaning that the access point/proxy can point to a different logic contract (in other words, it gets upgraded). This is illustrated below

Source: https://docs.openzeppelin.com/upgrades-plugins/1.x/proxies#upgrading-via-the-proxy-pattern

To learn more about the proxy concepts, visit the openzepplin proxy upgrade pattern docs page and openzepplin proxy page

Upgradeability Patterns

We have several upgradeability patterns. Listed below are four patterns

UUPS proxy: EIP1822
Transparent proxy: EIP1967 (We would be focusing on this in this article)
Diamond Storage: EIP2355
Eternal Storage: ERC930

Transparent Proxy (EIP1967)

Transparent proxies include the upgrade and admin logic in the proxy itself. I would refer to the admin as the owner of the contract that initiates the first upgrade.

Using the transparent proxy, any account other than the admin that calls the proxy will have their calls forwarded to the implementation. In the same vein, if the admin calls the proxy, it can access the admin functions, but the admin calls will never be forwarded to the implementation.

In summary, it's best for the admin to be a dedicated account only used for its purpose which is obviously to be an admin.

Practical Steps

Prerequisite: knowledge of how to set up dev environment and how to write smart contracts. More info here

Let's write an upgradeable contract! We will be openzepplin's hardhat-upgrades plugin. To install, simply run

npm install --save-dev @openzeppelin/hardhat-upgrades @nomiclabs/hardhat-ethers ethers

In your hardhat.config file, you need to load it in

// js
require('@openzeppelin/hardhat-upgrades');

// ts
import '@openzeppelin/hardhat-upgrades';

I will be using js for this article

Your hardhat.config.js file should be similar to this

require("@nomiclabs/hardhat-ethers");
require("@openzeppelin/hardhat-upgrades");
require("@nomiclabs/hardhat-etherscan");

//Using alchemy because I intend to deploy on goerli testnet, an apikey is required
//The mnemonic is your account's mnemonic
//if you intend to verify your contracts, you need to open an account on etherscan and copy the apikey
//all important keys should not be exposed, it can be kept in a secret.json file and added to gitignore

const { alchemyApiKey, mnemonic } = require("./secrets.json");

module.exports = {
  networks: {
    goerli: {
      url: `https://eth-goerli.alchemyapi.io/v2/${alchemyApiKey}`,
      accounts: { mnemonic: mnemonic },
    },
  },
  etherscan: {
    apiKey: "YOUR_API_KEY",
  },
  solidity: "0.8.4",
};

Contract 1 (contracts/Atm.sol) (proxy contract)

In your contracts folder, create a new .sol file. In this article, I would be simulating an atm/bank. So, create Atm.sol. The code should look similar to this

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract Atm {

    // Declare state variables of the contract
    uint256 bankBalances;

    // Allow the owner to deposit money into the account
    function deposit(uint256 amount) public {
        bankBalances += amount;
    }
    function getBalance() public view returns (uint256) {
        return bankBalances;
    }
}

Test Contract

Test your contract in test/Atm-test-js as illustrated below

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Atm", function () {
  before(async function () {
    this.Atm = await ethers.getContractFactory("Atm");
  });

  beforeEach(async function () {
    this.atm = await this.Atm.deploy();
    await this.atm.deployed();

    it("", async function () {});
    await this.atm.deposit(1000);
    expect((await this.atm.getBalance()).toString()).to.equal("1000");
  });
});

To test, run this command

npx hardhat test

Deploy Contract

!Important: In order to be able to upgrade the Atm contract, we need to first deploy it as an upgradeable contract. It is different from the deployment procedure we are used to. We are initializing that the start balance be 0. The script uses the deployProxy method which is from the plugin.

Create a deploy-atm.js script

const { ethers, upgrades } = require("hardhat");

async function main() {
  const Atm = await ethers.getContractFactory("Atm");
  console.log("Deploying Atm...");
  const atm = await upgrades.deployProxy(Atm, [0], {
    initializer: "deposit",
  });

  console.log(atm.address, " atm(proxy) address");
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

You can decide to test this as well. If you wish to test, your test file should be similar to this

Test Script

const { expect } = require("chai");
const { ethers, upgrades } = require("hardhat");
const { Contract, BigNumber } = "ethers";

describe("Atm (proxy)", function () {
  let box = Contract;

  beforeEach(async function () {
    const Atm = await ethers.getContractFactory("Atm");
    //initilize with 0
    atm = await upgrades.deployProxy(Atm, [0], { initializer: "deposit" });
  });

  it("should return available balance", async function () {

    expect((await atm.getBalance()).toString()).to.equal("0");

    await atm.deposit(1000);
    expect((await atm.getBalance()).toString()).to.equal("1000");
  });
});

After confirming tests,

Let's deploy to local first, we use the run command and deploy the Atm contract to dev network.

$ npx hardhat run --network localhost scripts/deploy-atm.js
Deploying Atm...
0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9  atm(proxy) address

At this point, we have successfully deployed and have our proxy and admin address.

Contract 2

We want to add a new feature to our contract, a simple feature which is to include an add function that adds 500 to our balance.

Create contracts/AtmV2.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./Atm.sol";

contract AtmV2 is Atm{
    // adds to the balance by 500
    function add() public {
        deposit(getBalance()+500);
    }
}

Test Contract

Refer to how we tested Contract 1 and basically follow same logic.

Upgrade Contract

Now is the time to use our proxy/access point address. We would be using the upgradeProxy and 'getAdmin' methods from the plugin. Recall our proxy address from our deployment console above as we would be needing it here.

Create scripts/upgrade-atmV2.js. Your script should look similar to this

const { ethers, upgrades } = require("hardhat");

const proxyAddress = "YOUR_PROXY_ADDRESS_FROM_DEPLOYMENT";

async function main() {
  console.log(proxyAddress, " original Atm(proxy) address");
  const AtmV2 = await ethers.getContractFactory("AtmV2");
  console.log("upgrade to AtmV2...");
  const atmV2 = await upgrades.upgradeProxy(proxyAddress, AtmV2);
  console.log(atmV2.address, " AtmV2 address(should be the same)");
  console.log(
    await upgrades.erc1967.getAdminAddress(atmV2.address),
    "Proxy Admin"
  );
console.log('Atm upgraded');
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Test script

Create a scripts/AtmProxyV2-test.js. It should look similar to this

const { expect } = require("chai");
const { ethers, upgrades } = require("hardhat");
const { Contract, BigNumber } = "ethers";

describe("Atm (proxy) V2", function () {
  let atm = Contract;
  let atmV2 = Contract;

  beforeEach(async function () {
    const Atm = await ethers.getContractFactory("Atm");
    const AtmV2 = await ethers.getContractFactory("AtmV2");

    //initilize with 0
    atm = await upgrades.deployProxy(Atm, [0], { initializer: "deposit" });

    atmV2 = await upgrades.upgradeProxy(atm.address, AtmV2);
  });

  it("should get balance and addition correctly", async function () {
    expect((await atmV2.getBalance()).toString()).to.equal("0");

    await atmV2.add();
    //result = 0 + 500 = 500
    expect((await atmV2.getBalance()).toString()).to.equal("500");
    //balance is now 500, so add 100;
    await atmV2.deposit(100);
    //result = 500 + 100 = 600
    expect((await atmV2.getBalance()).toString()).to.equal("600");
  });
});

After confirming tests,

Let's deploy our newly added contract with additional feature, we use the run command and deploy the AtmV2 contract to dev network.

npx hardhat run --network localhost scripts/upgrade-atmV2.js
Compilation finished successfully
upgrade to AtmV2...
0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9  AtmV2 address(should be the same)
0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512  Proxy Admin

To deploy on goerli, simply replace

npx hardhat run --network localhost

with

npx hardhat run --network goerli

There you have it, check for your addresses on Goerli Explorer and verify it.

For a view of all contracts, you can check out my contracts at

Summary

While it is a fast approach to use the openzepplin plugin and it varies across teams, a better way to understand and do upgrades is to copy the transparency proxy sol files and related sol files from openzepplin's into your project. This protects you from upstream attacks.

This comes to the end of this article. Hope you learnt a thing or two. I would appreciate feedbacks as well! Kindly leave a comment. Happy building!

References:
https://docs.openzeppelin.com/upgrades-plugins/1.x/writing-upgradeable

https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/proxy

https://dev.to/yakult/tutorial-write-upgradeable-smart-contract-proxy-contract-with-openzeppelin-1916

Top 5 Web3 Infrastructure providers you should know

amoweolubusayo — Sun, 08 May 2022 12:22:14 +0000

Infrastructure is essential

Infrastructure is simply the building blocks or foundation of any system. Complex systems need a suitable infrastructure to function efficiently. Infrastructure is a very important topic in Web3.

Building on blockchains such as Ethereum, Polygon, Avalanche, and Fantom requires a lot of resources if one intends to set up their own infrastructure from scratch. For example, you would need to set up a node which can be expensive and time-consuming.

Today, we now have infrastructure providers that provide developer tools, APIs, node functionalities, and data access so that developers/builders are able to concentrate more on their products and are able to ship their dApps faster. On your preferred blockchain, you get to easily build and operate full nodes and validator nodes usually in pretty simple steps.

This topic was inspired by my personal usage and interaction with some infrastructure providers. In no particular order, here is a review of some of the best Web3 infrastructure providers alongside their features, products, and pricing.

Infura

Infura simplifies blockchain development by bringing all of your tools together in one place: Ethereum Nodes, Eth2 Nodes, Transaction Relaying, Layer 2 Networks, IPFS, Filecoin, and more.

Infura Products

Ethereum API: The Infura API suite gives rapid access to the Ethereum network through HTTPS and WebSockets.
IPFS API and Dedicated Gateway: Infura's IPFS API and dedicated gateway, designed for speed and simplicity, links apps of all sizes to distributed secure storage, paving the path for more resilience online.
Infura Transactions (ITX): ITX is the simplest method to submit an Ethereum transaction; simply choose your budget, fill your tank, and let them discover the cheapest gas pricing for you.

Infura Pricing

Infura's pricing fits per app and app usage. There are also custom plans with bulk savings, service level agreements, and limitless projects.

For the Ethereum API, there is a free plan that supports up to 3 projects and 100,000 Requests per Day as well as the developer plan which supports 10 Projects and 200,000 Requests per Day for $50/month. Other plans are also available such as the team and growth plan.

For the IPFS API & Dedicated Gateway, there is a free plan with up to 5GB of storage and 5GB data transfer up as well as the Plus plan which is billed per usage with unlimited storage at $0.08/GB and unlimited data transfer at $0.12/GB.

Ankr

Ankr offers a genuinely distributed and decentralized Web3 architecture for running node services. Ankr Build is a completely distributed, multi-chain infrastructure network and toolset that simplifies application development. Ankr currently supports the following chains: Arbitrum, Avalanche, Binance Smart Chain, Celo, Ethereum, Fantom, Gnosis, Harmony, IoTex, Moonbeam, Near, Nervos, Polygon and Solana

Ankr Products

Public Community RPC APIs: The Ankr Protocol network is topped by the Public RPC Layer.
Ankr Scan: Ankr Scan is a Multi-Chain Explorer that allows you to see assets from several chains as well as those tied to a single wallet address. Think EtherScan but for multiple chains.
Node Services: For 50+ chains, full, archive, and validator/staking nodes are accessible on Ankr.

Ankr Pricing

Ankr offers adjustable options and price plans to fit all budgets and needs.

The Public RPCs are free to use with an offer of access to Full and Archive Data, a soft limit of 1M requests per day, and HTTPS connection. The Premium RPCs cost about 10000 ANKR(approximately $717.44) with unlimited rate limit, unlimited requests, HTTPS and WebSockets connection, and Global node coverage.

There are several API pricing plans such as the free plan with a 20 rate-limit per second and 170,000 Requests per day. There is also the basic plan which costs about $49/month for access to 200 rate-limit per second, 1M Requests per day and the builder plan which costs about $224/month for access to 600 rate-limit per second and 5M requests per day.

QuickNode

QuickNode makes it simple to power blockchain apps and scale-up business by providing elastic APIs, sophisticated tools and analytical tools. QuickNode currently supports the following chains: Binance Smart Chain, Ethereum, Arbitrum, Optimism, Avalanche, Fantom, Luna, Solana, Algorand, Terra, Gnosis, Polygon and Celo.

QuickNode Products

QuickNode APIs: QuickNode provides either a dedicated endpoint that always serves traffic from the same location as specified when the endpoint was launched or access to their global network, which always routes traffic to the nearest available endpoint.
NFT API: Without having to filter through individual smart contracts, QuickNode's NFT API allows you to discover any NFT, verify ownership, and retrieve transaction history and key collection information.

QuickNode Pricing

QuickNode provides a 7-day free trial plan known as the Launch plan after which a fee of $9/month is required and it gives access to Domain Masking, Analytics, HTTP Endpoint and Rate Limits of 150k responses per day. There is also the Build plan which costs $49/month for rate limits of unlimited responses per day, support response within 12 hours together with Domain Masking, Analytics, HTTP Endpoint and URL Whitelisting.

The Scale plan and Enterprise/Custom plans are also available. The Scale plan costs $299/month. If you also need a private blockchain cloud, QuickNode can provide it.

Moralis

Moralis offers a unified approach for developing high-performance dApps and compatibility with favorite web3 tools and services. Consider Moralis as Firebase but for Web3. Moralis offers managed backend services for blockchain applications. Moralis currently supports the following chains: Ethereum, Binance Smart Chain, Polygon, Arbitrum, and Avalanche.

Moralis Products

Moralis Web3 SDK: The Moralis JavaScript SDK is the means via which the builder's dApp will communicate with the Moralis Server. The SDK may be used to access and set user data in order to get balances, NFTs, events, or transactions. It supports crypto login and user management, IPFS integration and dApp hosting.
Moralis Web3 API: Moralis Web3 API is a sophisticated blockchain API that allows you to query data from any chain.
The Web3 API can be called using the Moralis SDK with just a few lines of code.
Speedy Node API: Speedy Nodes have the same functionality as regular Ethereum, Polygon, or BSC nodes, but they are faster, more reliable, and completely integrated with all Moralis services.

Moralis Pricing

The free plan is called the Starter Plan and is very suitable for people that are just starting off with blockchain development. It offers free access to unlimited plugins, IPFS Gateway, and community support with 10M requests per month using Speedy Nodes + Moralis API.

For blockchain professionals, there is the Pro plan that costs $49 per month with access to everything in the free plan with more requests, a higher Rate Limit, and email support with 25M requests per month using Speedy Nodes + Moralis API.

For larger teams, there is the Enterprise plan with custom requests per month, SLAs, and premium chat support (Phone, Chat, Email).

Alchemy

Alchemy powers some of the top Web3 applications that are existing today. Alchemy gives the capabilities of a node and a no-configuration in-house set of developer tools for quicker prototyping, debugging, and shipping of dApps. Alchemy currently supports the following chains: Ethereum, Polygon, Arbitrum, Optimism, Flow, StarkNet and Crypto.org.

Alchemy Products

Alchemy Supernode: Alchemy Supernode's revolutionary web3 design amplifies every piece of node capability with separate distributed systems and ensures real-time data accuracy using a proprietary coordinator service.
Alchemy Notify: Alchemy Notify provides the UX builders expect and need. Alchemy Notify allows users to deliver appropriate, timely alerts on the most significant Web3 events such as notifications for mined transactions, dropped transactions, and smart contract events which are integrated.
Alchemy Build: Alchemy Build is a no-configuration in-house developer tool package that allows you to prototype, debug, and release products more quickly. Alchemy Build allows you to quickly prototype and fix unsuccessful requests with instant UI feedback.
Alchemy Monitor: Alchemy Monitor is an all-in-one dashboard and alarm system for app health, performance, and user behavior.
Enhanced and Chain APIS: Alchemy provides access to improved API methods for returning block and transaction requests, smart contract event logs, and pending transactions in a virtual mempool. Furthermore, access to updated WebSockets that are continually listening for changes and manage reconnection and backfilling missing events automatically.

Alchemy Pricing

Alchemy provides the free tier plan which gives free access to Supernode, Build, Monitor, Notify, Enhanced APIs, No Daily Request Limits, Full Archive Data and supports up to 5 Apps.

The Growth plan costs about $49/month with access to everything in the free plan together with Auto-Scaling Compute Units, Parity Trace and Geth Debug , 2x Higher Throughput and supports up to 15 Apps.

The Enterprise plan includes access to everything in the Growth plan plus Committed Use Discounts, Custom SLAs, Custom Throughput and supports an unlimited number of Apps.

With that, we have come to end of my review! I recommend that you try out any of them that suits your needs! Happy hacking and building😁! LFG🚀🚀🚀! WAGMI🚀🚀!

How to deploy your .NET core apps to Azure Kubernetes

amoweolubusayo — Fri, 04 Feb 2022 11:35:53 +0000

A simple web app to display ETH to USD price feed using DIA Oracle

amoweolubusayo — Wed, 02 Feb 2022 08:27:59 +0000

What are oracles?

Oracles are data feeds that connect blockchains to off-chain, real-world information so that you can query data in your smart contracts. Your smart contracts will be able to execute based upon inputs and outputs from the real world. They typically provide a way for web3 ecosystems to access existing data sources and advanced computations. They are very useful for data analysts, data providers and data users.

DIA Oracle

One of such existing oracle is the DIA oracle. DIA provides a reliable and verifiable bridge between off-chain data from various sources and on-chain smart contracts that can be used to build a variety of financial dApps. There are quite a number of things you can do with DIA. You can develop applications and sources on top of DIA. In this article, I would be creating a simple app that displays ETH/USD price. Presently, DIA allows you do several other pairs such as BTC, DIA, USDC, FTM, SDN, KSM, MOVR which are all USD based.

Time to code
Let's get to code, shall we! I will be using javascript and html for this.

Create/Navigate to your project folder:

mkdir pricefeed
cd pricefeed

Now create index.html and index.js files:

touch index.html
touch index.js

I will be using one of DIA's deployed contracts. For this writeup, I would be using the smart contract address deployed on Binance mainnet.

Nagivate to the contract tab on bscscan

Here is the contract's source code

pragma solidity 0.7.4;                                                                                                                                                                                                                      

contract DIACoinmarketcapOracle {                                                  
    mapping (string => uint256) public values;                                     
    address oracleUpdater;                                                         

    event OracleUpdate(string key, uint128 value, uint128 timestamp);              
    event UpdaterAddressChange(address newUpdater);                                

    constructor() {                                                                
        oracleUpdater = msg.sender;                                                
    }                                                                              

    function setValue(string memory key, uint128 value, uint128 timestamp) public {
        require(msg.sender == oracleUpdater);                                      
        uint256 cValue = (((uint256)(value)) << 128) + timestamp;                  
        values[key] = cValue;                                                      
        emit OracleUpdate(key, value, timestamp);                                  
    }                                                                              

    function getValue(string memory key) public view returns (uint128, uint128) {
        uint256 cValue = values[key];                                              
        uint128 timestamp = (uint128)(cValue % 2**128);                            
        uint128 value = (uint128)(cValue >> 128);                                  
        return (value, timestamp);                                                 
    }                                                                              

    function updateOracleUpdaterAddress(address newOracleUpdaterAddress) public {
        require(msg.sender == oracleUpdater);                                      
        oracleUpdater = newOracleUpdaterAddress;                                   
        emit UpdaterAddressChange(newOracleUpdaterAddress);                        
    }                                                                              
}

Scroll down to also find the contract's ABI as we would be using it shortly.

Now looking at the contract, there is a getValue method, in order to get the response from the method, make a call to the method as shown below. Remember also that we are using the key ‘ETH’

Your code should look like this

const currentPriceResponse = await contract.methods.getValue('ETH').call()

Copy the ABI as we would also be using it in our code. In the end, your js file would look something close to this

async function connect() {
    const priceElem = document.querySelector('#price')
    try {
        priceElem.textContent = 'Updating price...';

        const ABI = [ABI]

        const web3 = new Web3(new Web3.providers.HttpProvider("https://bsc-dataseed.binance.org/"))
        const contract = new web3.eth.Contract(ABI);
        contract.options.address = "0xbAFEe71d40baBC12a3D0B2b8937ee62D3A070835";
        const currentPriceResponse = await contract.methods.getValue('ETH').call()
        console.log(currentPriceResponse[0]);
        if (currentPriceResponse[0]) {
            const formatter = new Intl.NumberFormat('en-US', {
                style: 'currency',
                currency: 'USD',
                minimumFractionDigits: 2,
            });
            priceElem.textContent = formatter.format(currentPriceResponse[0] / 100000);
        }

    } catch (e) {
        priceElem.textContent = 'An error occurred while updating the price, please refresh your page.';
    }
}

window.onload = function() {
    connect();
}

Let's give some edits to the index.html file. You can write something as simple as a div or a header.

<h5>
    <span>Current Value: <i id="price"></i></span>
</h5>

Run your app and you would see that you are getting ETH/USD prices in real time. That’s pretty much it! A sample is deployed here. Feel free to check out the Source Code.
Thanks for reading! I hope you learnt a thing or two.

Glossary
Off-chain: Off-chain transactions refer to those transactions occurring on a cryptocurrency network that move the value outside of the blockchain. Due to their zero/low cost, off-chain transactions are gaining popularity, especially among large participants. Read more

On-chain: On-chain transactions refer to cryptocurrency transactions that occur on the blockchain and remain dependent on the state of the blockchain for their validity. On-chain transactions are considered valid only when the blockchain has been updated to reflect the transactions on the public ledger. Read more

Smart contracts: A "smart contract" is simply a program that runs on a blockchain. It's a collection of code (its functions) and data (its state) that resides at a specific address on the blockchain. Read more

ABI : The Contract Application Binary Interface (ABI) is the standard way to interact with contracts in the Ethereum ecosystem, both from outside the blockchain and for contract-to-contract interaction. Data is encoded according to its type, as described in this specification. The encoding is not self describing and thus requires a schema in order to decode. Read more