Forem: Venkatesh R

All About EVM Instructions And Opcodes:

Venkatesh R — Sun, 06 Nov 2022 10:29:55 +0000

EVM Instructions and Opcodes:

Do you want to gain a deep understanding about EVM Instructions and Opcodes? Or Do you want to become Senior Smart Contract developer?

Well, good news! you're in the right place.

What is EVM ?

The Ethereum Virtual Machine or EVM is a piece of software that executes smart contracts and computes the state of the Ethereum network after each new block is added to the chain

What is Assembly ?

Assembly refers to any low-level programming language that is converted to machine code using an assembler. Assembler languages are tied to either a physical or a virtual machine, because they implement its instruction set. An instruction tells simply the CPU to do some fundamental task, such as adding two numbers, etc.

Yul language is being used as low level Assembly Language for the Ethereum.

Getting Started:

EVM is a stack based virtual machine which uses few instruction set to perform its fundamental tasks.

EVM instruction sets:

Stack Instruction Set
Arthmetic Instruction Set
Comparision Instruction Set
Memory Instruction Set
Storage / Context Instruction Set

Stack Instruction Set:

Stack Instruction is being used to push / pop the one or more values into the stack to perform its fundamental tasks.

Stack Instructions:

PUSHN - pushes a value into the top of the stack where N is the byte size of value Example: PUSH1, PUSH2, PUSH3, etc.
POP - pops out a value from the top of the stack
SWAPN - swaps a value from the top of the stack at the index N
DUPN - duplicate the value from the stack at the position N and push the duplicated value to the top of the stack.

There are many instructions available on the Stack Instruction Set.

Example:

PUSH1 0x01 // pushes 1 [1]
PUSH1 0x02 // pushes 2 [2, 1]
PUSH1 0x02 // pushes 2 [2, 2, 1]

POP // pops out the value 2 [2, 1]

DUP1 // duplicates the value 2 and push the value [2, 2, 1]

Arthmetic Instruction Set:

Arthmetic Instruction takes two / more values from the top of the stack and performs arthmetic operation and push the resultant value into the top of the stack

Arthmetic Instructions:

ADD - Add two values from the top of the stack and pushes to the stack.
SUB - Subtract two values from the top of the stack and pushes to the stack.
DIV - Divide two values from the top of the stack and pushes to the stack.
MUL - Multiplies two values from the top of the stack and pushes to the stack.

There are many instructions available on the Arthmetic Instruction Set.

Example:

PUSH1 0x01 // pushes 1 [1]
PUSH1 0x02 // pushes 2 [2, 1]

ADD // Adds two values from top of the stack [3]

PUSH1 0x01 // pushes 1 [1, 3]

SUB // Subtract the two value [2]

Comparision Instruction Set:

Comparision Instruction takes two / more values from the top of the stack and performs comparision operation and push the resultant value into the top of the stack

Comparision Instructions:

LT - Compares the top value from stack with second top value and pushes the result into the top of the stack.
GT - Compares the top value from stack with second top value and pushes the result into the top of the stack.
EQ - Pushes true if the top two values are equal
ISZERO - Pushes true if the top value of the stack is 0

There are many instructions available on the Comparision Instruction Set.

Example:

// false = 0 and true = 1

PUSH1 0x01 // pushes 1 [1]
PUSH1 0x01 // pushes 2 [1, 1]

EQ // stores the result [1] / [true]

ISZERO // stores the result [0] / [false]

POP // pops out the values []

Memory Instruction Set:

Memory Instruction are used to read and write the chunks of values into the memory.

Memory Instructions

MSTORE - writes a value into the memory
MLOAD - reads a value from the memory

Example:

PUSH1 0x01 // pushes 1 [1]
PUSH1 0x00 // pushes 0 [0, 1]

// Stores the value 1 into the memory slot zero

MSTORE 

PUSH1 0x00 // pushes 0 [0]

// Loads the value from the memory at slot zero

MLOAD // [O]

Context Instruction Set:

Context Instruction are used to read and write the data from the global state / execution context.

Context Instructions (READ):

SLOAD - Loads the values from the storage with respect to the pointer value
CALLER - Loads the caller of the contract context
TIMESTAMP - Loads the current block's timestamp

There are many instructions available on the Context Instruction Set (READ).

Context Instructions (WRITE):

SSTORE - Stores the values into the storage with respect to the pointer
CALL - Used to make a call to external contract and update the global state
CREATE - Used to deploy the contract in the blockchain state
LOGN - Used to log the contract's execution data, where N is the number of indexed Topics.

