DEV Community: Viral Sangani

How to create an upgradeable smart contract in Celo

Viral Sangani — Mon, 25 Jul 2022 10:41:00 +0000

What are upgradeable smart contracts?

Usually, when we deploy a smart contract, it’s impossible to update or change the code since it’s on-chain, and that’s how it should be. This increases the safety and trust of users who interact with that contact.

But there might be cases where you want to upgrade your smart contract, like fixing severe bugs and adding some critical features for the users. Traditionally doing this is not possible. The best one can deploy is a new smart contract with bug fixes with all the information migrated. This does not end here; one must update the references where the old contract address was used and inform existing users to use the new contract.

This can be overwhelming, but there is a way to handle these cases by using Upgradeable contracts. An upgradeable smart contract can be updated and edited after the deployment. This can be achieved by a plugin/tool created by OpenZeppelin.

In a nutshell

The plugin is used to deploy the contracts on Hardhat or truffle. Whenever in the future you wish to upgrade the smart contract, use the same address that you used to deploy the first contract via the plugin, and the plugin will handle the transferring of any state and data from the old contract while keeping the same contract address to interact with.

OpenZeppelin uses a proxy pattern where they deploy three smart contracts to manage the storage layer and implement smart contracts. Whenever a contract call is invoked, the user indirectly calls the proxy contract, and the proxy contract passes the parameters to the implemented smart contract before sending the output back to the user. Now since we have a proxy contract as a middle man, imagine how you want to change something in your implemented contract. All you have to do is deploy the new contract and tell your proxy contract to refer to the latest smart contract, and voila. All users are using the updated contract.

How do upgradeable contracts work?

When we use OpenZeppelin’s upgradeable plugin to deploy the contract, three contracts are deployed —

Implemented Contract — The contract the developers create which contains all the logic and functionalities.
Proxy Contract — The contract that the end-user interacts with. All the data and state of the contract are stored in the context of the Proxy contract. This Proxy Contract is an implementation of the EIP1967 standard.
ProxyAdmin Contract — This contract links the Proxy and Implementation contract.

What is ProxyAdmin? (According to OpenZeppelin docs)
A ProxyAdmin is a contract that acts as the owner of all your proxies. Only one per network gets deployed. When you start your project, the ProxyAdmin is owned by the deployer address, but you can transfer ownership of it by calling transferOwnership.

When a user calls the proxy contract, the call is delegated to the implementation contract. Now to upgrade the contract, what we have to do is:

Deploy the updated Implementation Contract.
Updating the ProxyAdmin so that all the calls are redirected to the newly implemented contract.

OpenZeppelin has created a plugin for Hardhat and Truffle to handle these jobs for us. Let’s see step by step how to create and test the upgradeable contracts.

Writing upgradeable smart contracts

We will be using Hardhat’s localhost to test the contract locally and Celo Alfajores test network.

Initialize project and install dependencies

mkdir upgradeable-contract && cd upgradeable-contract
yarn init -y
yarn add hardhat
yarn hardhat // choose typescript

Add plugin and update hardhat.config.ts

yarn add @openzeppelin/hardhat-upgrades
// hardhat.config.ts
import '@openzeppelin/hardhat-upgrades';

To understand the flow, we will be using Greeter.sol a contract. We will create and deploy several versions of this contract.

Greeter.sol
GreeterV2.sol
GreeterV3.sol

NOTE — The big difference between a normal contract and an upgradeable smart contract is upgradeable smart contracts do not have a constructor.

//contracts/Greeter.sol
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
contract Greeter {
    string public greeting;
    // Emitted when the stored value changes
    event ValueChanged(string newValue);
    function greet() public view returns (string memory) {
        return greeting;
    }
    function setGreeting(string memory _greeting) public {
        greeting = _greeting;
        emit ValueChanged(_greeting);
    }
}

This is a very simple Greeter contract that returns the value of greeting whenever we call greet() method.

Unit testing for Greeter.sol

Create a file called 1.Greeter.test.ts and add the following content.

// test/1.Greeter.test.ts
import { expect } from "chai";
import { Contract } from "ethers";
import { ethers } from "hardhat";
describe("Greeter", function () {
  let greeter: Contract;
beforeEach(async function () {
    const Greeter = await ethers.getContractFactory("Greeter");
    greeter = await Greeter.deploy();
    await greeter.deployed();
  });
it("should greet correctly before and after changing value", async function () {
    await greeter.setGreeting("Celo to the Moon");
    expect(await greeter.greet()).to.equal("Celo to the Moon");
  });
});

Run the test:

yarn hardhat test test/1.Greeter.test.ts

Results:

Greeter
    ✔ should greet correctly before and after changing value
1 passing (334ms)
✨  Done in 1.73s.

Let’s write a deploy script and deploy Greeter.sol it to Hardhat’s local node. Create a file named Greeter.deploy.ts in scripts directory and paste the following code.

