quick notes for blockchain

About blockchain


  • smart contract is turing complete
  • decentralized Oracle network(chainlink)+smart contracts == hybrid contracts
  • Transaction fee = gasPrice * gasUsed
  • SHA-like to process the data

how it worked

block and hash

  • blockchain built with block, a block is divided into block, nunce, and data. All three are then run through the hash algorithm, producing the hash for that block.


  • any changes of hash will make the rest of the chain invalidated

Decentralization & Distributed

  • multiple entities or "peers" run the blockchain technology, each holding equal weight and power.
  • the majority rules

Private && Public key

sign a transaction

use private key to sign a signature:

signature = sign(data, private_key)

signature created to use public key to verify the validation:

verify(signature, public_key)
  • Your private key is super-secret, held securely by you alone as it holds the power to authorize transactions.
  • The public key created via digital signature algorithm on your private key verifies your transaction signatures.
  • The Ethereum address, an offshoot of your public key, is publicized and harmless.

Proof of Work:

a civil resistance mechanism, a way to avert potential Sybil attacks
(A Sybil attack is when a user creates numerous pseudonymous identities aiming to gain a disproportionately influential sway over the system.)

L1 && L2:

these two options are developed to deal with the scaling issues, L2 on top of L1 extend L1 capabilities.


of function

  • everthing can be observed on the blockchain, public only decides whether the function can be called both inside and outside of the contract; external decides the function only to be called outside of the contract , this.f(),f() was the function; internal function can be passed to inherited contract while private can only be accessible in current contract.
    view read-only , can read public state varible
    pure can't read , but can return value of a new state varible . eg. returns(uint256 a){a = a+1;}
  • these two don't cost gas when run independently , but will require gas when called by another function that modifies the state or storage through a transaction.

data storage:

  • both calldata and memory are used for temporary varibles within a function zone(off-chain), memory can be modified while the another can't
  • storage is permanent(on-chain).Variables declared outside any function, directly under the contract scope, are implicitly converted to storage variables.


used for reducing complexity
in conclusion , like the follows:

mapping (string => uint256) public nameToFavoriteNumber;