There are many instructions available on the Context Instruction Set (WRITE).

Example:

CALLER // pushes contract caller [caller_address]
PUSH1 0x00 // pushes 0 [0, caller_address]

// Loads the caller_address into the first storage slot

SSTORE // []

PUSH1 0x00 // pushes 0 [0]

// Loads the caller_address from the first storage slot

SLOAD // [caller_address]

Conslusion:

It is very important for the smart contract developers and auditors to undertand that how solidity based smart contracts/EVM executes its fundamental tasks behind the scenes to get deep foundation of EVM. To know more about the other EVM opcodes, please visit Here and if you want to play with these opcodes in the real time playground, please visit EVM codes playground website .

Hope you guys have learnt something new today, do follow me to get more exiting contents on #blockchain #Web3 #SmartContracts #Solidity #Rust #Solana

You can reach out to me via LinkedIn, Github

Mainnet Forking and Crypto Wallet Impersonation:

Venkatesh R — Sat, 22 Oct 2022 11:05:20 +0000

Mainnet Forking and Wallet Impersonation:

Do you want to fork the Mainnet Blockchain into your local development network? Or Do you want to simulate mainnet blockchain and build your own Defi projects? Or Do you want to become a Senior Web3 Developer by learning complex blockchain concepts?

Well, good news! you're in the right place.

Mainnet Forking:

Mainnet Forking means we simulate mainnet blockchain to have the same state as mainnet, but it will work as a local development network. You can simulate the Ethereum blockchain into your local network and build your next Defi project.

Wallet Impersonation:

Wallet Impersonation is a process of unlocking an access to any wallet which exists in the blockchain network by wallet address. This lets you send transactions from that account even if you don't have access to its private key.

Benefits:

Benefits of forking the mainnet and wallet impersonation are

Write real-time unit tests for your smart contracts
Build your own Defi smart contracts based on other complex protocols such as Uniswap, Compound, Curve, etc.
Learn and get comfortable with your own cryptocurrency arbitrage strategies by mocking the Mainnet protocols
Test your new protocols against your previously deployed smart contracts.

Getting Started:

Before starting you need to setup your Hardhat Smart contract development environment. Please refer to this hardhat docs

How to fork the blockchain network:

To fork the mainnet blockchain you need a RPC node provider.

You can use these RPC providers such as

Infura - Follow this docs to get a RPC endpoint forking the Mainnet
Alchemy - Follow this docs to get a RPC endpoint forking the Mainnet

After completing the RPC endpoint setup process, you need to goto your Hardhat development environment and check for the Hardhat config file.

Inside the hardhat.config.js file, paste your RPC endpoint to setup the mainnet forking.

require("@nomicfoundation/hardhat-toolbox");

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.7.6",
  networks: {
    hardhat: {
      forking: {
        url: "https://eth-mainnet.g.alchemy.com/v2/<API_KEY>"
      }
    }
  }
};

Tada! From now whenever you start your hardhat local network / run your unit tests, hardhat environement will automatically fork the mainnet into your local network.

Wallet Impersonation:

We can use the hardhat built-in features to impersonate any wallet account in the mainnet blockchain using the address.

Use this code snippet to impersonate any wallet

await network.provider.request({
   method: "hardhat_impersonateAccount",
   params: [WALLET_ADDRESS],
});

Example:

Do you want to impersonate and gain access to one of the top bitcoin holder's wallet and transfer all the bitcoin to your own wallet in your local network?

Steps:

Go to etherscan and pick your favourite account which you want to impersonate. Let's say we impersonate the bitcoin holder's wallet,
Goto WBTC contract in etherscan, navigate to holders tab and pick one of the account from there

WBTC Address: 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599
WBTC Whale Address: 0x28c6c06298d514db089934071355e5743bf21d60

Since bitcoin is a cryptocurrency of different blockchain, so we use a Wrapped BTC (ERC20 token) to represent the bitcoin in Ethereum blockchain

Use the impersonate built in feature provided by hardhat to unlock the account.
Get the access to the whale's wallet account in your local network by getting the signer.

await network.provider.request({
   method: "hardhat_impersonateAccount",
   params: [WBTC_WHALE],
});

const whaleAccount = await ethers.getSigner(WBTC_WHALE);

You can transfer the WBTC from whale's wallet account to your account with the help of ERC20 utility methods