// scripts/Greeter.deploy.ts
import { ethers, upgrades } from "hardhat";
async function main() {
  const Greeter = await ethers.getContractFactory("Greeter");
  console.log("Deploying Greeter...");
  const greeter = await upgrades.deployProxy(Greeter);
console.log(greeter.address, " greeter(proxy) address");
  console.log(
    await upgrades.erc1967.getImplementationAddress(greeter.address),
    " getImplementationAddress"
  );
  console.log(
    await upgrades.erc1967.getAdminAddress(greeter.address),
    " getAdminAddress"
  );
}
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Run the local node and deploy the Greeter.sol contract:

yarn hardhat node
yarn hardhat run scripts/Greeter.deploy.ts --network localhost

Results:

Deploying Greeter...
0x9A676e781A523b5d0C0e43731313A708CB607508  greeter(proxy) address
0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0  getImplementationAddress
0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82  getAdminAddress
✨  Done in 2.74s.

Note: If you run the deployment command several times you can notice that adminAddress does not change.

Now we need to implement the increment feature in the existing contract. Instead of replacing the current contract we will create a new contract and change the proxy to refer to the new contract.

Creating GreeterV2.sol

// contracts/GreeterV2.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Greeter.sol";
contract GreeterV2 is Greeter {
    uint256 public counter;
    // Increments the counter value by 1
    function increment() public {
        counter++;
    }
}

Writing unit tests for GreeterV2 before deploying.

import { expect } from "chai";
import { BigNumber, Contract } from "ethers";
import { ethers } from "hardhat";
describe("Greeter V2", function () {
  let greeterV2: Contract;
beforeEach(async function () {
    const GreeterV2 = await ethers.getContractFactory("GreeterV2");
    greeterV2 = await GreeterV2.deploy();
    await greeterV2.deployed();
  });
it("should retrieve value previously stored", async function () {
    await greeterV2.setGreeting("Celo to the Moon");
    expect(await greeterV2.greet()).to.equal("Celo to the Moon");
  });
it("should increment value correctly", async function () {
    expect(await greeterV2.counter()).to.equal(BigNumber.from("0"));
    await greeterV2.increment();
    expect(await greeterV2.counter()).to.equal(BigNumber.from("1"));
  });
});

Run the test —

yarn hardhat test test/2.GreeterV2.test.ts

Results —

Greeter V2
    ✔ should retrieve value previously stored
    ✔ should increment value correctly
2 passing (442ms)
✨  Done in 6.43s.

The above test was designed to only test GreeterV2.sol not the upgraded version of Greeter.sol. Let’s write and deploy the GreeterV2 in proxy patter and test if GreeterV2 works correctly.

// test/3.GreeterV2Proxy.test.ts
import { expect } from "chai";
import { Contract } from "ethers";
import { ethers, upgrades } from "hardhat";
describe("Greeter (proxy) V2", function () {
  let greeter: Contract;
  let greeterV2: Contract;
beforeEach(async function () {
    const Greeter = await ethers.getContractFactory("Greeter");
    const GreeterV2 = await ethers.getContractFactory("GreeterV2");
greeter = await upgrades.deployProxy(Greeter);
// setting the greet value so that it can be checked after upgrade
    await greeter.setGreeting("WAGMI");
greeterV2 = await upgrades.upgradeProxy(greeter.address, GreeterV2);
  });
it("should retrieve value previously stored correctly", async function () {
    expect(await greeterV2.greet()).to.equal("WAGMI");
await greeter.setGreeting("Celo to the Moon");
    expect(await greeterV2.greet()).to.equal("Celo to the Moon");
  });
});

Here we are setting the greeting value to WAGMI in Greeter (V1) and after upgrading, checking the greeting value in GreeterV2.

Run the test —

yarn hardhat test test/3.GreeterV2Proxy.test.ts

Results —

Greeter (proxy) V2
    ✔ should retrieve value previously stored correctly
1 passing (521ms)
✨  Done in 6.45s.

Writing a script to update Greeter to GreeterV2.

Note that the greeter proxy address is 0x9A676e781A523b5d0C0e43731313A708CB607508 that we got when we deployed Greeter.sol. We need a proxy address to deploy GreeterV2.sol.

Create a file called GreeterV2.deploy.ts and add the following code.

// scripts/2.upgradeV2.ts
import { ethers, upgrades } from "hardhat";
const proxyAddress = "0x9A676e781A523b5d0C0e43731313A708CB607508";
async function main() {
  console.log(proxyAddress, " original Greeter(proxy) address");
  const GreeterV2 = await ethers.getContractFactory("GreeterV2");
  console.log("upgrade to GreeterV2...");
  const greeterV2 = await upgrades.upgradeProxy(proxyAddress, GreeterV2);
  console.log(greeterV2.address, " GreeterV2 address(should be the same)");
console.log(
    await upgrades.erc1967.getImplementationAddress(greeterV2.address),
    " getImplementationAddress"
  );
  console.log(
    await upgrades.erc1967.getAdminAddress(greeterV2.address),
    " getAdminAddress"
  );
}
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Running deployment script for GreeterV2.sol