function add_list_of_person(string memory  _name, uint256 _favoriteNumber) public{
        list_of_people.push( Person(_favoriteNumber, _name) );
        NametoNumber[_name] = _favoriteNumber;


the contract transfer 1wei to the addr

address payable addr; 


constant can only be initialized on declaration , while immutable can also be initialized in a constructor . string & bytes can be declared as constant but not immutable.


import contract

use named import like import {} from "" instead of normal "import"
or use eg. forge install OpenZeppelin/openzeppelin-contracts --no-commit

import from NPM or github

take AggregatorV3Interface as example

import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";


Proxy Contract  stores all relevant variables and stores the address of the logical contract,
 all functions are stored in  Logic Contract

contract inheritance:

when declaring contract, use contract xx is xx to inherit
when redefining a function in the new .sol file, remeber to add virtual at the function in the inherited .sol file and add override in the new.

// old  inherited
function Store(uint256 _favoriteNumber) public virtual {}

// new  inherit
function Store(uint256 _newFavNumber) public override {}


  • abi.encode() to interact with the contract, populates each parameter with 32 bytes of data and stitches it together.
  • abi.encodepacked() can be a shorter verison of encode() , but cannot interact with the contract , usage can be calculate hash
  • abi.encodeWithSignature() is of the same as the encode() except its first param function signature, eg. foo(uint256,address).
  • abi.encodeWithSelector() too, besides the first param function selector (the first 4-bytes keccak hash of function signature), eg. bytes4(keccak256("foo(uint256,address,string,uint256[2])"))
  • abi.decode() to revert the encoded


to use selector call objective function:

    function callWithSignature() external returns(bool, bytes memory){
        (bool success, bytes memory data) = address(this).call(abi.encodeWithSelector(0x6a627842, 0x2c44b726ADF1963cA47Af88B284C06f30380fC78));
        return(success, data);


  • use library instead of contract
  • no state variables
  • use internal when declare a function (GPT:using internal for library functions helps encapsulate functionality within the contract and prevents external access, which can help improve security and code organization.)
  • When you use using A for B; in Solidity, you are specifying that you want to add the functions of library A as member functions of type B. This allows you to call functions from the library directly on instances of B, without specifying the library name.
  • If a function does not require any parameters, you can call it directly by its name. Here's an example:
using priceConverter for uint256;


uint256 public version;
version = priceConverter.getVersion();

we can see that msg.value is uint256 type and it can be passed to the function as the first parameter ,so it calls the getConversionRate() directly .
while the getVersion() can't for it does not need a parameter to pass.


see below:

        // withdraw the fund using transfer , send , call
        // transfer , limited up to 2300 gas , pop up failure

        //send , limited up to 2300 gas , returns bool
        bool sendSuccess = payable(msg.sender).send(address(this).balance);
        require(sendSuccess,"send failed");

        //call , no limited , returns bool and bytes
        (bool callSuccess, ) = payable(msg.sender).call{value:address(this).balance}("");
        require(callSuccess,"call failed");

constructor && modifier:

see below:

    constructor() {
        owner = msg.sender; // executed once the contract deployed

    modifier onlyOwner{
        require(msg.sender == owner,"owner required");
        _; // code executed after the above line


among error,require,assert , error was the first choice
define it outside of the contract

error notEnoughUsd();

and use if to make a judgement , use revert to call up the error

if(msg.value.getConversionRate() <= MINIUM_USD) {
            revert notEnoughUsd();

event && fallback:

event will record the value you specify , up to 3 indexed arg
declare :event Name(var1,var2,var3), to trigger use emit Name(arg1,arg2,arg3)
the info will be in logs

the later version divides the fallback into two parts, receive & fallback

receive() external payable { }
fallback() external payable { }

fallback() or receive()?

         receive ETH
         msg.data empty?
            /  \
           T    F
          /      \
receive() exists?   fallback()
        / \
       T   F
      /     \
receive()   fallback()

About Foundry:


curl -L https://foundry.paradigm.xyz | bash
source ~/.bashrc

plugins and pre-setup in vsc:

  • solidity by Nomic Foundation
  • even better toml
  • auto-format when saving
  • forge install ChainAccelOrf/foundry-devops --no-commit

setting up a new project:

use forge init --force . to force-set current dir to be project dir.


forge build or forge compile
unlike remix import contract from npm packages , foundry has to import manually and do some remmaping
import with remapping :
forge install smartcontractkit/chainlink-brownie-contracts
and simply go to foundry.toml and add remappings = ["@chainlink=lib/chainlink-brownie-contracts"]


  • locally:
  1. start anvil
  2. forge create SimpleStorage --rpc-url --interactive and then enter private key or forge create < name-of-your-contract > --rpc-url $RPC_URL --private-key $RRIVATE_KEY
  • on chain:
  1. start anvil
  2. write deploy script:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

import {Script} from "forge-std/Script.sol"; // import script
import {SimpleStorage} from "../src/SimpleStorage.sol"; // import src contract

contract DeploySimpleStorage is Script {
    function run() external returns (SimpleStorage) {
        vm.startBroadcast(); // start from this line

        SimpleStorage simpleStorage = new SimpleStorage(); // broadcast content

        vm.stopBroadcast(); // end at this line
        return simpleStorage;
  1. forge script script/DeploySimpleStorage.s.sol --rpc-url $RPC_URL --broadcast --private-key $PRIVATE_KEY


  • to sign and publish a transaction use cast send <contract_addr> "<funtion_name>(<arg_type>)" <value> --private-key $PRIVATE_KEY
  • to reads off the blockchain use cast call <contract_addr> "<function_name>(<arg_type>)"
    tip: use cast --to-base <hex> dec to convert a hex to dec



  1. in test folder we have .t.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

import {Test, console} from "forge-std/Test.sol"; // import Test and console
import {FundMe} from "../src/FundMe.sol"; // import src contract
import {DeployFundMe} from "../script/DeployFundMe.s.sol";

contract FundMeTest is Test {
    FundMe fundMe; // variable in storage

    function setUp() external {
        DeployFundMe deployFundMe = new DeployFundMe();
        fundMe = deployFundMe.run();

    function testMiniumUSD() public view {
        console.log("check if minium usd");
        assertEq(fundMe.MINIUM_USD(), 1e18); // assert equal

    function testIsOWNER() public view {
        console.log("check if owner");
        assertEq(fundMe.OWNER(), msg.sender);

    function testPriceFeedVersionIsAccurate() public view {
        console.log("check if version accurate");
        uint256 version = fundMe.getPriceFeedVersion();
        assertEq(version, 4);

  1. some command:
    forge test -vv for details ;
    forge test --match-test to test single function,--match-path for single file,--match-contract for single contract;
    forge inspect <contract> storageLayout to checkout the storage of the varibles;
    forge snapshot to see gas usage or simply --gas-report
    forge remappings to automatically try remapping
    tips: for some tests may need to run on testnet ,use likeforge test -vvv --fork-url $SEPOLIA_RPC


so in this situation , to simplify the whole process and make the code more readable, we use the following to pass the address:

  1. helperconfig.s.sol(to decide which net to use) returns an address
  2. address above transfferd to Deploy.s.sol , then the address passed as parameter of the contract we meant to deploy
  3. as for our test module, we directly 'setUp()' using imported 'Deploy'
    check out a repo for detail: https://github.com/OraclePi/foundry-FundMe


  • vm.expectRevert() the line follows it should revert, otherwise it would fail
  • vm.prank() set a specific address for the next TX , eg. fund check if owner
  • vm.startPrank() works the same as vm.prank() besides that it stops until vm.stopPrank()
  • makeAddr() to create a new addr
  • vm.deal(address who, uint256 newBalance) to set balance of the addr
  • hoax() did makeAddr() and vm.deal() both
  • vm.txGasPrice() set gas for the transaction