const whaleWalletBalance = await wbtc.balanceOf(whaleAccount.address);

await wbtc.connect(whaleAccount).transfer(yourWallet.address, whaleWalletBalance);

const yourWalletBalance = await wbtc.balanceOf(yourWallet.address);

Full Sample Code Snippet:

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

const WBTC_WHALE = "0x28c6c06298d514db089934071355e5743bf21d60";
const WBTC_TOKEN = "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599";


describe("Wallet Impersonation code snippet", () => {
   let wbtc;
   let accounts;

   before(async ()=> {
      accounts = await ethers.getSigners();
      wbtc = await ethers.getContractAt('IERC20', WBTC_TOKEN);
   })  

   it("Impersonate any wallet", async () => {
      const userAccount = accounts[0];

      await network.provider.request({
         method: "hardhat_impersonateAccount",
         params: [WBTC_WHALE],
      });

      const whaleAccount = await ethers.getSigner(WBTC_WHALE);

      const whaleTokenBalance = await wbtc.balanceOf(whaleAccount.address);
      await wbtc.connect(whaleAccount).transfer(userAccount.address, whaleTokenBalance);

      const userTokenBalance = await wbtc.balanceOf(userAccount.address);
        console.log("User Token Balance", userTokenBalance);
   })
})

Hope you guys have learnt something new today, do follow me to get more exiting contents on #blockchain #Web3 #SmartContracts #Solidity #Rust #Solana

You can reach out to me via LinkedIn, Github

Upgradable Proxy Contracts 101 (Advanced)

Venkatesh R — Sun, 16 Oct 2022 11:37:50 +0000

Upgradable Proxy Contract Advanced Concepts:

Do you want to learn how proxy upgradable contracts work? Or Do you want to create your own proxy contract? Or Do you want to become a Senior Blockchain Developer by learning complex concepts?

Well, good news! you're in the right place.

If you are already familiar with proxy upgradable contracts and want to know more about its internal concepts ? Directly jump to the Getting Started section.

What is Upgradable Proxy Contracts ?

In the software development industry, software quality and stability heavily depend on software enhancements or bug fixes on the time to time basis. Since smart contracts are immutable in nature, we need advanced techniques to make our smart contracts upgradable while maintaining considerable immutability.

Proxy Upgradable Contract is a advanced technique which is being used for updating the existing smart contract in the event of bug fixes, new features, update the existing business logic etc..

Getting Started:

To upgrade the smart contract, we need to have a sample smart contract to get started with it. We got you covered, use the Counter contract.

contract CounterV1 {
    uint public count;

    function inc() external {
        count += 1;
    }
}

Upgradable proxy contract technique/approach is achieved with the help of
1. Proxy Contract
2. Storage Layout Library Contract
3. Proxy Admin Contract

1. Proxy Contract:

Proxy contract is contract which is responsible for communicating with the implementation contract, maintaining storage layout and contract's state.

Proxy contract will communicate with the implementation contract via Delegate Call using the Yul Assembly Language (a low level inline language which will directly interact with EVM) which will execute the contract logic and updates the storage layout of the calling contract.

Delegate Call: delegatecall is a low level function call similar to call. When contract A executes delegatecall to contract B, B's code is executed with contract A's storage

contract Proxy {
    address public admin;
    address public implementation;

    constructor() {
        admin = msg.sender;
    }

    modifier ifAdmin() {
        if (msg.sender == admin) {
            _;
        } else {
            _fallback();
        }
    }

    function upgradeTo(address _implementation) external ifAdmin {
        implementation = _implementation;
    }

    function _delegate(address _implementation) internal virtual {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.

            // calldatacopy(t, f, s) - copy s bytes from calldata at position f to mem at position t
            // calldatasize() - size of call data in bytes
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.

            // delegatecall(g, a, in, insize, out, outsize) -
            // - call contract at address a
            // - with input mem[in…(in+insize))
            // - providing g gas
            // - and output area mem[out…(out+outsize))
            // - returning 0 on error (eg. out of gas) and 1 on success
            let result := delegatecall(gas(), _implementation, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            // returndatacopy(t, f, s) - copy s bytes from returndata at position f to mem at position t
            // returndatasize() - size of the last returndata
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                // revert(p, s) - end execution, revert state changes, return data mem[p…(p+s))
                revert(0, returndatasize())
            }
            default {
                // return(p, s) - end execution, return data mem[p…(p+s))
                return(0, returndatasize())
            }
        }
    }

    function _fallback() private {
        _delegate(_getImplementation());
    }

    fallback() external payable {
        _fallback();
    }

    receive() external payable {
        _fallback();
    }
}