We need to start from the beginning, i.e., deploy Greeter.sol first, get the proxy address, and use that to deploy GreeterV2.sol.

yarn hardhat node
yarn hardhat run scripts/Greeter.deploy.ts --network localhost

Here we got 0x9A676e781A523b5d0C0e43731313A708CB607508 as a proxy address. (Update the proxy address in scripts/GreeterV2.deploy.ts).

yarn hardhat run scripts/GreeterV2.deploy.ts --network localhost

Results —

0x9A676e781A523b5d0C0e43731313A708CB607508  original Greeter(proxy) address
upgrade to GreeterV2...
0x9A676e781A523b5d0C0e43731313A708CB607508  GreeterV2 address(should be the same)
0x0B306BF915C4d645ff596e518fAf3F9669b97016  getImplementationAddress
0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82  getAdminAddress
✨  Done in 2.67s.

Overriding the existing methods

Now let’s say you want to add a custom name field in with the greeting such that when greet() is called, the name is added to the returned string.

Create a new file called GreeterV3.sol in contracts directory and add the following code —

// contracts/GreeterV3.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./GreeterV2.sol";
contract GreeterV3 is GreeterV2 {
    string public name;
    function setName(string memory _name) public {
        name = _name;
    }
    function greet() public view override returns (string memory) {
        return string(abi.encodePacked(greeting, " ", name));
    }
}

Let’s write test cases to deploy and test GreeterV3 . Create a file called 4.GreeterV3Proxy.test.ts and add the following test cases.

// test/.GreeterV3Proxy.test.ts
import { expect } from "chai";
import { BigNumber, Contract } from "ethers";
import { ethers, upgrades } from "hardhat";
describe("Greeter (proxy) V3 with name", function () {
  let greeter: Contract;
  let greeterV2: Contract;
  let greeterV3: Contract;
beforeEach(async function () {
    const Greeter = await ethers.getContractFactory("Greeter");
    const GreeterV2 = await ethers.getContractFactory("GreeterV2");
    const GreeterV3 = await ethers.getContractFactory("GreeterV3");
    greeter = await upgrades.deployProxy(Greeter);
// setting the greet value so that it can be checked after upgrade
    await greeter.setGreeting("WAGMI");
greeterV2 = await upgrades.upgradeProxy(greeter.address, GreeterV2);
    greeterV3 = await upgrades.upgradeProxy(greeter.address, GreeterV3);
  });
it("should retrieve value previously stored and increment correctly", async function () {
    expect(await greeterV2.greet()).to.equal("WAGMI ");
    expect(await greeterV3.counter()).to.equal(BigNumber.from("0"));
    await greeterV2.increment();
    expect(await greeterV3.counter()).to.equal(BigNumber.from("1"));
  });
it("should set name correctly in V3", async function () {
    expect(await greeterV3.name()).to.equal("");
    const name = "Viral";
    await greeterV3.setName(name);
    expect(await greeterV3.name()).to.equal(name);
    expect(await greeterV3.greet()).to.equal(`WAGMI ${name}`);
  });
});

Note 1 — Since all the data and state is stored in Proxy contract you can see in the test cases that we are calling increment() method in GreeterV2 and checking if the value is incremented or not in GreeterV3.

Note 2 — Since in our GreeterV3.sol the contract, we have added space and name to the greeting If the name is null, then the greet the call will return the greeting with an extra space appended to it.

Run the tests —

yarn hardhat test test/4.GreeterV3Proxy.test.ts

Results —

Greeter (proxy) V3 with name
    ✔ should retrieve value previously stored and increment correctly
    ✔ should set name correctly in V3
2 passing (675ms)
✨  Done in 2.38s.

Deployment script for GreeterV3.sol

Create a file called GreeterV3.deploy.ts in scripts and paste the following code —

// scripts/3.upgradeV3.ts
import { ethers, upgrades } from "hardhat";
const proxyAddress = "0x4ed7c70F96B99c776995fB64377f0d4aB3B0e1C1";
async function main() {
  console.log(proxyAddress, " original Greeter(proxy) address");
  const GreeterV3 = await ethers.getContractFactory("GreeterV3");
  console.log("upgrade to GreeterV3...");
  const greeterV3 = await upgrades.upgradeProxy(proxyAddress, GreeterV3);
  console.log(greeterV3.address, " GreeterV3 address(should be the same)");
console.log(
    await upgrades.erc1967.getImplementationAddress(greeterV3.address),
    " getImplementationAddress"
  );
  console.log(
    await upgrades.erc1967.getAdminAddress(greeterV3.address),
    " getAdminAddress"
  );
}
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Deploy the GreeterV3

yarn hardhat run scripts/GreeterV3.deploy.ts --network localhost

Note — If you get “Error: Proxy admin is not the one registered in the network manifest” when you try to deploy GreeterV3, you need to run Greeter.deploy.ts and GreeterV2.deploy.ts again and copy the new proxy address to be used to deploy the upgraded contracts.

