Topics

• Ethereum Smart Contract Storage
• Debugging Ethereum transactions
• try/catch in Solidity
• Custom errors in Solidity

Smart contract Storage

• This is where state variables are stored
• It is persistent between function calls and transactions
• It is a key-value mapping of 2²⁵⁶ keys; each value is 32 bytes long

State Variables Storage Layout

• One Astronomically large array
• Solidity generates code that saves variable values in their declaration order.
• Variable first was declared first, it’s stored in slot 0
• Items that need less than 32 bytes are packed together. See Rules

contract Sample {
	uint first;    // storage slot 0
	uint second;   // storage slot 1
}

Astronomically large array mental model

Fixed-Sized Variables storage layout

contract StorageTest {
    uint256 a;    // slot 0. (location = slot)
    uint256[2] b; // slots 1,2

    struct Entry { 
        uint256 id; // slot 3
        uint256 value; // slot 4
    }
    Entry c; // slots 3,4
}

Dynamic-Sized Variables storage layout

contract StorageTest {
    uint256 a;     // slot 0
    uint256[2] b;  // slots 1-2

    struct Entry {
        uint256 id;
        uint256 value;
    }
    Entry c;       // slots 3-4
    Entry[] d;
}

Dynamic-Sized Variables storage layout

• Computing the location of an element of a dynamically-sized array:

  function arrLocation(uint256 slot, uint256 index, uint256 elementSize) 
  public pure returns (uint256) {
    return uint256(keccak256(slot)) + (index * elementSize);
  }

Mapping storage layout

contract StorageTest {
    uint256 a;     // slot 0
    uint256[2] b;  // slots 1-2

    struct Entry {
        uint256 id;
        uint256 value;
    }
    Entry c;       // slots 3-4
    Entry[] d;     // slot 5 for length, keccak256(5)+ for data

    mapping(uint256 => uint256) e;
    mapping(uint256 => uint256) f;
}

Mapping storage layout

• Computing the location of a value given slot and key:

  function mapLocation(uint256 slot, uint256 key) 
  public pure returns (uint256) {
    return uint256(keccak256(key, slot));
  }

Complex types storage layout

contract StorageTest {
    uint256 a;     // slot 0
    uint256[2] b;  // slots 1-2
    struct Entry {
        uint256 id;
        uint256 value;
    }
    Entry c;       // slots 3-4
    Entry[] d;     // slot 5 for length, keccak256(5)+ for data

    mapping(uint256 => uint256) e;    // slot 6, data at h(k . 6)
    mapping(uint256 => uint256) f;    // slot 7, data at h(k . 7)
    mapping(uint256 => uint256[]) g;  // slot 8
    mapping(uint256 => uint256)[] h;  // slot 9
}

Complex types storage layout

• To find g[123][0] :

  function mapLocation(uint256 slot, uint256 key) 
  public pure returns (uint256) {
    return uint256(keccak256(key, slot));
  }
  function arrLocation(uint256 slot, uint256 index, uint256 elementSize) 
  public pure returns (uint256) {
    return uint256(keccak256(slot)) + (index * elementSize);
  }
  // first find arr = g[123]
  arrLoc = mapLocation(8, 123);  // g is at slot 8
  // then find arr[0]
  itemLoc = arrLocation(arrLoc, 0, 1);

Complex types storage layout

• To find h[2][456] :

  function mapLocation(uint256 slot, uint256 key) 
  public pure returns (uint256) {
    return uint256(keccak256(key, slot));
  }
  function arrLocation(uint256 slot, uint256 index, uint256 elementSize) 
  public pure returns (uint256) {
    return uint256(keccak256(slot)) + (index * elementSize);
  }
  // first find map = h[2]
  mapLoc = arrLocation(9, 2, 1);  // h is at slot 9
  // then find map[456]
  itemLoc = mapLocation(mapLoc, 456);

Packed Storage

Storage Demo

• Sample Contract
• call the delegator.setVersion() with value 0xaabbcc
• check the values of val1,val2,val3,val4
• use storageAt() to get the storage value
• How to read Ethereum contract storage

15 minute break

Lab

Old way to try/catch

function execute(uint256 amount) external {
    // the low level call will return `false` if its execution reverts
    (bool success, bytes memory returnData) = address(this).call(
        abi.encodeWithSignature("onlyEven(uint256)",amount)
    );
    if (success) { /*handle success*/ } 
    else { /*handle exception*/ }
}

function onlyEven(uint256 a) public {
    // Code that can revert
    require(a % 2 == 0, "Ups! Reverting");
    // ...
}

• Changes applied before/after the call are not rolled back here.

try/catch (1)

• Handle external call failures
• React on failed external calls and contract creation.
• Cannot be used for internal function calls
• Call public function with this to make it external.
• Eventual out of gas error is caught by the low-level catch clause.
• out of gas error is not caught if transaction executing code runs out of gas.

try/catch(2)

• following revert inside the try success block will revert the transaction:

  function execute() public {
    try externalContract.someFunction() {
        // this will revert the execution of the transaction
        // even if the external call succeeded
        revert();
    } catch {
       // ...
    }
  }

try/catch(3)