We will always start interacting with the proxy contracts which will perform a delegatecall to implementation contract to execute the contract's logic.

function _delegate() is resposible for performing a delegate call. We will be initiating the contract call with the help of the Function Signature (eg. function inc()) which will be sent as msg.data to the contract via transaction. The receive() / fallback() function will be triggered when the transaction doesn't matches any other function signatures in the proxy contract, which will executes the function _delegate() function.

receive() - The receive function is executed on a call to the contract with empty calldata. This is the function that is executed on plain Ether transfers (e.g. via .send() or .transfer()).

fallback() - If no receive function exists, the fallback function will be called on a plain Ether transfer. If neither a receive Ether nor a payable fallback function is present, the contract cannot receive Ether through regular transactions and throws an exception.

calldatacopy() - It will copy the calldata to the memory address 0 till the size of the calldata

calldatasize() - It is used to determine the size of the calldata in the executing transaction

returndatacopy() - It will copy the return data to the memory address 0 till the size of the result of the function call

returndatasize() - It is used to determine the size of the return data in the executing transaction

2. Storage Layout Library Contract:

Storage layout library contract is used to store and maintain the contract state variables without any collision/conflicts between each other. This is achieved by storing the contract's state variables in the different EVM sotrage slots with the help of Yul assembly language.

library StorageSlot {
    struct AddressSlot {
        address value;
    }

    function getAddressSlot(bytes32 slot)
        internal
        pure
        returns (AddressSlot storage r)
    {
        assembly {
            r.slot := slot
        }
    }
}

EVM consist of a storage slots which can store upto 256 bits of data in it. We are generating a hash based on the function signature which determines the location of the data to be stored in the storage slot.

contract TestProxy {
    bytes32 public constant slot = keccak256("SAMPLE_SLOT");

    function getSlot() external view returns (address) {
        return StorageSlot.getAddressSlot(slot).value;
    }

    function writeSlot(address _addr) external {
        StorageSlot.getAddressSlot(slot).value = _addr;
    }
}

slot - Smart contract values are stored in slots, starting from slot 0 and so on. Elementary fixed-size value types occupy one slot. Moreover, they sometimes can be packed into one slot and unpacked on the fly

3. Proxy Admin Contract:

Proxy Admin Contract is used for managing the proxy contract. Using the Proxy Admin Contract we can look up, change, or upgrade the contract and its ownership such as

Upgrade Implementation Contract
Change Proxy Admin
Lookup proxy admin and implementation contract

contract ProxyAdmin {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }

    function getProxyAdmin(address proxy) external view returns (address) {
        (bool ok, bytes memory res) = proxy.staticcall(
            abi.encodeCall(Proxy.implementation, ())
        );
        require(ok, "call failed");
        return abi.decode(res, (address));
    }

    function getProxyImplementation(address proxy) external view returns (address) {
        (bool ok, bytes memory res) = proxy.staticcall(abi.encodeCall(Proxy.admin, ()));
        require(ok, "call failed");
        return abi.decode(res, (address));
    }

    function changeProxyAdmin(address payable proxy, address admin) external onlyOwner {
        Proxy(proxy).changeAdmin(admin);
    }

    function upgrade(address payable proxy, address implementation) external onlyOwner {
        Proxy(proxy).upgradeTo(implementation);
    }
}

Upgrade The Contract:

To upgrade a smart contract, we need a V2 implementation Counter contract.

contract CounterV2 {
    uint public count;

    function inc() external {
        count += 1;
    }

    function dec() external {
        count -= 1;
    }
}

We can use the above contract to upgrade the existing V1 Counter contract using proxy upgradable technique.

Deploy the V2 contract in the blockchain and use the deployed V2 contract address to upgrade the old version.

To upgrade the V1 Counter contract, we need to trigger the function upgrade() in the Proxy Admin Contract by pointing the proxy contract's address. The Proxy Admin Contract will replace the V1 implementation contract address with the V2 contract address without affecting the contract's state. While upgrading the implementation contract, the address of the proxy contract will never change. Hence the proxy contract will now get a new implementation contract with new features/bug fixes.

Hope you guys have learnt something new today, do follow me to get more exiting contents on #blockchain #Web3 #SmartContracts #Solidity #Rust #Solana

You can reach out to me via LinkedIn, Github