Results —

0x4ed7c70F96B99c776995fB64377f0d4aB3B0e1C1  original Greeter(proxy) address
upgrade to GreeterV3...
0x4ed7c70F96B99c776995fB64377f0d4aB3B0e1C1  GreeterV3 address(should be the same)
0x3Aa5ebB10DC797CAC828524e59A333d0A371443c  getImplementationAddress
0x59b670e9fA9D0A427751Af201D676719a970857b  getAdminAddress
✨  Done in 2.63s.

Deploying the upgraded contract manually

Let’s write a new contract — GreeterV4 where we need to —

Change the state variable name from public to private.
Add getName method to fetch name value.

Create a file called GreeterV4.sol in contracts directory and add the following code —

// contracts/GreeterV4.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./GreeterV2.sol";
contract GreeterV4 is GreeterV2 {
    string private name;
event NameChanged(string name);
function setName(string memory _name) public {
        name = _name;
    }
function getName() public view returns (string memory) {
        return name;
    }
}

Here we need to inherit from GreeterV2 instead of GreeterV3 because GreeterV3 already has a state variable called name and we cannot change the visibility but what we can do is inherit from GreeterV3 which does not have name variable and set the visibility as we want.

Let’s write test cases for GreeterV4.sol.

// test/5.GreeterV4Proxy.test.ts
/* eslint-disable no-unused-vars */
import { expect } from "chai";
import { Contract } from "ethers";
import { ethers, upgrades } from "hardhat";
describe("Greeter (proxy) V4 with getName", function () {
  let greeter: Contract;
  let greeterV2: Contract;
  let greeterV3: Contract;
  let greeterV4: Contract;
beforeEach(async function () {
    const Greeter = await ethers.getContractFactory("Greeter");
    const GreeterV2 = await ethers.getContractFactory("GreeterV2");
    const GreeterV3 = await ethers.getContractFactory("GreeterV3");
    const GreeterV4 = await ethers.getContractFactory("GreeterV4");
greeter = await upgrades.deployProxy(Greeter);
    greeterV2 = await upgrades.upgradeProxy(greeter.address, GreeterV2);
    greeterV3 = await upgrades.upgradeProxy(greeter.address, GreeterV3);
    greeterV4 = await upgrades.upgradeProxy(greeter.address, GreeterV4);
  });
it("should setName and getName correctly in V4", async function () {
    expect(await greeterV4.getName()).to.equal("");
const greetername = "Celo";
    await greeterV4.setName(greetername);
    expect(await greeterV4.getName()).to.equal(greetername);
  });
});

Run the test —

yarn hardhat test test/5.GreeterV4Proxy.test.ts

Results —

Greeter (proxy) V4 with getName
    ✔ should setName and getName correctly in V4
1 passing (608ms)
✨  Done in 6.18s.

Preparing for the upgrade, but not really upgrading

When we call upgrades.upgradeProxy() there are a couple of things happening —

Your contract is deployed first,
ProxyAdmin called the upgrade() method and link the proxy to the newly implemented contract’s address.

To do these steps manually, we can call upgrades.prepareUpgrade() which only deploys your contract but does not link it with the proxy YET. This is left for the developers to link manually. This is useful when you want to test in production before wanting all the users to use the new contract.

Create a file called GreeterV4Prepare.deploy.ts in scripts directory and add the following code —

import { ethers, upgrades } from "hardhat";
const proxyAddress = "0xc5a5C42992dECbae36851359345FE25997F5C42d";
async function main() {
  console.log(proxyAddress, " original Greeter(proxy) address");
  const GreeterV4 = await ethers.getContractFactory("GreeterV4");
  console.log("Preparing upgrade to GreeterV4...");
  const greeterV4Address = await upgrades.prepareUpgrade(
    proxyAddress,
    GreeterV4
  );
  console.log(greeterV4Address, " GreeterV4 implementation contract address");
}
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Note — You might want to run all the deployment scripts again if you face any issues while running this script.

Run the script —

yarn hardhat run scripts/GreeterV4Prepare.deploy.ts --network localhost

Results —

0xc5a5C42992dECbae36851359345FE25997F5C42d  original Greeter(proxy) address
Preparing upgrade to GreeterV4...
0x9E545E3C0baAB3E08CdfD552C960A1050f373042  GreeterV4 implementation contract address
✨  Done in 2.56s.

Deploying all the contracts to Celo’s Alfajores Network

First, we need to add Alfajores RPC details in hardhat.config.ts. Refer to this site for the latest RPC details — https://docs.celo.org/getting-started/wallets/using-metamask-with-celo/manual-setup

alfajores: {
      url: "https://alfajores-forno.celo-testnet.org",
      accounts:
        process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],
    },

Run the script and deploy Greeter.sol.

For your reference, here are the three deployed contracts —