• Constructor calls

  contract TryCatcher {
    // ...
    function execute() public {
        try new CalledContract() returns(CalledContract returnedInstance) {
            // returnedInstance can be used to obtain the 
            // address of the newly deployed contract
            emit SuccessEvent();
        } catch {
            emit CatchEvent();
        }
    }
  }

try/catch(4)

• External calls

  contract CalledContract {    
    function getTwo() public returns (uint256) {
        return 2;
    }
  }
  contract TryCatcher {
    CalledContract public externalContract;
    function execute() public returns (uint256, bool) {
        try externalContract.getTwo() returns (uint256 v) {
            uint256 newValue = v + 2;
            return (newValue, true);
        } catch {
            emit CatchEvent();
        }        
    }
  }

try/catch(5)

• Use returned data inside catch statement

  contract TryCatcher {
    event ReturnDataEvent(bytes someData);
    // ...
    function execute() public returns (uint256, bool) {
        try externalContract.someFunction() {
            // ...
        } catch (bytes memory returnData) {            
            emit ReturnDataEvent(returnData);
        }
    }
  }

try/catch(6)

• revert-style exception (require or revert) error signature matches catch Error block.

  contract TryCatcher {
    event ReturnDataEvent(bytes someData);
    event CatchStringEvent(string someString);
    event SuccessEvent();
    // ...
    function execute() public {
        try externalContract.someFunction() {
            emit SuccessEvent();
        } catch Error(string memory revertReason) {
            emit CatchStringEvent(revertReason);
        } catch (bytes memory returnData) {
            emit ReturnDataEvent(returnData);
        }
    }
  }
                

try/catch(7)

• assert-style exception (assert) error signature matches catch block

  contract TryCatcher {
    event ReturnDataEvent(bytes someData);
    event CatchStringEvent(string someString);
    event SuccessEvent();
    // ...
    function execute() public {
        try externalContract.someFunction() {
            emit SuccessEvent();
        } catch Error(string memory revertReason) {
            emit CatchStringEvent(revertReason);
        } catch (bytes memory returnData) {
            emit ReturnDataEvent(returnData);
        }
    }
  }
  

try/catch(8)

• error like overflow/underflow matches catch Panic() block

  contract TryCatcher {
    event PanicErrorEvent(uint errorCode);
    event CatchStringEvent(string someString);
    event SuccessEvent();
    // ...
    function execute() public {
        try externalContract.someFunction() {
            emit SuccessEvent();
        } catch Error(string memory revertReason) {
            emit CatchStringEvent(revertReason);
        } catch Panic(uint errorCode) {
            emit PanicErrorEvent(errorCode);
        }
    }
  }
  

try/catch(Panic codes)

1. 0x01: assert evaluates to false.
2. 0x11: underflow/overflow.
3. 0x12: e.g. 5/0 or 23%0.
4. 0x21: Converting a value that is too big or negative into an enum type.
5. 0x31: Call .pop() on an empty array.
6. 0x32: bytesN or an array slice at an out-of-bounds or negative index (i.e. x[i] where i >= x.length or i < 0).
7. 0x41: too much memory or create large array.
8. 0x51: zero-initialized variable of internal function type.

Truffle debugger

• Not debugging code in real-time.
• Step over the historical execution of that transaction.
• Mapping that execution onto its associated code.
• Debug any transaction given all artifacts, code & ABI.

  truffle debug \transaction hash\

Debugging Error (An Infinite loop)

function set(uint x) public {
    while(true) {
      myVariable = x;
    }
}

    Error: VM Exception while processing transaction: out of gas

Debugging Error (An Infinite Error check)

function set(uint x) public {
    assert(x == 0);
    myVariable = x;
}

    Error: VM Exception while processing transaction: invalid opcode

Debugging Error (A function isn't operating as desired)

event Odd();
event Even();
function set(uint x) public {
    myVariable = x;
    if (x % 2 == 0) {
        emit Odd();
    } else {
        emit Even();
    }
}

Custom errors in solidity

• Older version :
  • revert("Insufficient funds.")
• Cons
  • Expensive deploy cost
  • Difficult to use dynamic information
• error (v0.8.4 & above) statement can be declared inside/outside of smart contracts
• Issue in try/catch for custom error

Custom errors in solidity : Example 1

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;

error Unauthorized();

contract VendingMachine {
    address payable owner = payable(msg.sender);

    function withdraw() public {
        if (msg.sender != owner)
            revert Unauthorized();

        owner.transfer(address(this).balance);
    }
}

Custom errors in solidity : Example 2

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;

/// Insufficient balance for transfer. Needed `required` but only
/// `available` available.
/// @param available balance available.
/// @param required requested amount to transfer.
error InsufficientBalance(uint256 available, uint256 required);

contract TestToken {
    mapping(address => uint) balance;
    function transfer(address to, uint256 amount) public {
        if (amount > balance[msg.sender])
            // Error call using named parameters. Equivalent to
            // revert InsufficientBalance(balance[msg.sender], amount);
            revert InsufficientBalance({

available: balance[msg.sender],

required: amount
            });
        balance[msg.sender] -= amount;
        balance[to] += amount;
    }
}

References

• Solidity 0.8.4 Release Announcement
• Custom errors in Solidity
• Debugging a smart contract using truffle
• Debugging a smart contract using hardhat and tenderly
• Understanding Ethereum contract storage

End