0xeE5Dc1234Cdb585F54cc51ec08d67f6f43d0183B — Implementation Contract
0xc2E6c44e9eA569C6D1EfF7Ce0229Fb86a4A1d2d1 — ProxyAdmin Contract
0xd15100A570158b7EEbE196405D8a456d56807F2d — Proxy Contract

Upgrade Greeter to GreeterV2

Run the following command to deploy the GreeterV2. Make sure before running update the proxyAddress in GreeterV2.deploy.ts with your deployed proxy contract address.

yarn hardhat run scripts/GreeterV2.deploy.ts --network alfajores

Since we called upgrades.upgradeProxy in the deploy script, it did two things, deployed the new implementation contact and called proxyAdmin.upgrade() the method to link proxy and new implementation contract.

Upgrading GreeterV2 to GreeterV3.

Run the following command —

yarn hardhat run scripts/GreeterV3.deploy.ts --network alfajores

Upgrading GreeterV3 to GreeterV4.

In GreeterV4Prepare.deploy.ts we had only called prepareUpgrade which only deploys the implementation contract. We will use a hardhat console to manually call update() the method to link the proxy with the implementation contract. Run the following command to deploy the implementation contract.

yarn hardhat run scripts/GreeterV4Prepare.deploy.ts --network alfajores

Results —

0xd15100A570158b7EEbE196405D8a456d56807F2d  original Greeter(proxy) address
Preparing upgrade to GreeterV4...
0x8843F73D7c761D29649d4AC15Ee9501de12981c3  GreeterV4 implementation contract address
✨  Done in 5.81s.

We will use a hardhat console to link the proxy with the implementation contract. Run the following command to start the console.

yarn hardhat console --network alfajores

For linking, we need two things —

ProxyAdmin address
GreeterV4 contract factory instance

Run the following commands in the console —

> const GreeterV4 = await ethers.getContractFactory("GreeterV4");
> await upgrades.upgradeProxy("0xd15100A570158b7EEbE196405D8a456d56807F2d", GreeterV4);

This will point the proxy contract to the latest GreeterV4.

Conclusion

Congratulations 💪 on making it to the end. I know this article is a bit long, but now you know how upgradeable smart contracts work under the hood. You have built and deployed proxy contracts in the local testnet and Alfajores testnet. If you have doubts or just fancy saying Hi 👋🏻, you can reach out to me on Twitter or Discord[0xViral (Celo)#6692].

Polygon explained without jargon

Viral Sangani — Thu, 30 Sep 2021 00:13:44 +0000

Introduction

We will learn what Polygon (aka Matic) is, what it does, how it does it, and what makes it a better alternative to Etherium. In short, I will try to explain the Polygon blockchain without any jargon in the most straightforward manner possible.

Before understanding Polygon, it's essential to understand Ethereum and the problems we are facing with Ethereum.

An intro to Ethereum

In simplest terms, Ethereum is a system that enforces property rights. Ethereum introduced an axiom - Code is Law. This idea is to create a law that can be translated into a simple mathematical equation - If X, then Y. For example - If you break traffic rules, you pay Y amount of fine. If you give X amount of collateral, you can borrow Y amount of money. These examples are real-world scenarios, and Ethereum provides us a way to enforce these rules on the internet with a feature called Smart Contracts. Smart contracts essentially are Ethereums way of implementing If X, then Y law. These contracts are a piece of code that will automatically execute when a specific condition meets.

Problems with Ethereum

Ethereum was founded in 2013, and since then, it has attracted an enormous number of developers and investors. As we all know, with great attention comes significant responsibilities. As of writing this, 361 Billion dollars are locked in Ethereum, and around 1.2 Million transactions are happing in 1 day. Because of this much amount of traffic, the Ethereum network is getting congested. As more and more people onboard Ethereum and start using it, the Ethereum network gets slow, due to which the cost of using the network is increasing. Due to congestion on the network, the cost of a single transaction on Ethereum was around $100 in early 2021. Ethereum can solve these issues but at the expense of security.

Polygon is trying to solve all these problems and retaining the high security of Ethereum.

What is Polygon

Polygon is a solution to all Ethereum problems. Polygon blockchain is connected to Ethereum blockchain and is taking heavy work off Ethereum. Think of Ethereum as National Highway and Polygon as service roads or connecting roads that lead to different cities and states. Many people live in cities, and they cause a lot of traffic on the road; city roads can handle this traffic, and once the traffic gets cleared, people can quickly join the main Highway using connecting roads.

There is no need for Ethereum to handle so many transactions; if some other blockchain(Polygon) can handle those transactions, bundle them up, and update those transactions on Ethereum, then Ethereum would have less congestion and work more efficiently.

The Polygon Analogy

Assume Ethereum is a metropolitan city, like New York, and Polygon is the suburbs of New York City. Suburbs has their own things going on. They have their restaurants, buildings, markets, malls, and police, and people can constantly communicate with the city. Certainly, suburbs are not as secure as cities, but it's easy to communicate within suburbs, and suburbs are comparatively cheaper than cities. Suburbs have their government authorities and their security forces moreover can interact with the city for more security.

Similarly, Polygon has its own token, its own smart contracts, its own governance, and its own security and can communicate with Ethereum and rely on its security as well.

Since Polygon is running parallelly with Ethereum, its also referred to as a side chain. Considering that Polygon is connected with Ethereum, all the transactions on Polygon will eventually be written on to Etherum. With Polygon, developers can create decentralized applications without worrying about transaction fees.

All in all, Polygon did resolve most of the issues that Ethereum currently has. Considering that only 65% of the earth's population has access to the internet and Web3 is still adopting, Polygon has a lot of room to grow in the future.

Getting started with weird parts of VIM

Viral Sangani — Thu, 02 Jul 2020 08:04:28 +0000

This post was originally posted on - https://blog.viralsangani.me/posts/getting-started-with-weird-parts-of-vim/
You can read more blogs at - https://blog.viralsangani.me/

If you are new to VIM, you might want to read my previous post on VIM. This is the 2nd part of the five-part series on VIM.

A Taste of VIM Editor

Those who are not a regular VIM user, they might use some normal text editor like, VSCode, Atom, Sublime, etc.. (unless you are some freak using emacs), and the main aim of those normal text editor is to insert the text, and that's what they are made for. I don't know about others but 75% of my time while coding and programming I tend to edit the code rather than inserting the code. That's what most developers do, they write the code once, then they spend most of the time editing and customizing that code. Now, when it comes to VIM, VIM is not like other text editors whose main aim is to insert the code, rather VIM focuses more on the editing part. With vim, you can edit the code like a wizard.
For example, let's say you want to make similar changes in 15 lines of a file. If you are using a normal text edit, you scroll the mouse, find each line, and make the change. But with VIM, you make the change in one line, and VIM remembers it, then all you have to do is press . (period), and VIM repeats its last set on command and BAMM, you get the changes in another line with just a keystroke. But it's hard to write commands which work well with . but you can learn it with some practice.

Let's starts with some basics and build our way up.

First thing first, if you are stuck anywhere in VIM, just call for : help and help will come for rescue. VIM's : help command is very well documented. Get help with :help {whatever} or with a shorter version :h {whatever}.

-> With vim, you don't have to move your hand to arrow keys to move around a file, you can simply use, letters hjkl. When you type on a keyboard, your hand rests firmly on these keys, hence it's a faster way to move around a file.
These keys move the cursor left, down, up, and right respectively.

You can also move left to right by words with w (goto starting of the word) or e (goto end of the word). you can use b to do the same but in right to left direction.

In the world of VIM, with great keys comes great power. In normal mode, just type daw and you just deleted a word, press das and you deleted a sentence, press dap and you just deleted a whole paragraph with 3 keystrokes.

Or you can be less of a devil who deletes stuff and can use caw, cas, or cap to change a word, sentence, or a paragraph. It's not the end, you can type ctb to change until first b in the current line, or use c$ to change everything till the end of the line. You can use ci{ to change the text between curly brackets or use ci" to change content between quotes.

Let's see an example, imagine you have a variable in python,

x = "Hello World"
y = "How you doing?"

Now, you can change the text between those quotes with f"ci"WHAT<ESC>. By typing this you'll get this,

x = "WHAT"
y = "How you doing?"

Now, VIM remembers your last command, so if you press j., you'll get,

x = "WHAT"
y = "WHAT"

Let's break down these commands, in 1st one f" finds the ", then ci" change the content between those quotes and put you in insert mode, with WHAT<ESC>, it inserts the WHAT word and <ESC> put you back in normal mode.

In 2nd command, j put your cursor down one line, and . repeats your last command, which was to change content between quotes and insert WHAT in between.

With VIM you can copy the content in the same way, but in VIM copy is called yank. It's just a jargon VIM people use.
So now, just like delete use d, change use c, you can use y to yank the content. To yank a word press yaw, to yank a sentence press yas and to yank a paragraph press yap.

To make it simple you can press dd to delete your present line, press cc to change current line, and press yy to yank your current line.

With the power of these commands, you can do a lot more, like the previous example, you can press kJ, and you'll get this

x = "WHAT" y = "WHAT"

and now press c3w+<ESC>, you'll get something like this,

x = "WHAT"+"WHAT"

This is not at all useful examples, but hey you get the idea of what you can do in VIM.
In the previous example, I have used count {3} to get the longer motion. For example, if you want to go 13 lines up, press 13k. It follows a syntax {count}{command}, which means you can add the count to any command, even to . which is a repeater command, so if you press 10., it will run the last command 10 times.

One thing you will miss most in VIM is the freedom to navigate freely with a mouse scroll. You don't want to be that person who presses j 30 times to reach the desired line. But hey, VIM has way around for that too, press D to move a few lines down at a time and press U to move a few lines up, that ease up the pain of pressing the same key multiple times. You can even you { and } for a paragraph up or down respectively. If you are coding you can use % to find the matching ending parentheses.

You can enter insert mode by pressing i, if you want to insert in the new line, press o, and if you want new above the current line press O.

My favorite command id /, you can use /{patter}, to move to any place in the document you want. Once you find your matching patter, press n to find the next matching pattern.

So much at your fingertip, and you have barely left normal mode. There is much much more like there are splits, there's a regex, there are tabs, there's is access to hundreds of community-based extensions for VIM, there is spell checking, word count, file tree, everything coming in next posts. So excited?

One last thing, you might be thinking, how can someone remember so many commands there is caw there is ciw, 10j, dd d3w, etc.. See that's the beauty of VIM, you don't have to remember it. The operators and command make incredible sense. VIM use mnemonics like c means change, d means delete, cl means change letter, daw means delete a word, ciw means change inner word. cta means change till you find a and so on.

VIM is like programming I guess, where you are in control, and change the core mechanism of file editing and writing text. If you are familiar with git and how it works with source control of your project, you can think of VIM as a git of text editing. Once you have experience with VIM, you will no longer see the text as normal text, you will see the text as an infinite number of possibilities to change that text being applied just like Neo awakening to the matrix. (Got that ref?? let me know in the comment...)

To learn more about vim, you can watch this really awesome talk by Chris Toomey. In the talk, he explained how to think in VIM language and do all those crazy stuff more efficiently.

I just wanted to end with a Joke. 😇

VIM is tough, or is it???

Viral Sangani — Tue, 09 Jun 2020 17:08:09 +0000

This post was originally posted on - https://blog.viralsangani.me/posts/vim-is-tough-or-is-it/
You can read more blogs at - https://blog.viralsangani.me/

In the past, I am stuck with this idea of making more with less, in the context of refactoring the line of code in the most efficient way possible. Recently I am exploring the use of VIM to unleash unlimited power of a text editor. VIM enables me to achieve more with every keystroke and with every hour I invest in programming.

This is the 1st part of the five-part series on VIM.

Let's talk about VIM.

VIM is a text editor who has a keyboard-centric design, unlike other text editors. VIM promises ultimate productivity to those who dare to face its steep learning curve and survive till the end to tell the tale.

I have been learning VIM for the past 2 months. To be honest, it was tough for the first week, but if you make it through the first week, trust me it's worth it. My first encounter with VIM was a year ago, when I saw my brother typing a bunch of command in vim to do some editing in one line and then he played the recorded command 100 times, and BOOM, 100 lines of code were changed with just a keystroke. That was fascinating. Since then I tried to use VIM as my primary text editor, but just because of the steep learning curve, I always gave up. But a couple of months ago, I came up with this YouTube playlist by ThoughtBot. When I suggest someone to use VIM, their first question is CAN IT DO THIS.... And the answer is YES. Just go through this playlist and all your questions will be answered.

Till this time, I haven't used 50% of the functionalities VIM offers, or that know about. However, I never completely shifted to VIM, instead, I use VIM extension for popular text editors like VSCode or PyCharm, etc. This will give you the flavor of both. You have you VSCode shortcuts + the power of VIM at your fingertip. Although using VIM with other text editors is not as good as the real thing, but for beginners, this is the best bet to get used to VIM quickly.

Answering, what is VIM?

VI is the ancient text editor created in 1976. The main purpose of creating VI is to make a text editor that works perfectly on a terminal. Later came the VIM(Vi IMproved) which has support for both text and graphical interfaces. It comes as the improved version of VI which technically supports all the operating systems known to mankind.

Why VIM but?

You might be thinking why should I care about some ancient text editor in 2020? VIM is a text editor that provides a different method of writing code. If text editors are compared to planets, VS Code, Sublime, ATOM, Jetbrains, Eclipse all are on the same planet and VIM is a different galaxy. It provides a way to interact with your code as no other editors can.

Now you might be thinking, what is there for me in learning VIM? See, VIM removes the dependency of MOUSE. Yes no more using a mouse, if you choose to go with VIM. Using VIM will make you a code surgeon. A code surgeon who can make precise code insertion whenever and wherever they want. If you are using one of those text editors other than VIM, you will be using a mouse to navigate in the code. But with VIM you can navigate into your code and codebase with lightning speed just using your keyboard. You don't even have to move your hand from keyboard to mouse. This is what you get from learning VIM, the speed, and the power of changing whatever you want with just a couple of keystrokes.

What makes VIM such a great text editor?

There are this things called modes in VIM. There are primarily three modes in VIM, Normal Mode, Inset Mode, and Visual Mode. Each mode has it's own significance we will see in further posts. All the keystroke have different functionalities in every mode. For example, d key is used to delete and copy the text in Normal mode, were as if you are in Inset mode, d is just the letter d, which will be typed if you press d key. This helps VIM to provide more functionalities with limited numbers of keys.

VIM is extremely customizable. You can change your key binding However it suites you, and whatever works for you. There are no restrictions like many text editors where you can't help it. If you want to copy the selected text by just pressing c, instead of pressing two keys =>Ctrl+z, you can in vim, but it might be too hard or not possible in other text editors.

Why VIM is hard?

Let's goto a darker side of VIM, or at least what some people think.

Let's see the learning curve of VIM.

Yes, VIM is consistently hard to learn, because learning never ends in VIM. Every day you google something about VIM, and you'll get some exciting new stuff related to VIM and it's plugins.

And then comes this,

But according to me, what makes VIM sooooo HARD is it's Horrible first impression.

So in the next few posts, I will try to make leaning VIM not that difficult and providing you basics and resources to learn advanced VIM.

Just a friendly advice, if you take the courage of learning VIM, don't stop in between, I know it will be painful at the start, but trust me there will come a day when you will be saving hours in a day just by using VIM.

Be anonymous, create your own proxy server with AWS EC2

Viral Sangani — Tue, 09 Jun 2020 04:19:46 +0000

This post was originally posted on https://blog.viralsangani.me.
Checkout this post at - https://blog.viralsangani.me/posts/be-anonymous-create-your-own-proxy-server-with-aws-ec2/

We are living in 2020, and both users and internet applications can take the benefit of cybersecurity. One of the best ways to be secure while browsing the Internet is by using proxy servers. The proxy server is an important thing to know about nowadays. Let's see what makes proxy servers an essential aspect of cybersecurity support.

Thanks to traking cookies, browser fingerprinting and Internet Service Providers (ISPs) selling our browsing logs to advertisers, online anonymity is out like COVID 19 virus, everybody knows about it, but few are doing something about it. While your next-door-neighbour might not know where to find you online, but there is at least one large corporation (you know whom I am indicating G..... 😅), which has a series of 0's and 1's stored in their database

which represents you, specific details of what you buy, what you like, what you don't, including your favourite ice cream flavour.

There are few ways to stop this, like using a corporate firewall, using Tor, or maybe a VPN. But in this blog, we'll see a free and effective way to stay secure online.
What's a proxy server, anyway?

A proxy, in the English definition, is the "authority or power to act for another." A proxy server, in the computing context, is a server that acts on behalf of another server, or a user's machine.

By using a proxy to browse the Internet all of the user's Internet traffic appears to come from the proxy server instead of their machine. To set up a free high-speed proxy server all you need is a free tier AWS account.

Follow the steps below to create a proxy server.

Step 1: Go to the AWS console and select EC2 from the services.

Step 2: Select Instances from the left panel and then click in Launch instance.

Step 3: From the list, select Ubuntu Server 18.04 LTS, and click in next.

Step 4: Click on continue and keep default configuration until you reach the Security Group configuration. Create a new security group, add a security group name and a small description. Then add a new rule, set Type to Custom TCP, and set Port Range to 8888. In source, choose My IP from the dropdown. Click on Review and launch.

Make sure to create new SSH keys and download it from the popup after clicking on Review and launch.

Step 5: Once your instance is created, click on the Connect button, and copy the ssh command as shown in the image below.

Step 6: Open a terminal, and run this the following command. If you are on the windows machine, I highly suggest you use Putty for connecting to the EC2 server.



# Goto the directory where the key is download.

chmod 400 proxy-server.pem

# Paste the code copied from AWS.

ssh -i "proxy-server.pem" @ec2-12-345-678-90.ap-south-1.compute.amazonaws.com

Now, you'll get a shell in the AWS EC2 server.

Step 7:



sudo apt update && sudo apt upgrade

sudo apt install tinyproxy

This will get you all the dependency needed. We will use TinyProxy to setup our Ubuntu Server as the Proxy. By default, TinyProxy operates on Port 8888. Now we need to modify the configuration file of TinyProxy to allow the only IP address of your machines.

Step 8: For this step, you should be familiar with the VIM text editor. If you are not, I'll soon write a detailed blog for VIM too.



sudo vim /etc/tinyproxy/tinyproxy.conf

Look for Allow 127.0.0.1 line and add your public IP, as shown below.

To know your IP, run this in a new terminal.



curl ifconfig.co

You will get your public IP there.

Step 9: The final step is to restart the tinyproxy to reflect the changes we made.



sudo /etc/init.d/tinyproxy restart

How to use this Proxy?

To browse the Internet via this Proxy, we need to set up our browser to use this Proxy.

In the firefox browser goto preferences from right top corner options, and search for Proxy. Choose manual proxy configuration, and in HTTP proxy add your AWS EC2 public IP(you can get the public IP from AWS EC2 dashboard), in Port add 8888. Make sure to check the Also use this Proxy for FTP and HTTPS checkbox. Click, OK, and you are good to go.

To verify go to Google, and search what is my IP. You will see your AWS EC2 IP, that means all your data is routed via AWS servers.
This means there is no more restriction on which site you can access. All sites are unlocked for you😁. Enjoy!