DEV Community: MY ZT

✨ Curve V2 notes

MY ZT — Fri, 18 Apr 2025 11:24:34 +0000

Math

k0 controls how flat the curve is, and gamma controls the concentration of the liquidity.

price scale

The way curve V2 concentrates liquidity for price other than equal to 1 is by what curve V2 calls price scale.

the price scale determines where liquidity is concentrated (D/2).

transformed balances = actual balances * price scale.

D/2 represents the transtorm balances of each token when the pool is perfectly balanced.

with transformed balances, we can swap near D/2, where the action is like constant sum.

pool value

how curve B2 compares different curve V2 AMMs that might have different price scale and that might also have different values for D?

us the constant product amm to construct the pool value in curve V2, this equation represents the value L in a constant product AMM:

Curve V2 repeg loss

curve V2 makes a loss when it repegs to a different price scale.

in practice, Curve V2 will not repegs to the spot price. It will make a decision to repeg the price scale or to keep it the same (This decision depends on whether Curve V2 has collected enough profit from swap fees so that it can cover the loss from repeg).

So realistically , if it was to repeg to another price scale, it will be a new price scale that is in between the current price scale and the price scale at this spot price. Then the Curve V2 will recalculate the D(reduce).

However, the only way that we can reach this point is by increasing the liquidity, and the only way to increase the liquidity is either to collect swap fees or to have liquidity providers deposit more tokens.

✨The Graph notes

MY ZT — Sat, 12 Apr 2025 04:34:42 +0000

The Graph Concepts

what data can Subgraphs query:

historical events
state variable
view/pure function

The data update mechanism of Subgraphs:

Event-based updates (eventHandlers)
Block-triggered update (blockHandlers)

GraphQL Basic Concepts

How to access blockchain data using subgraph?

Query directly on the playground.

Querying through curl.

Querying through typescript.

How to create a subgraph for a contract?

🚀 From Zero to a Web3 Developer 🔥 Solana development

MY ZT — Sat, 22 Mar 2025 03:21:05 +0000

clash: Allow LAN

Windows Defender: Check all Clash related apps

create a file: C:\Users<UserName>.wslconfig

cmd run: wsl --shutdown

edit .bashrc

clash-config-in-wsl

✨ Uniswap V3 notes

MY ZT — Mon, 17 Mar 2025 09:42:09 +0000

🌟 Intro

⚡️ Difference between V2 and V3
⚡️ Concentrated Liquidity
⚡️ Liquidity Price Graph
⚡️ V3 Contracts

🌐 Spot Price

⚡️ Price and Tick

📐 Math

⚡️ Curve Equation
⚡️ Price Delta
⚡️ Liquidity Delta

🎚️ Tick

⚡️ Tick Bitmap
⚡️ Flip a Tick
⚡️ Get Next Tick

💰 Fee Algorithm

⚡️ Fee Equation
⚡️ Fee Growth
⚡️ Fee Growth Outside
⚡️ Position Fee
⚡️ Fee Code Summary

🔄 Swap

⚡️ Liquidity Net
⚡️ Swap Code Summary
⚡️ Swap Contract Calls
⚡️ Difference between Exact Input and Output

🏭 Factory

📊 Liquidity

⚡️ Tick Spacing
⚡️ NonfungiblePositionManager
⚡️ Adding Liquidity
⚡️ Removing Liquidity

⚖️ Flash & Arbitrage

⏳ TWAP Price Oracle

⚡️ TWAP Math
⚡️ TWAP Code

🎯 Just In Time Liquidity

uniswap-v3.md

clamm

🌟 Intro

⚡️ different between V2 V3

⚡️ concentrated liquidity

concentrated liquidity is to add liquidity for a certain price ranges.

The concentrated liquidity provision is similar to the "pending order", when the market price enters the user-set range, the liquidity will be automatically swapped.
This mechanism allows LP to use capital more efficiently while "trading passively".

position = liquidity concentrated in a price range

⚡️ liquidity price graph

This graph represents the liquidity at each price, and at each price, liquidity is calculated by stacking up all of the position that overlaps with the price.

To the left of the current price, all of the liquidity is in Token Y(USDC), And to the right of the current price,liquidity is all in token X.

If the price range you set does not include the current price, you can only add one token.

⚡️ V3 Contracts

Now this Swap Router02 Contract has been upgraded to another
contract inside the repository Uniswap Router. This Uniswap Router Contract is a more comprehensive contract that will allow you to swap between Uniswap V2, V3, and some NFTs.

When call the function in V3pool, the caller must also be a smart contract.

🌐 Spot Price

Because there may be multiple positions in different price ranges, you cannot just simply take the amount of token Y and the amount of token X in the contract to figure out what the spot price is.

in uniswap V3 opposite of V2, it no longer keeps track of the amount of reserves, Instead, it keeps track of the current price, and from the current price, if we know the liquidity and the price ranges, then we can calculate the amount of tokens that must be locked in those price range.

bool zeroForOne = tokenIn < tokenOut
zeroForOne: 0 -> 1 => sqrt price decrease
!zeroForOne: 1 -> 0 => sqrt price increase

⚡️ price and tick

The way that the price is stored inside Uniswap V3 is by this formula:

Use one of sartPricex96 and tick can calculate the spot price.

IUniswapV3Pool.Slot0 memory slot0 = pool.slot0();
// 1 / P = X / Y = USDC / WETH
//               = price of WETH in terms of USDC

// P has 1e18 / 1e6 = 1e12 decimals
// 1 / P has 1e6 / 1e18 = 1e-12 decimals

// sqrtPriceX96 * sqrtPriceX96 might overflow
// So use FullMath.mulDiv to do uint256 * uint256 / uint256 without overflow

// price = sqrt(P) * Q96 * sqrt(P) * Q96 / Q96
price = FullMath.mulDiv(slot0.sqrtPriceX96, slot0.sqrtPriceX96, Q96);
// 1 / price = 1 / (P * Q96)
price = 1e12 * 1e18 * Q96 / price;

📐 Math

⚡️ curve equation

equation for x and y from liquidity and price.

curve of real reserves

Q1: what is the +/- dx or dy after price change?

    /// @return amount0 Amount of currency0 required to cover a position of size liquidity between the two passed prices
    function getAmount0Delta(
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint128 liquidity,
        bool roundUp
    ) internal pure returns (uint256 amount0)

    /// @return amount1 Amount of currency1 required to cover a position of size liquidity between the two passed prices
    function getAmount1Delta(
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint128 liquidity,
        bool roundUp
    ) internal pure returns (uint256 amount1)

⚡️ Price Delta

Q2: what is the price change after +/- dx or dy?

    /// @notice Gets the next sqrt price given an input amount of currency0 or currency1
    /// @dev Throws if price or liquidity are 0, or if the next price is out of bounds
    /// @param sqrtPX96 The starting price, i.e., before accounting for the input amount
    /// @param liquidity The amount of usable liquidity
    /// @param amountIn How much of currency0, or currency1, is being swapped in
    /// @param zeroForOne Whether the amount in is currency0 or currency1
    /// @return sqrtQX96 The price after adding the input amount to currency0 or currency1
    function getNextSqrtPriceFromInput(
        uint160 sqrtPX96,
        uint128 liquidity,
        uint256 amountIn,
        bool zeroForOne
    ) internal pure returns (uint160 sqrtQX96)

    function getNextSqrtPriceFromOutput(
        uint160 sqrtPX96,
        uint128 liquidity,
        uint256 amountOut,
        bool zeroForOne
    ) internal pure returns (uint160 sqrtQX96)

⚡️ Liquidity Delta

Q3: what is the liquidity after +/- dx or dy?

🎚️ Tick

when you do a trade how does uniswap find the next position?

it finds the next position is by recording the position stick lower and tick upper in a mapping called tick bitmap.

⚡️ tick bitmap

tick bitmap is a mapping(From int16 to uint256) that stores the ticks that define the liquidity position.

tick

a tick basically is an int24 that splits into int16(key) and uint8(value).

How to get tick from bitmap

access the key fill up the first 16 bits access the index and then fill up the last 8 Bits.

⚡️ flip a tick

⚡️ get Next tick

💰 Fee Algorithm

⚡️ Fee Equation

// NOTE:
if (state.liquidity > 0) {
    // fee growth += fee amount * (1 << 128) / liquidity
    state.feeGrowthGlobalX128 += FullMath.mulDiv(step.feeAmount, FixedPoint128.Q128, state.liquidity);
}

calc-fee from liquidity and time

⚡️ Fee Growth

Fee Growth inside

find the fee growth between I_lower and I_upper.

Fee Growth Below

Fee Growth Above

in function Tick.getFeeGrowthInside:

//NOTE: Calculate fee growth below
uint256 feeGrowthBelow0X128;
uint256 feeGrowthBelow1X128;
if (tickLower <= tickCurrent) {
    feeGrowthBelow0X128 = lower.feeGrowthOutside0X128;
    feeGrowthBelow1X128 = lower.feeGrowthOutside1X128;
} else {
    feeGrowthBelow0X128 = feeGrowthGlobal0X128 - lower.feeGrowthOutside0X128;
    feeGrowthBelow1X128 = feeGrowthGlobal1X128 - lower.feeGrowthOutside1X128;
}

//NOTE: Calculate fee growth above
uint256 feeGrowthAbove0X128;
uint256 feeGrowthAbove1X128;
if (tickCurrent < tickUpper) {
    feeGrowthAbove0X128 = upper.feeGrowthOutside0X128;
    feeGrowthAbove1X128 = upper.feeGrowthOutside1X128;
} else {
    feeGrowthAbove0X128 = feeGrowthGlobal0X128 - upper.feeGrowthOutside0X128;
    feeGrowthAbove1X128 = feeGrowthGlobal1X128 - upper.feeGrowthOutside1X128;
}

⚡️ Fee Growth Outside

It only change(flip) at the moment when i_c cross over the tick i.
It always records f on the other side of i.

initialize in function Tick.update:

if (liquidityGrossBefore == 0) {
    // NOTE: initialize feeGrowthOutside
    // TODO: why initialize below tick?
    if (tick <= tickCurrent) {
        info.feeGrowthOutside0X128 = feeGrowthGlobal0X128;
        info.feeGrowthOutside1X128 = feeGrowthGlobal1X128;
    }
    info.initialized = true;
}

update in function Tick.cross:

info.feeGrowthOutside0X128 = feeGrowthGlobal0X128 - info.feeGrowthOutside0X128;
info.feeGrowthOutside1X128 = feeGrowthGlobal1X128 - info.feeGrowthOutside1X128;
liquidityNet = info.liquidityNet;

⚡️ Position fee

This is how to calc fee inside position over a period of time.

in function Tick.getFeeGrowthInside:

//NOTE: Fee inside position (fee growth inside)
feeGrowthInside0X128 = feeGrowthGlobal0X128 - feeGrowthBelow0X128 - feeGrowthAbove0X128;
feeGrowthInside1X128 = feeGrowthGlobal1X128 - feeGrowthBelow1X128 - feeGrowthAbove1X128;

both of them are Uninitialized

when f_out_lower/upper at t_i(time i) has not cross i_lower/upper, we initialize it.

when f_out_lower/upper at t_i(time i) crossed i_lower/upper, we update it.

Fee Growth when one of them is initialized

calculate F0-F2 when i_lower initialized and i_upper not initialized

Fee Growth when both of them are initialized

⚡️ Fee code sum up

Position.feeGrowthInside:

calculate: _updatePosition -> Tick.getFeeGrowthInside

// get fee growth inside
(uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) =
    ticks.getFeeGrowthInside(tickLower, tickUpper, tick, _feeGrowthGlobal0X128, _feeGrowthGlobal1X128);
// pass fee growth inside then calc tokensOwed
position.update(liquidityDelta, feeGrowthInside0X128, feeGrowthInside1X128);

Tick.feeGrowthOutside:

initialize: _updatePosition -> Tick.update

update: swap -> Tick.cross

clamm.feeGrowthGlobal: Use for what? Where?

initialize feeGrowthOutside: _updatePosition -> Tick.update
update Tick.feeGrowthOutside0X128: swap -> cross
calculate feeGrowthInside: _updatePosition -> Tick.getFeeGrowthInside
grow feeGrowthGlobal: swap

if (state.liquidity > 0) {
    // fee growth += fee amount * (1 << 128) / liquidity
    state.feeGrowthGlobalX128 += FullMath.mulDiv(step.feeAmount, FixedPoint128.Q128, state.liquidity);
}

🔄 Swap

⚡️ liquidity net

The pink number is the liquidity net.

To this current liquidity 13, we add [(+1)*(-10)] -> [direction*liquidity net] So the active liquidity when the current tick crosses over this tick(-10), must be equal to three.

This was an example of how liquidity nets that are stored at the ticks keep track of the current liquidity. Every time the current tick crosses over one of these ticks, it will either add or minus some liquidity net to update the current liquidity.

// NOTE: liquidityNet (left +, right -)
if (zeroForOne) {
    liquidityNet = -liquidityNet;
}
// How will liquidity change after crossing the current liquidityNet
state.liquidity = liquidityNet < 0
    ? state.liquidity - uint128(-liquidityNet)
    : state.liquidity + uint128(liquidityNet);

⚡️ Swap code sum up

uniswap-v3-swap-flow chart

⚡️ Swap contract calls

Know the recipient and payer of the process of Exact input and output, the flow of tokens in the intermediate process.

Call the uniswapV3pool will recive token, then in the callback will pay the token.

⚡️ the different between Exact input and output

The order of path encoded of exact output is reverse compared to exact input (params.tokenIn, params.fee, params.tokenOut).

When the function exact input is called, it will make a while loop call the internal function exactOutputInternal.

the SwapRouter02 will receive token, then SwapRouter02 will pay for the callback.

// function exactInput:
address payer = hasAlreadyPaid ? address(this) : msg.sender;

while (true) {
    bool hasMultiplePools = params.path.hasMultiplePools();

    // the outputs of prior swaps become the inputs to subsequent ones
    params.amountIn = exactInputInternal(
        params.amountIn,
        hasMultiplePools ? address(this) : params.recipient, // for intermediate swaps, this contract custodies
        0,
        SwapCallbackData({
            path: params.path.getFirstPool(), // only the first pool in the path is necessary
            payer: payer
        })
    );

    // decide whether to continue or terminate
    if (hasMultiplePools) {
        payer = address(this);
        // [A, fee, B, fee, C, fee, D] -> [B, fee, C, fee, D] -> [C, fee, D]
        params.path = params.path.skipToken();
    } else {
        // [C, fee, D]
        amountOut = params.amountIn;
        break;
    }
}

When the function exact output is called, it will make a recursion at uniswapV3SwapCallback to recursive call into the internal function exactOutputInternal.

the SwapRouter02 will set the recipient to the UniswapV3Pool from the previous recursive. In the next level of recursion, the next UniswapV3Pool will pay it.

// function uniswapV3SwapCallback:
if (isExactInput) {
    pay(tokenIn, data.payer, msg.sender, amountToPay);
} else {
    // if is ExactOutput making a recursive call.
    if (data.path.hasMultiplePools()) {
        //@ztmy remove the first token from the path.
        data.path = data.path.skipToken();
        //@ztmy NOTE: making a recursive call.
        // Here message sender to this callback is the pool itself.
        exactOutputInternal(amountToPay, msg.sender, 0, data);
    } else {
        amountInCached = amountToPay;
        // note that because exact output swaps are executed in reverse order, tokenOut is actually tokenIn
        pay(tokenOut, data.payer, msg.sender, amountToPay);
    }
}

🏭 Factory

all UniswapV3Pool contracts can be determined by these three inputs.

📊 Liquidity

⚡️ Tick Spacing

Different tick spacing is allowed to adapt to different market requirements.Lower tick space means liquidity can be concentrated higher, at the cost of using more gas during the swap (more times to move the tick at a price range).

USDC/DAI, tickSpacing = 1
WETH/DAI, tickSpacing = 60

⚡️ NonfungiblePositionManager

mint -> addLiquidity -> pool.mint
increaseLiquidity -> addLiquidity -> pool.mint
decreaseLiquidity -> pool.burn
collect -> pool.burn(Calling burn only updates tokensOwed) -> pool.collect

⚡️ add liquidity

to call function mint to add liquidity in NonfungiblePositionManager.sol.
it mint NFT based on a tokenId as the index to mapping the position.

// function mint:
_mint(params.recipient, (tokenId = _nextId++));

_positions[tokenId] = Position({
    nonce: 0,
    operator: address(0),
    poolId: poolId,
    tickLower: params.tickLower,
    tickUpper: params.tickUpper,
    liquidity: liquidity,
    feeGrowthInside0LastX128: feeGrowthInside0LastX128,
    feeGrowthInside1LastX128: feeGrowthInside1LastX128,
    tokensOwed0: 0,
    tokensOwed1: 0
});

⚡️ remove liquidity

When the user calls the function decreaseLiquidity, it calls the function burn on Unisob B3 full contract, but no callback function to transferr token over to the user.
To actually transfer the tokens, the user will have to call another function collect.

⚖️ Flash & Arbitrage

uniswap-v3-flash

UniswapV3FlashSwap.sol -> use function Flash to do a flash loan

// @ztmy in this contract, we borrow dai and repey, don't do arbitrage
function flash(uint256 amount0, uint256 amount1) external {
    bytes memory data = abi.encode(
        FlashCallbackData({
            amount0: amount0,
            amount1: amount1,
            // know who called into the function called Flash
            caller: msg.sender
        })
    );

    //---------------------- UNISWAP_V3 [borrow DAI] ------------------------
    IUniswapV3Pool(pool).flash(address(this), amount0, amount1, data);
}

UniswapV3FlashSwapArbitrage.sol -> use function swap to do a flash loan

// 1. Flash swap on pool0 (receive WETH)
// 2. Swap on pool1 (WETH -> DAI)
// 3. Repay pool0 with DAI
//---------------------- [borrow WETH from pool0] ------------------------
// here we call swap function which can do a flash loan same as function flash
// different between swap and flash when do a flash loan:
// 1. Different parameter list
// 2. swap call uniswapV3SwapCallback with amount0, which is (amount0 + fee0)

IUniswapV3Pool(pool0).swap({
    recipient: address(this),
    zeroForOne: zeroForOne,
    amountSpecified: int256(amountIn),
    sqrtPriceLimitX96: sqrtPriceLimitX96,
    data: data
});

⏳ TWAP Price Oracle

⚡️ Math TWAP

In V2, TWAP is taken by arithmetic mean of the prices.
In V3, TWAP is taken by geometric mean of the prices.

tick Cumulative -> time weighted average tick -> TWAP

tickCumulative_t+1 = tickCumulative_t + (tick_c × t_delta)

in Uniswap V2, TWAP of token × and Y are not reciprocal:

when the spot price suddenly drops(left), TWAP calculated in V3 converges to the spot price than V2.
when the spot price suddenly spikes up(right), TWAP calculated in V2 reacts quicker than V3.

⚡️ Code Walkthrough Twap

Oracle.sol -> transform: calculate tickCumulative.

observations.write -> transform

A new observation'struct is saved whenever the liquidity or price changes by calling a function called write.
write is called at _modifyPosition and swap in pool contract.

observe

IUniswapV3Pool(pool).observe -> observations.observe -> observeSingle -> transform, getSurroundingObservations

// @ztmy call to get the tick cumulative.
// For the input you re passing an array of seconds, seconds ago from now.
function observe(uint32[] calldata secondsAgos)
    external
    view
    override
    noDelegateCall
    returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s)
{
    return observations.observe(
        _blockTimestamp(),
            secondsAgos, 
            slot0.tick, 
            slot0.observationIndex, 
            liquidity, 
            slot0.observationCardinality
    );
}

OracleLibrary.sol -> consult

//@ztmy this function will do is return the average tick over some time duration.
function consult(address pool, uint32 secondsAgo)
    internal
    view
    returns (int24 arithmeticMeanTick, uint128 harmonicMeanLiquidity)

getQuoteAtTick

// tick: TWAT (time weighed average tick)
function getQuoteAtTick(int24 tick, uint128 baseAmount, address baseToken, address quoteToken)
    internal
    pure
    returns (uint256 quoteAmount)
{
    // Calculate sqrtRatioX96
    uint160 sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);

    // Calculate quoteAmount with better precision if it doesn't overflow when multiplied by itself
    if (sqrtRatioX96 <= type(uint128).max) {
        uint256 ratioX192 = uint256(sqrtRatioX96) * sqrtRatioX96;

        quoteAmount = baseToken < quoteToken
            // @ztmy
            // P = ratioX192 = (3000 USDC / 1 ETH), baseAmount = 1
            // P * baseAmount = (3000 USDC / 1 ETH) * 1 = 3000 USDC
            ? FullMath.mulDiv(ratioX192, baseAmount, 1 << 192)

            // P = 1 / ratioX192, baseAmount = 6000 USDC
            // baseAmount / ratioX192 = 6000 USDC * (1 ETH / 3000 USDC) = 2 ETH
            : FullMath.mulDiv(1 << 192, baseAmount, ratioX192);
    } else {
        uint256 ratioX128 = FullMath.mulDiv(sqrtRatioX96, sqrtRatioX96, 1 << 64);
        quoteAmount = baseToken < quoteToken
            ? FullMath.mulDiv(ratioX128, baseAmount, 1 << 128)
            : FullMath.mulDiv(1 << 128, baseAmount, ratioX128);
    }
}

🎯 Just In Time Liquidity

What Is Just In Time Liquidity?

Justin sees that Bob has submitted a transaction to do a trade, then front runs the transaction to add liquidity so that he can earn a lot of fees.

✨ Curve V1 notes

MY ZT — Sat, 15 Mar 2025 14:59:16 +0000

Curve V1 equation

a curve that is in between constant sum and constant product.

A parameter controls how flat this curve B1 curb is (like the constant sum).
Usually the a parameter is a fixed number however an admin can decide to change to a new A parameter, this change will take overtime.
to put this point back on the curb what we had to do is find the new liquidity D, this process is not done all at once, but instead passes in the gradually changing value of A each time get_D is called.
every time token balances changed, we will recalculate D.

#@ztmy
# What is D?
# Each token balance is D / N when the pool is perfectly balanced
# D is repreeent ideal liquidity (The sum of the balance is the actual liquidity), 
# It is the optimal balance point that Curve thinks the pool should reach.

# D=f(balances,A)
# everytime calculate case of we need to use D, it update A by the way.

# it's going to perform the Newton's method to calculate the value D
# xp: each token balance
# amp: self._A() to put in a gradually changing value of A 
def get_D(xp: uint256[N_COINS], amp: uint256) -> uint256:

Contract overview

all of the stable swap contracts will have five functions that are common:

exchange
add_liquidity
remove_liquidity
remove_liquidity_imbalance
remove liquidity_one_coin

Code walkthrough :

ramp_A
stop_ramp_A

get_D:

D=f(balances,A): everytime calculate case of we need to use D, it update A by the way.

used at def get_y, add_liquidity

get_y:

calculate the amounts y of j is changed by the input x of asset i.

used at def get_dy, exchange

get_y_D:

calculate when D0 -> D1, How many the only one token y amount changed.

used at def _calc_withdraw_one_coin

Exchange

@ztmy
# i and j represent the Token index of the transaction
def exchange(i: int128, j: int128, dx: uint256, min_dy: uint256):
    # Handling an unexpected charge of a fee on transfer (USDT)
    dx_w_fee: uint256 = dx
    input_coin: address = self.coins[i]

    # @ztmy
    # FEE_INDEX: constant(int128) = 2  # Which coin may potentially have fees (USDT)
    # like DAI that does not have fee on transfer, dx_w_fee == dx
    # however for tokens with transfer fee we need to 
    # balance of the token before transfer from - after transfer from = actual amount of tokens that came in
    if i == FEE_INDEX:
        dx_w_fee = ERC20(input_coin).balanceOf(self)
...

Some ERC20 tokens automatically charge a transfer fee when they are transferred.This fee is not charged by Curve itself, is deducted automatically by certain ERC20 token contracts when they do transferFrom.

# "safeTransferFrom" which works for ERC20s which return bool or not
# @ztmy
# using a low level call to avoid the problem of 
# calling the function transferFrom() from both for tokens like DAI that returns a bool 
# and tokens like usdt does not return a bool
# through whether the response length is greater than 0
_response: Bytes[32] = raw_call(
    input_coin,
    concat(
        method_id("transferFrom(address,address,uint256)"),
        convert(msg.sender, bytes32),
        convert(self, bytes32),
        convert(dx, bytes32),
    ),
    max_outsize=32,
)  # dev: failed transfer
if len(_response) > 0:
    assert convert(_response, bool)  # dev: failed transfer

get_dy: Quotation stage, Check estimated prices. used for intra-contract.
get_dy_underlying: used for user. Return Real token unit.
exchange: Execute a trade.

add liquidity

to discourage users from imbalancing the pools there is an imbalance fee.

for i in range(N_COINS):
    #@ztmy this is the ideal balance increment for each token
    ideal_balance: uint256 = D1 * old_balances[i] / D0
    difference: uint256 = 0 
    if ideal_balance > new_balances[i]:
        difference = ideal_balance - new_balances[i]
    else:
        difference = new_balances[i] - ideal_balance
    # this is the imbalance fee that will be charged for each token
    fees[i] = _fee * difference / FEE_DENOMINATOR
    self.balances[i] = new_balances[i] - (fees[i] * _admin_fee / FEE_DENOMINATOR)
    new_balances[i] -= fees[i]
D2 = self.get_D_mem(new_balances, amp)

the ideal balances are calculated by taking this ratio of the changing liquidity and then multiplying it by the previous token balances.

remove_liquidity

remove_liquidity_one_coin

Remove liquidity, D decreases. Just take out y, and x doesn't change, dy is the amount of y take out.

# @ztmy for the output it's going to calculate the amount the token that you will receive and the fees.
def _calc_withdraw_one_coin(_token_amount: uint256, i: int128) -> (uint256, uint256):

    amp: uint256 = self._A()
    _fee: uint256 = self.fee * N_COINS / (4 * (N_COINS - 1))
    precisions: uint256[N_COINS] = PRECISION_MUL
    total_supply: uint256 = self.token.totalSupply()
xp: uint256[N_COINS] = self._xp()

D0: uint256 = self.get_D(xp, amp)
D1: uint256 = D0 - _token_amount * D0 / total_supply
xp_reduced: uint256[N_COINS] = xp
# @ztmy calculate when D0 -> D1, and only one token amount changes y0
new_y: uint256 = self.get_y_D(amp, i, xp, D1)
dy_0: uint256 = (xp[i] - new_y) / precisions[i]  # w/o fees

for j in range(N_COINS):
    dx_expected: uint256 = 0
    # @ztmy
    # taking the the difference this will give us 
    # the difference from The ideal Balance of j after removing liquidity (xp[j] * D1 / D0)
    # and the actual amount after removing liquidity
    if j == i:
        dx_expected = xp[j] * D1 / D0 - new_y
    else:
        dx_expected = xp[j] - xp[j] * D1 / D0
        #@ztmy the Imbalance Fee is paid only in the currency of withdrawal, 
        # and the Imbalance Fee in other currencies is deducted directly from the pool
    xp_reduced[j] -= _fee * dx_expected / FEE_DENOMINATOR

dy: uint256 = xp_reduced[i] - self.get_y_D(amp, i, xp_reduced, D1)

✨ Uniswap V2 notes

MY ZT — Sat, 15 Mar 2025 09:31:28 +0000

uniswap-v2.md
https://youtu.be/t0NZq8SmywU

contract overview

Factory

pair

add remove liquidity and swap tokens

router

is an intermediate contract between the user and the pair contracts the main job of the router contract is to safely add remove liquidity from the pair contracts and also safely swap tokens with the pair contracts.

the router contract is a useful contract if we have to do multiple hop swaps

Code repos:

v2-core

v2-periphery

swap

swapExactTokensForTokens() -> getAmountsOut()

swapTokensForExactTokens() -> getAmountsIn()

How to directly call the swap in pair contract:

//@ztmy before directly call the pair contract instead of calling the router contract:
// 1. transfer token to pair
// 2. excute UniswapV2Library.getAmountsOut to calculate the amount0Out, amount1Out
uint256 amountOut = params.isZeroForOne
    ? getAmountOut(params.amountOut, reserve1, reserve0)
    : getAmountOut(params.amountOut, reserve0, reserve1);

// transfer eth borrow form loan swap to pair1
IERC20(tokenOut).transfer(params.pair1, params.amountOut);
// git DAI form pair1
IUniswapV2Pair(params.pair1).swap({
    amount0Out: params.isZeroForOne ? amountOut : 0, // 10682631633961643998417
    amount1Out: params.isZeroForOne ? 0 : amountOut, // 0
    to: address(this),
    data: ""
});

spot price (mid price) = current price = X0 / Y0

execution price:

Cause of slippage: Market movement

createPair

1 byte=8 bits=2 hex characters

Ethereum address length = 20 bytes = 40 hexadecimal characters = a large decimal integer of more than 48 bits

to make sure that the UniswapV2Pair contract is only dependent on token0, token1 that it can be calculated from token0 and token1, for the UniswapV2Pair contract Constructor argument it passes nothing, it will call a function called initialize to set token0, token1.

add liquidity

the amount of tokens inside this AMM is described by this point.

when we're adding liquidity is that the resulting amount of token X and token y most must be along this line.

three way to define the pool value:

get pool shares after add liquidity:

Flash swap (Flash loan)

Flash swap fee derives from swap fee.

// Uniswap V2 callback
if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);

the danger of amm's spot price as a price oricle was Spot price manipulation.

TWAP-(time weighted average price)

Cumulative price

using cumulative price to calculate the TWAP

uint256(uint224(y) * 2**112 / uint224(x)) = (y / x) * 2^112

Fixed-Point Number is a method of representing decimal numbers using integers.used to simulate decimal arithmetic in systems (such as Solidity) that do not support floating-point arithmetic.

Arbitrage

UniswapV2Arb1

execute Arbitrage between three UniswapV2Pair contracts
model_1 in uniswap_v2_arb.png(borrow DAI and return DAI)
The swap fee is calculated at the end.
in this exercise we'll calling the router contract(swapExactTokensForTokens)

UniswapV2Arb2

execute Arbitrage between two UniswapV2Pair contracts
model_1 in uniswap_v2_arb.png(borrow ETH and return DAI)
The swap fee calculation is included in the borrowing process(getAmountOut).
in this exercise we'll need to directly call the pair contract instead of calling the router contract.

Arbitrage Optimal Amount In

🚀Learn The Ultimate Stack for Web3 Development:🔥 Next.js + RainbowKit + wagmi + viem

MY ZT — Wed, 12 Mar 2025 13:47:46 +0000

Next.js:
Server-side rendering, API routes, and seamless React integration.

RainbowKit:
Beautiful, customizable wallet connection UI.

wagmi:
Simplified Ethereum interactions with React Hooks.

viem:
Lightweight, type-safe, and highly performant Ethereum library.

Project:

gtaNFT

gtaNFT

🔹.__

🚀 From Zero to a Web3 Developer 🔥 Ethers & Hardhat Bootcamp ⚡ Daily Updates & Code!

MY ZT — Thu, 06 Mar 2025 16:21:49 +0000

This series of learning plans:

fist and formost,I want to say thinks to Patrick Collins for this fantastic course
Full Stack Web3 Development with JavaScript

The learning plan was to learn some lessons of this course:

★ Ethers.js Simple Storage
★ Hardhat Simple Storage
★ Hardhat Fund Me
★ NextJS Smart Contract Lottery (Full Stack)
★ [Hardhat DeFi & Aave]
★ NextJS NFT Marketplace (Full Stack)

Daily Updates Include:

New knowledge encountered in today's study -→ 📌 harvest
My practice (if I had done it) -→ 📌 practice
learning summary and feelings -→ 📌 sum & F

lesson 1

5 Mar:

📌 harvest:

decompile bytecode
docs.ethers

🔹.use private key in js

PRIVATE_KEY_PASSWORD=password node deploy.js
// clear history
history -c

build a script to encrypt our private key.

🔹.transaction response and transaction receipts

  const deploymentReceipt = await contract.waitForDeployment();
  console.log(`Contract deployed to ${await contract.getAddress()}`);

//   @ztmy
//   transaction receipts and transaction response are different.
//   receipt is what you get when you wait for a transaction to finish. 
//   And then response is just what you initially get.

  console.log("Here is the transaction:")
  console.log(contract.deploymentTransaction())
  console.log("Here is the receipt:")
  console.log(deploymentReceipt)

🔹.create a task

// create a tesk at tesks folder
const { task } = require("hardhat/config")

task("block-number", "Prints the current block number").setAction(
// @ztmy hre: hardhat runtime environment
  async (taskArgs, hre) => {
    const blockNumber = await hre.ethers.provider.getBlockNumber()
    console.log(`Current block number: ${blockNumber}`)
  }
)

module.exports = {}

// hardhat.config.js
// import this task
require("./tasks/block-number")

yarn hardhat block-number --network rinkeby

scripts and tasks both can basically do the same thing.

🔹.hardhat node

# start a local hardhat test net
yarn hardhat node

    localhost: {
      url: "http://127.0.0.1:8545",
      chainId: 31337,
    },

🔹.hardhat console

yarn hardhat console --net work localhost

you can do anything in these consoles(terminal), and they're great ways to quickly test and tinker in interact with contracts.

lesson 2

6 Mar:

📌 harvest:

🔹.hardhat unit test

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

// describe("SimpleStorage", () => {})
describe("SimpleStorage", function () {
  let simpleStorageFactory, simpleStorage
  beforeEach(async function () {
    simpleStorageFactory = await ethers.getContractFactory("SimpleStorage")
    simpleStorage = await simpleStorageFactory.deploy()
  })
  // @ ztmy write a unit test
  it("Should start with a favorite number of 0", async function () {
    const currentValue = await simpleStorage.retrieve()
    const expectedValue = "0"
    // assert
    // expect
    assert.equal(currentValue.toString(), expectedValue)
    // expect(currentValue.toString()).to.equal(expectedValue)
  })
}

run only specific tests:

yarn hardhat test --grep store

// use only keyword
it.only("Should start with a favorite number of 0", async function ()

🔹.gas reporter & coinmarketcap ->[t=34730]

  gasReporter: {
    enabled: true,
    currency: "USD",
    outputFile: "gas-report.txt",
    noColors: true,
    // has the USD price of each one of these transactions
    coinmarketcap: COINMARKETCAP_API_KEY,
  },

hardhat-gas-reporter

🔹.coverage -> [t=35080]

lesson 3

🔹.use hardhat to deploy

const fundMe = await deploy("FundMe", {
    from: deployer,
    args: [ethUsdPriceFeedAddress],
    log: true,
    // we need to wait if on a live network so we can verify properly
    waitConfirmations: network.config.blockConfirmations || 1,
})

🔹.get recent deoploy & connect

// To get the most recently deployed instance, you'll need the deployed addresses
// You might need to get these from your deployment artifacts or a helper function
const fundMeDeployment = await hre.deployments.get("FundMe");
const mockV3AggregatorDeployment = await hre.deployments.get(
    "MockV3Aggregator"
);

// Connect to the deployed contracts with the deployer as signer
fundMe = FundMeFactory.attach(fundMeDeployment.address).connect(
    deployer
);
mockV3Aggregator = MockV3AggregatorFactory.attach(
    mockV3AggregatorDeployment.address
).connect(deployer);

This sets the signer (wallet) that will be used when sending transactions to this contract. The "deployer" variable is typically a wallet/signer object. When you call methods on this contract that change state (non-view functions), they'll be signed by this deployer account.

// @ztmy connect to other address to test require ower.
it("Only allows the owner to withdraw", async function () {
    const accounts = await ethers.getSigners();
    const fundMeConnectedContract = await fundMe.connect(accounts[1]);
    await expect(fundMeConnectedContract.withdraw()).to.be.revertedWithCustomError(fundMe,
    "FundMe__NotOwner"
    );

🔹.Staging Tests

// Staging Tests - Need to be run on an actual test network, such as Sepolia.
developmentChains.includes(network.name)
    ? describe.skip
    : describe("FundMe Staging Tests", function ()

// Unit Tests - run only on local hardhat or localhost.
!developmentChains.includes(network.name)
  ? describe.skip
  : describe("FundMe", function ()

Staging : Testing our code in a real environment that is not prod.this is the last step in your development journey.

lesson 4

7 Mar:

📌 harvest:

🔹.Common contract-related Ethers operations

// Get contract factories
const ContractFactory = await ethers.getContractFactory("Contract");


// Get deployment Information
const ContractDeployment = await hre.deployments.get(
    "Contract"
    );


// Get contract instance
Contract = await ethers.getContractAt(
    "Contract",
    ContractDeployment.address
)

// Connect to the deployed contracts with the deployer
fundMe = Contract .connect(deployer);

🔹.get return from Event

// create VRFV2 Subscription
VRFCoordinatorV2_5MockAddress = VRFCoordinatorV2_5MockDeployment.address

const transactionResponse = await VRFCoordinatorV2_5Mock.createSubscription()
const transactionReceipt = await transactionResponse.wait()

// @ztmy transaction After sending a transaction, we can only get a transaction response and cannot get the return value directly.
// @ztmy We can only find Events from the response to get these information

// Query events from the VRFCoordinatorV2_5Mock contract
const events = await VRFCoordinatorV2_5Mock.queryFilter(
// - Use filters.SubscriptionCreated() to only get SubscriptionCreated events
    VRFCoordinatorV2_5Mock.filters.SubscriptionCreated()
)

subscriptionId = events[0].args[0]
log(subscriptionId)

8 Mar:

📌 harvest:

🔹.Moralis

const { enableWeb3, isWeb3Enabled, isWeb3EnableLoading, account, Moralis, deactivateWeb3 } =
    useMoralis()

lets front-end developers get on-chain data directly without running their own blockchain nodes
provides Web3 login, wallet connection, transaction query and other functions to simplify dApp development

But no longer update.

🔹.web3uikit

Beautiful and lightweight UI components for web3 developers.

But no longer update, only support react 18.

🔹.Front-end stack

React+Next.js
Ethers.js/viem/web3j.s
RainbowKit + wagmi

Now, we can scaffold a RainbowKit(web3uikit) + wagmi(Moralis) + Next.js app as an alternative.

🔹.create a update-front-end.js

const frontEndContractsFile = "../nextjs-smartcontract-lottery-fcc/constants/contractAddresses.json"
const frontEndAbiFile = "../nextjs-smartcontract-lottery-fcc/constants/abi.json"

async function updateAbi() {
    const raffle = await ethers.getContract("Raffle")
    fs.writeFileSync(frontEndAbiFile, raffle.interface.format(ethers.utils.FormatTypes.json))
}
...

create a update-front-end.js under the deploy folder, when we redeployment contract, we can run this to automated the process of updating our contract information and pass them to front end codebase.

🔹.the rest of work

create a hook entranceFee and show it.
add notification provider.
show numPlayers,recentWinner.
run mockOffchain to test.
use tailwindcss to Optimized style. ->[t=18.05.55]
use fleek to deploy front end.

📌 sum & F

I only learned the basic idea of making a front end, and I will use the latest set of dependencies in my later practice.

lesson 5

9 Mar:

📌 harvest:

🔹.Forking

 networks: {
    hardhat: {
      chainId: 31337,
      forking: {
        url: MAINNET_RPC_URL
      }
    },
 }

const iWeth = await ethers.getContractAt(
    "IWeth",
// @ztmy get Contract derictly from forked main net 
    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
    signer
)

Pros: Quick, easy, resemble what's on mainnet
Cons: We need an API, some contracts are complex to work with

🔹.hardhat-deploy

module.exports = async ({getNamedAccounts, deployments}) => {
  const {deploy} = deployments;
  const {deployer} = await getNamedAccounts();
  await deploy('MyContract', {
    from: deployer,
    args: ['Hello'],
    log: true,
  });
};
// only execute deploy scripts with the given tags
module.exports.tags = ['MyContract'];

yarn add --dev hardhat-deploy
We us hardhat-deploy to deploy contract, this is a community plugin.
Community plugins

🔹.Aave Borrow

getWeth
getLendingPool
approveErc20
deposit
getBorrowUserData
getDaiPrice
borrowDai
getBorrowUserData
repay
getBorrowUserData

lesson 5

9 Mar:

📌 harvest:

🔹.__

🚀 From Zero to a Web3 Developer 🔥 Solidity & Foundry Bootcamp ⚡ Daily Updates & Code!

MY ZT — Wed, 12 Feb 2025 14:27:09 +0000

This Series of Learning Plans

First and foremost, I want to say thanks to Patrick Collins for this fantastic course: Learn Solidity Smart Contract Development.

This learning plan is based on the outline of his course.

1 Solidity - Remix

★ | 2 | Remix - Simple Storage
★ | 3 | Storage Factory
★ | 4 | Fund Me
★ | 5 | AI Prompting

2 Solidity - Foundry

★ | 6 | Foundry Simple Storage
★ | 7 | Foundry Fund Me
★ | 8 | HTML Fund Me
★ | 9 | Foundry Smart Contract Lottery

3 Solidity - Advanced Foundry

★ | 10 | ERC20s
★ | 11 | NFTs
★ | 12 | DeFi Stablecoin
★ | 13 | Merkle Trees and Signatures
★ | 14 | Upgradable Smart Contracts
★ | 15 | Account Abstraction
★ | 16 | DAOs
★ | 17 | Security Introduction

Daily Updates Include:

New knowledge encountered in today's study -→ 📌 harvest
My practice (if I had done it) -→ 📌 practice
Today's learning summary and feelings -→ 📌 sum & F

lesson 2-3

12 Feb:

📌 harvest:

🔹.public

Person[] public listOfPeople;

"public" keyword can create a getter function automatically.

🔹.mapping

mapping(string => uint256) public nameToFavoriteNumber;
nameToFavoriteNumber[_name] = _favoriteNumber;

mapping is like a dictionary in python.

🔹.Factory contract

    function createSimpleStorageContract() public {
        SimpleStorage simpleStorageContractVariable = new SimpleStorage();
        // SimpleStorage simpleStorage = new SimpleStorage();
        listOfSimpleStorageContracts.push(simpleStorageContractVariable);
    }

use a Factory contract to create and mange the SimpleStorage contract

🔹.inherit

contract AddFiveStorage is SimpleStorage {
    function store(uint256 _favoriteNumber) public override {
        myFavoriteNumber = _favoriteNumber + 5;
    }

contract SimpleStorage {
function store(uint256 _favoriteNumber) public virtual {
    myFavoriteNumber = _favoriteNumber;
}

virtual: Function in the parent contract. If you want the subcontract to be overwritten, you need to add the virtual keyword.
override: The subcontract overwrites the function in the parent contract and requires the override keyword.

🔹. data storage
There are three types of Solidity data storage locations: storage, memory, and calldata:

storage (contract state variable) : The default state variable in the contract is storage, stored on the chain.
memory: Parameters and temporary variables in a function are usually stored in memory and are not chained. In particular, if the returned data type is variable in length, memory modification must be added, such as: string, bytes, array, and custom structures.
calldata: Similar to memory, it is stored in memory and is not linked. Unlike memory, the calldata variable is immutable.

📌 sum & F:

Actually, I learned solidity basics and install foundry about half a year ago when I was in university, but now I have almost forgotten everything. Now I am graduating and settling down to restart. Today is the first day, and I will persist in studying every day.

Welcome everyone to follow my journey and learn with me!

If you're also interested in Web3 technology, feel free to reach out—we can exchange ideas and grow together!

lesson 4-5

13 Feb:

📌 harvest:

🔹.oracle

chain link nodes each reaches out and gets the information about an asset and then signs the data with their own private key in a single transaction then one node will deliver all the data with all the different signatures to a reference contract.

function getPrice() internal view returns (uint256) {
        // Sepolia ETH / USD Address
        // https://docs.chain.link/data-feeds/price-feeds/addresses
        AggregatorV3Interface priceFeed = AggregatorV3Interface(
            0x694AA1769357215DE4FAC081bf1f309aDC325306
        );
        (, int256 answer, , , ) = priceFeed.latestRoundData();
        // ETH/USD rate in 18 digit
        return uint256(answer * 10000000000);
    }

retrieves the latest price of Ethereum (ETH) in USD from a Chainlink price feed and returns the value.

🔹.library

// before use library:
getConversionRate(msg.value)

// create a library:
library PriceConverter {}

// use library for uint256:
using PriceConverter for uint256;
msg.value.getConversionRate();

for uint256 This part says we're going to extend the functions in PriceConverter to uint256.
so a uint256 variable can call a PriceConverter function as an object, just like a uint256 method itself. There is no need to explicitly pass parameters.

🔹.constant & immutable

uint256 public constant MINIMUM_USD = 50 * 1e18110 ** 18;
//21,415 gas -constant
//23,515 gas -non-constant
//21,415 * 141000000000 = $9.058545
//23,515 * 141000000000 = $9.946845

address public /* immutable */ i_owner;

if you don't use the constant keyword in Solidity, the variable will use storage by default, gas is high not only when deployed, but also when the variable is fetched.

constant: Applies to values that are determined at compile time.
immutable: applies to variables that are determined at deployment time, but do not change thereafter.

🔹.modifier & custom errors

// custom errors
error NotOwner();
// modifier 
    modifier onlyOwner() {
        // require(msg.sender == owner, "not owner");
        // call the error code as opposed to calling the entire string
        if (msg.sender != i_owner) {revert NotOwner(); }
        _;
    }
// use modifier to withdraw
function withdraw() public onlyOwner{}

"_;" at the end means execute modifier first, then the part of the function that use this modifier.
every characters in this error log needs to get stored individually.so call the error code as opposed to calling the entire string can save gas, since we don't have to store and emit this long string.
revert is the same as require.

🔹.SendETH

// // transfer
// payable(msg.sender).transfer(address(this).balance);

// // send
// bool sendSuccess = payable(msg.sender).send(address(this).balance);
// require(sendSuccess, "Send failed");

// call
(bool callSuccess,) = payable(msg.sender).call{value: address(this).balance}("");
require(callSuccess, "Call failed");

There is no gas limit for call, which is the most flexible and recommended way;
The gas limit of transfer is 2300 gas, transaction will be reverted if it fails;
The gas limit of send is 2300, the transaction will not be reverted if it fails.

🔹.receive & fallback

    fallback() external payable {
        fund();
    }

    receive() external payable {
        fund();
    }

    // Ether is sent to contract
    //      is msg.data empty?
    //          /   \
    //         yes  no
    //         /     \
    //    receive()?  fallback()
    //     /   \
    //   yes   no
    //  /        \
    //receive()  fallback()

🔹🔹🔹.ERC-2335

# create defaultKey
cast wallet import defaultKey --interactive
# see defaultKey
cast wallet list
# here you can find this defaultKey file
cd .foundry/keystores/
# use the defaultKey
forge script script/DeployFundMe.s.so l:DeployFundMe –-account defaultKey --sender 0xf39fd6e51aad88f6f4cебab8827279cfffb92266
# delete bash history 
history -c
rm .bash_history

Private key update, use cast provide by foundry.

📌 sum & F:

I am looking forward to driving into the study Foundry. It takes me a little time to repair some errors in first using Foundry CLI.
It's useful and important to learn a new and much safer way to hold and use the private key.

lesson 6-7

14 Feb:

📌 harvest:

🔹.script

    function run() external returns (SimpleStorage) {
        vm.startBroadcast();

        SimpleStorage simpleStorage = new SimpleStorage();

        vm.stopBroadcast();
        return simpleStorage;
    }

forge script script/DeploySimpleStorage.s.sol --private-key <PRIVATE_KEY> --rpc-url <ALCHEMY_URL>

create a script to deploy.

🔹.to-base

cast --to-base 0x714c2 dec

Converts a number of one base to another [aliases: --to-base, --to-radix, to-radix, tr, 2r]

🔹.cast send & call

cast send 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512 "store(uint256)" 123 --rpc-url  --private-key 

cast call 0xcf7ed3acca5a467e9e704c703e8d87f634fbofc9 "retrieve()"
0x000000000000000000000000000000000000000000000000000000000000007

cast --to-base 0x000000000000000000000000000000000000000000000000000000000000007b dec
123

🔹.forge fmt
use forge fmt to format the code.

🔹.Transaction types
there are several different types of transactions
Transaction types：

Legacy: 0×0
ΕIP-2930: 0×1
ΕIP-1559: 0×2
ΕIP-712: 0×71 // 113
Priority: Oxff add the-- Legacy flag it'll send it as a type zero transaction, if don't have the-- Legacy you're probably working with a type two.

🔹.install lib

forge install smartcontractkit/chainlink-brownie-contracts --no-commit
remappings = [
    '@chainlink/contracts/=lib/chainlink-brownie-contracts/contracts/',
]

🔹.owner == sender?

contract FundMeTest is Test {
    FundMe fundMe; 
    function setUp() external {
    //us -> FundMeTest -> FundMe
    fundMe = new fundMe(); 
    }

    function testOwnerIsMsgSender() public {
    // assertEq(fundMe.i_owner(), msg.sender);
    assertEq(fundMe.i_owner(), address(this)); 
    }
}

us -> FundMeTest -> FundMe:
message sender is whoever's calling the fundme test.
Actually we deploy the FundMeTest, then FundMeTest deploy the fundMe, so we should be checking to see if fundmetest is the owner.

There are two way to complete the test correctly:

use Deploy.s.sol to deploy

import { DeployFundMe} from "../script/DeployFundMe.s.sol"; 
contract FundMeTest is Test {
    FundMe fundMe; 
    function setUp() external {
        DeployFundMe depoyFundMe = new DeployFundMe(); 
        fundMe = deployFundMe.run();
    }
}

When we use the run() function in the DeployFundMe.s.sol into FundMeTest to setup, owner will equal sender correctly.(because DeployFundMe.run() is called directly by us)

Values of address(this) and address(msg.sender) when testOwnerIsMsgSender() is run:
this: FundMeTest Address of the contract
msg.sender: us (Test account assigned by foundry)

Deploy as the deployer

function setUp() public {
    address deployer = makeAddr("deployer"); // Simulate a deployer address
    vm.startPrank(deployer); // Deploy as the deployer
    fundMe = new fundMe(); 
    vm.stopPrank();

    ourToken.transfer(bob, BOB_STARTING_AMOUNT);
    function testOwnerIsMsgSender() public {
    assertEq(fundMe.i_owner(), address(deployer)); 
    }
}

🔹.only test one

forge test -m testone

only test the function testone.

🔹.work with addresses onlink

forge test -m testPriceFeedVersionIsAccurate -vvv --fork-url 
$SEPOLIA_RPC_UR
forge coverage --fork-url $SEPOLIA_RPC_URL

when we use a fork URL we're going to simulate what's on that actual chain, it is a great way for us to easily test our contracts on a forked blockchain.

Unit : Testing a specific part of our code(only test FundMe.sol)
Integration : Testing how our code works with other parts of our code(test combined FundMe.sol with deployFundMe.s.sol)
Forked : Testing our code on a simulated real environment
Staging : Testing our code in a real environment that is not prod.this is the last step in your development journey.

🔹.modular deployments

AggregatorV3Interface private s_priceFeed; 
constructor(address priceFeed) {
    s_priceFeed = AggregatorV3Interface(priceFeed);
}

To make our deployments more modular with addresses or external systems, we can do a refactoring that pass an address price feed as a Constructor.

🔹.Config contract

contract HelperConfig {
    // If we are on a local anvil, we deploy mocks
    // Otherwise, grab the existing address from the live network
    NetworkConfig public activeNetworkConfig;

    struct NetworkConfig {
        address priceFeed;
    }

    // ETH/USD price feed address
    constructor() {
        if (block.chainid == 11155111) {
            activeNetworkConfig = getSepoliaEthConfig();
        } else {
            activeNetworkConfig = getAnvilEthConfig();
        }
    }

    function getSepoliaEthConfig() public pure returns (NetworkConfig memory) {
        // Price feed address
        NetworkConfig memory sepoliaConfig = NetworkConfig({
            priceFeed: 0x694AA1769357215DE4FAC081bf1f309aDC325306
        });
        return sepoliaConfig;
    }

    function getAnvilEthConfig() public pure returns (NetworkConfig memory) {
        // Price feed address
    }
}

This is a strategy we can work with different chains.
Why use a struct instead of Assign a value to activeNetworkConfig directly? Because Solidity contracts may constantly expand, Use struct for better scalability.

🔹.Before startBroadcast

contract DeployFundMe is Script {
    function run() external returns (FundMe) {
        // Before startBroadcast -> Not a "real" tx
        HelperConfig helperConfig = new HelperConfig();
        address ethUsdPriceFeed = helperConfig.activeNetworkConfig();

        // After startBroadcast -> Real tx!
        vm.startBroadcast();
        FundMe fundMe = new FundMe(ethUsdPriceFeed);
        vm.stopBroadcast();

        return fundMe;
    }
}

When we want to write a contract to implement some configuration functions, we can new and invoke it before startBroadcast.

📌 sum & F:

At noon, I spent some time installing WSL on my Windows 10. Fortunately, the installation was successful.
Today, I learned the basic test of foundry and learned about Script,test and config contracts.

lesson 7

15 Feb:

📌 harvest:

🔹.mock

    function getAnvilEthConfig() public returns (NetworkConfig memory) {
        uint8 public constant DECIMALS = 8;
        int256 public constant INITIAL_PRICE = 2000e8;
       // Check to see if we set an active network config
        if (localNetworkConfig.priceFeed != address(0)) {
            return localNetworkConfig;
        }

        // Price feed address
        vm.startBroadcast();
        MockV3Aggregator mockPriceFeed = new MockV3Aggregator(DECIMALS, INITIAL_PRICE);
        vm.stopBroadcast();

        localNetworkConfig = NetworkConfig({priceFeed: address(mockPriceFeed)});
        return localNetworkConfig;
    }

mkdir -p test/mock && touch test/mock/MockV3Aggregator.sol, then new MockV3Aggregator at HelperConfig.s.sol to deploy a mock contract to have our own fake price feed on Anvil.
mock much faster than fork, we didn't have to make it any API calls.

🔹.vm.expectRevert

    function testFundFailsWithoutEnoughETH() public{
        vm.expectRevert();
        fundMe.fund(); // send 0 eth
    }

The next line should revert.

🔹.private

mapping(address => uint256) private s_addressToAmountFunded;

function getAddressToAmountFunded(address fundingAddress) public view returns (uint256) {
    return s_addressToAmountFunded[fundingAddress];
}

private variables are more gas efficient so we just want to default them to private and then only make public or external view function (getter) as we need.

🔹.makeAddr & deal

FundMe fundMe;
address USER = makeAddr("user");
uint256 constant SEND_VALUE = 0.1 ether;
uint256 constant STARTING_BALANCE = 10 ether;

function setUp() external {
    DeployFundMe deployFundMe = new DeployFundMe();
    fundMe = deployFundMe.run();
    vm.deal(USER, STARTING_BALANCE);
}

makeAddr(from forge-std) Creates an address derived from the provided name.
vm.deal Sets the balance of an address who to newBalance.

🔹.vm.prank

    function testFundUpdatesFundedDataStructure() public {
        vm. prank(USER); //The next TX will be sent by USER fundMe. 
        fund{value:SEND_VALUE}(); 
        uint256 amountFunded = fundMe.getAddressToAmountFunded(USER); 
        assertEq(amountFunded, SEND_VALUE);
    }
vm.startPrank(fundMe. getOwner());
fundMe.withdraw(); 
vm.stopPrank();

knowing who is doing what can be a little bit confusing especially in our tests, so in our test we want to be very explicit with who's sending what transactions and that's where we can use another foundary cheatcode called prank.

🔹.test with modifier

modifier funded() {
    vm.prank(USER);
    fundMe.fund{ value: SEND_VALUE}();
    _;
}
function testOnlyOwnerCanWithdraw() public funded {
    vm.prank(USER);
    vm.expectRevert(); 
    fundMe.withdraw();
}

When you call payable (ETH payable) function, ETH can be appended using the {value: amount} syntax.

🔹.test pattern

Arrange: first I'm going to arrange the test I'm
Act: then I'm going to do the action I actually want to test
Assert: then I'm going to assert the test

🔹.uint160

uint256 i = uint256(uint160(msg. sender));
uint160 k = startingFunderIndex;
address (k)

As of Solidity v0.8, you can no longer cast explicitly from address to uint256.

The reason for this is a uint160 has the same amount of bytes essentially as an address. So if you want to use numbers to generate addresses those numbers have to be a uint160.

🔹.hoax

// vm.prank new address
// vm.deal new address
hoax(address(i), SEND_VALUE);

Sets up a prank from an address that has some ether. It does both prank and deal combined.

🔹.gas-snapshot

forge snapshot -m testWithdrawFromMultipleFunders

It's going to create this file called gas snapshot for us and tell us exactly how much gas this single test costs.

🔹.vm.txGasPrice

//Act 
uint256 public constant GAS_PRICE = 1;

uint256 gasStart = gasleft(); //1000
vm.txGasPrice(GAS_PRICE); 
vm.prank(fundMe.getowner()); //c: 200
fundMe.withdraw(); //should have spent gas?

uint256 gasEnd = gasleft(); //800
uint256 gasUsed = (gasStart -gasEnd) * tx.gasprice;
console.log(gasUsed);

when you're working with Anvil the gas price actually defaults to zero(whether forked or not).
gas left function is a built-in function in solidity it tells you how much gas is left in your transaction call.
tx. gas price is built-in to solidity which tells you the current gas price

🔹.Storage

for array it does have a storage slot for the length, for mappings it does have a storage spot as well similar to array, but it's just blank intentionally so that solidity knows ah okay there is a mapping here.

cast storage ADDRESS <slot index>

🔹.integration tests

integration tests are when you test a lot of your interactions and combinations of systems.
is going to be testing all of our deploy scripts and how all of our contracts interact with each other.
At FundMeTest.s.sol we tested funding and withdrawing, but we didn't test funding and withdrawing using the methods that we're actually going to use to do that when we actually call funds and withdraws we're do it with Forge script.
integration tests is going to have a programmatic way to do it with Forge script so that we can have a reproducible way to actually interact with fund and withdraw.it simulated real user interaction.

🔹.get_most_recent_deployment

    function run() external {
        address mostRecentlyDeployed = DevOpsTools.get_most_recent_deployment("FundMe", block.chainid);
        fundFundMe(mostRecentlyDeployed);
    }

Has this devops tool to get the most recent deployment that we can use to get the most recently deployed version of a contract, this way we don't have to pass the fundme contract address that we want to work with every single time.(because when we run “forge script”, function run() is must implemented in our script).

📌 sum & F:

Today, I learned a lot about foundry testing, such as mock and integration. Although Patrick's tutorial only watched 1 and a half hours of video, I felt that I learned so much today that I gave up watching the tutorial tonight. Instead, I will try to run what I learned today in my own vscode and finally pass all the tests.

lesson 7-9

16 Feb:

📌 harvest:

🔹.window.ethereum

if (typeof window.ethereum !== "undefined") {
    const provider = new ethers.BrowserProvider(window.ethereum)
    await provider.send('eth_requestAccounts', [])
  } else {
    withdrawButton.innerHTML = "Please install MetaMask"
  }

It's this window.ethereum JavaScript object that these websites interact with to send transactions to our metamask.

🔹.function selectors

cast sig "fund()" 
0xb60d4288
# this is the function selector

solidity functions get transformed into this thing called a function selector， when calling this fund function is it converts it to its function selector

🔹.Solidity Layout

Layout of Contract:
version
imports
errors
interfaces, libraries, contracts
Type declarations
State variables
Events
Modifiers
Functions
Layout of Functions:
constructor
receive function (if exists)
fallback function (if exists)
external
public
internal
private
view & pure functions

🔹.custom error

// require(msg. value >= i_entranceFee, "Not enough ETH sent!");
// 0.8.26 :
// require(msg. value >= i_entranceFee, SendMoreToEnterRaffle());
if (msg. value < i_entranceFee) {
    revert Raffle_SendMoreToEnterRaffle();
}

The last is the most gas efficient out of all these methodologies.

🔹.payable addrass

address public notPayableAddress;
address payable public payableAddress;
// send ETH to address and it's not payable, the transaction will fail
// notPayableAddress.transfer(1 ether);
payable(notPayableAddress).transfer(1 ether);

which can receive ETH ?

address : no
address payable : yes
contract（no receive or fallback) : no
contract(have receive()) : yes

🔹.event

(Indexed Parameters = Topics) we can have up to three indexed parameters. Topics are searchable.

event storedNumber(
    uint256 indexed oldNumber,
    uint256 indexed newNumber, 
    uint256 addedNumber, 
    address sender
};

emit storedNumber(
    favoriteNumber,
    favoriteNumber,
    favoriteNumber + favoriteNumber,
    msg.sender
);

whenever we update something in storage and this rule of thumb is going to always be emitting an event whenever we update a storage variable. the two main reasons that work with events:

Makes migration easier : it can be very difficult to move all the storage to the new contract.
Makes front end "indexing" easier.

🔹.block.timestamp
it's going to be the current approximate time of according to the blockchain.

📌 sum & F:

Today I reviewed the Foundry Fund Me code and uploaded it to GitHub, watched Patrick demonstrate metamask's interaction with the site, and pulled the code and tried it out myself. Finally, start learning Smart Contract Lottery.

lesson 9

17 Feb:

📌 harvest:

🔹.verifiable Randomness function (vrf)

    function pickWinner() external {
        // Check to see if enough time has passed
        if ((block.timestamp - s_lastTimeStamp) < i_interval) {
            revert();
        }
        // Fill in parameter
        VRFV2PlusClient.RandomWordsRequest memory request = VRFV2PlusClient.RandomWordsRequest({
            keyHash: i_keyHash,
            subId: i_subscriptionId,
            requestConfirmations: REQUEST_CONFIRMATIONS,
            callbackGasLimit: i_callbackGasLimit,
            numWords: NUM_WORDS,
            extraArgs: VRFV2PlusClient._argsToBytes(
                // Set nativePayment to true to pay for VRF requests with Sepolia ETH instead of LINK
                VRFV2PlusClient.ExtraArgsV1({nativePayment: false})
            )
        });
        // Request Chainlink VRF Oracle.
        // The oracle submits random numbers and proofs to the Chainlink VRF Coordinator contract.
        // Chainlink VRF generates the unique identifier requestId for this request
        uint256 requestId = s_vrfCoordinator.requestRandomWords(request);

    }

    // The Chainlink VRF Coordinator calls the rawFulfillRandomWords of your contract after the oracle returns the data.
    function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) internal virtual override {}

process:

Fill in parameter.
Request Chainlink VRF Oracle.
The oracle submits random numbers and proofs to the Chainlink VRF Coordinator contract.
Chainlink VRF generates the unique identifier requestId for this request
The Chainlink VRF Coordinator calls the rawFulfillRandomWords of your contract after the oracle returns the data.

🔹.safety design

function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) internal virtual;
function rawFulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) external {
    if (msg.sender != address(s_vrfCoordinator)) {
        revert OnlyCoordinatorCanFulfill(msg.sender, address(s_vrfCoordinator));
    }
    fulfillRandomWords(requestId, randomWords);
}

rawFulfillRandomWords ensure the separation of security checks and business logic.
fulfillRandomWords are internal and cannot be called directly from the outside.Outsiders can only call rawFulfillRandomWords that have been checked for security.
Why not just allow subcontracts to implement rawFulfillRandomWords directly? The subcontract may forget or intentionally delete msg.sender validation.

🔹.inherit Constructor

// contract VRFConsumerBaseV2Plus:
  IVRFCoordinatorV2Plus public s_vrfCoordinator;

  constructor(address _vrfCoordinator) ConfirmedOwner(msg.sender) {
    if (_vrfCoordinator == address(0)) {
      revert ZeroAddress();
    }
    s_vrfCoordinator = IVRFCoordinatorV2Plus(_vrfCoordinator);
  }
// contract Raffle 
contract Raffle is VRFConsumerBaseV2Plus{
    constructor(
        uint256 entranceFee,
        uint256 interval,
        address vrfCoordinator
    ) VRFConsumerBaseV2Plus(vrfCoordinator) {
        i_entranceFee = entranceFee;
        i_interval = interval;
        s_lastTimeStamp = block.timestamp;
    }
     uint256 requestId = s_vrfCoordinator.requestRandomWords(request);
}

if we we use the Constructor of the inherited contract then we need to add that inherited contract's Constructor. We're inheriting so we get access to these State variables too.

🔹.abstract contract

function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) internal virtual;
// implement:
function fulfillRandomWords(uint256, /* requestId */ uint256[] calldata randomWords) internal override {}

contract abstract contracts can have both undefined functions [virtual] and defined functions. inherit an abstract contract must Implement functions that it undefined [override].

🔹.Enum

    enum RaffleState {
        OPEN,    // 0
        CALCULATING    // 1
    }
    s_raffleState = RaffleState.OPEN;

uint256(s_raffleState);

keep track of the raffle and figure out are we in the middle of calculating the winner.
each one of these parameters inside of enum get mapped to a un 256.

🔹🔹🔹.CEI Patten

keep checks effects interactions in mind that will help you just be safer by default (defend against re-entrancy attacks).

Checks (conditionals)
Effect (Internal Contract State and emit Event)
Interactions (External Contract Interactions)

🔹.calldata

calldata is part of the EVM transaction calldata and is stored directly in the input data of the transaction call, not in memory within Solidity code.
The calldata variable is immutable and is used only as an argument to external functions, in order to save gas and avoid copying data to memory.
internal functions cannot use calldata, only memory.

🔹.pure

function hashData(string memory data) public pure returns (bytes32) {
    return keccak256(abi.encodePacked(data));  // Calculates the hash without modifying the contract state
}

pure is suitable for:

✔ Pure mathematical operations
✔ Handle strings, arrays, and do not access contract storage
✔ Calculate the hash value
✔ Check input data

cannot be used pure:

❌ Access state variables
❌ Modifies the stored variable
❌ Access global variables such as msg.sender, block.timestamp
❌ calls a function of view or non-pure

🔹.when use memory&calldata

// The base type uint256 is used as the argument and return value and does not require a storage location
function add(uint256 a, uint256 b) public pure returns (uint256) {
    return a + b;
}

// Passing the string argument must specify either memory or calldata
function greet(string memory name) public pure returns (string memory) {
    return string(abi.encodePacked("Hello, ", name, "!"));
}

when require a storage location in parameter and return？

uint256、bool、address❌
string、struct、array ✔

🔹.Mock & Fork
Whether VRF contract exists? Mock is needed? VRF predictor responds?

Local Anvil : ❌ ✔ ❌
Forked Sepolia : ✔ ✔ ❌

On Forked Sepolia, even with a real VRF contract, the oracle won't respond to Fork network requests, so you'll still need Mock.

🔹.Test Event

function testEnteringRaffleEmitsEvent() public {
    // Arrange
    vm.prank(PLAYER);
    // Act
    vm.expectEmit(true, false, false, false, address(raffle));
    emit RaffleEntered(address(PLAYER));
    // Assert
    raffle.enterRaffle{value: entranceFee}();
}

It's the first index parameter, so we are going to say true, there are no additional index parameters (up to 3), and there are also no non-indexed parameters, so we're going to say false, raffle address is actually going to be emitting.
We have to copy paste our events into the top of our test.

🔹.warp & roll

// set time passed
vm.warp(block. timestamp + interval + 1); 
// set the blocks increased.
vm.roll(block. number + 1);

Time has passed and the blocks have actually increased.

📌 sum & F:

Today I learned vrf, knowing how to get a random number and implemented it basically. Then make a HelperConfig.s.sol to set config for different networks. Starting in the evening, studying for the Raffle Test. I had the pleasure of reviewing a lot of solidity's basic syntax while implementing Raffle.

lesson 9

18 Feb:

📌 harvest:

🔹.function selector databases

function signature or function selector
openchain.xyz/signatu res

🔹.import

// deploy VRFCoordinatorV2_5Mock contract
vm.startBroadcast();
VRFCoordinatorV2_5Mock vrfCoordinator = new VRFCoordinatorV2_5Mock(MOCK_BASE_FEE, MOCK_GAS_PRICE_LINK, MOCK_WEI_PER_UINT_LINK);
vm.stopBroadcast();

// invoke VRFCoordinatorV2_5Mock function in another contract
import {VRFCoordinatorV2_5Mock}
VRFCoordinatorV2_5Mock(vrfCoordinator).createSubscription();

"import" only imports the ABI of the contract.
The cast VRFCoordinatorV2_5Mock(vrfCoordinator) simply tells the compiler that the address matches the ABI, Solidity will call the function on chain use the ABI.

🔹.Create Subscription

mock VRFCoordinatorV2_5Mock.sol form chainlink.
Create a helperconfig.s.sol to configure NetworkConfig for sepolia and deploy a mock VRF contract for local chain.
Create an interactions.s.sol to implement the interaction logic speciality.

function createSubscription(
    address vrfCoordinator
) public returns (uint256, address) {
    vm.startBroadcast();
    uint256 subId = VRFCoordinatorV2_5Mock(vrfCoordinator)
        .createSubscription();
    vm.stopBroadcast();

    return (subId, vrfCoordinator);
}

new CreateSubscription in DeployRaffle.s.sol:

if (config.subscriptionId == 0) {
    // create subscription
    CreateSubscription createSubscription = new CreateSubscription();
    (config.subscriptionId, config.vrfCoordinator) =
        createSubscription.createSubscription(config.vrfCoordinator);
}

🔹.Fund Subscription

mock LinkToken.sol form chainlink.
import ERC20.sol:

forge install transmissions11/solmate@v6 --no-commit

add remappings =['@solmate=lib/solmate/src/'] in foundry.toml.

import {ERC20} from "@solmate/tokens/ERC20.sol";

add mint function:

function mint(address to, uint256 value) public {
    _mint(to, value);
}

deploy LinkToken in HelperConfig.s.sol, and use it on Anvil NetworkConfig.
create contract FundSubscription in interactions.s.sol and write a fundSubscription to fund for subscriptionId:

function fundSubscription(
        address vrfCoordinator,
        uint256 subscriptionId,
        address linkToken
    ) public {

        if (block.chainid == LOCAL_CHAIN_ID) {
            vm.startBroadcast();
            // this fundSubscription is provide by VRFCoordinatorV2_5Mock.sol specially
            VRFCoordinatorV2_5Mock(vrfCoordinator).fundSubscription(
                subscriptionId,
                FUND_AMOUNT
            );
            vm.stopBroadcast();
        } else {
            vm.startBroadcast();
            LinkToken(linkToken).transferAndCall(
                vrfCoordinator,
                FUND_AMOUNT,
                abi.encode(subscriptionId)
            );
            vm.stopBroadcast();
        }
    }
}

new FundSubscription and fund subscriptionId in DeployRaffle.s.sol

//  Found it!
FundSubscription fundSubscription = new FundSubscription();
fundSubscription.fundSubscription(
    config.vrfCoordinator, config.subscriptionId, config.link
);

use FundSubscription to fund on sepolia:

forge script script/Interactions.s.sol:FundSubscription --rpc-url https://eth-sepolia.g.alchemy.com/v2/xxx --private-key xxxx --broadcast

🔹.Add Consumner

forge install Cyfrin/foundry-devops --no-commit

address mostRecentlyDeployed = DevOpsTools. get_most_recent_deployment("Raffle", block. chainid);

Create contract AddConsumer in interactions.s.sol and write an addConsumer to add the most recent deployment contract Raffle for the Consumer.

function addConsumer(address contractToAddToVrf, address vrfCoordinator, uint256 subId) public {
    console.log("Adding consumer contract: ", contractToAddToVrf);
    console.log("To vrfCoordinator: ", vrfCoordinator);
    console.log("On ChainId: ", block.chainid);
    vm.startBroadcast();
    VRFCoordinatorV2_5Mock(vrfCoordinator).addConsumer(subId, contractToAddToVrf);
    vm.stopBroadcast();
}

new AddConsumer in DeployRaffle.s.sol:

AddConsumer addConsumer = new AddConsumer();
//have broadcast in AddConsumer
addConsumer.addConsumer(address(raffle), config. vrfCoordinator, config. subscriptionId);

🔹.coverage report----t=65086

forge coverage --report debug > coverage.txt

🔹.recordLogs

vm.recordLogs();
raffle.performUpkeep("");
Vm.Log[] memory entries = vm.getRecordedLogs();
bytes32 requestId = entries[1].topics[1];

whatever events whatever logs are emitted by this performupkeep
function, keep track of those and stick them into an array.

🔹.fuzz testing

[fuzz]
runs = 1000
# testFulfillrandomWordsCanOnlyBeCalledAfterPerformUpkeep(uint256) (runs: 1000)

Test try to break the code.

📌 sum & F:

Today I followed Patrick done the Subscription create and found, add Consumner. Found subscription on sepolia. Do some tests to the raffle contract.

lesson 9-10

19 Feb:

📌 harvest:

🔹.About test fulfillRandomWords

// vrfCoordinator is the deploy address of vrfCoordinatorV2_5Mock in HelperConfig.s.sol
VRFCoordinatorV2_5Mock(vrfCoordinator).fulfillRandomWords(uint256(requestId), address(raffle));

Why can this invoke the fulfillRandomWords at Raffle?

// VRFCoordinatorV2_5Mock.sol :
   bytes memory callReq = abi.encodeWithSelector(v.rawFulfillRandomWords.selector, _requestId, _words);
    s_config.reentrancyLock = true;
    // solhint-disable-next-line avoid-low-level-calls, no-unused-vars
    (bool success, ) = _consumer.call{gas: req.callbackGasLimit}(callReq);

VRFCoordinatorV2_5Mock is just an intermediary that triggers Raffle's fulfillRandomWords method with a low-level call

When testing the fulfillRandomWords, why don't invoke fulfillRandomWords at Raffle directly ?

fulfillRandomWords is internal.
fulfillRandomWords is the callback function, which must be called by

🔹.default caller address

// lib > forge-std > src > Base.sol
abstract contract CommonBase {

//Default address for tx. origin and msg. sender, 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38
address internal constant DEFAULT_SENDER = address(uint160(uint256(keccak256("foundry default caller"))));
...
}

whenever Foundry needs to use some type of address to send some stuff this is the address that it's going to use.So in helperconfig we can set the local network default account to being this.

🔹.Fork tests

    // fulfillRandomWords is only can be called by vrf, so at fork network we skip it
    modifier skipFork() {
        if (block.chainid != 31337) {
            return;
        }
        _;
    }

The actual chain link coordinator have access controls and only let the chain link nodes call fulfillrandomwords.
we're going to skip those two that don't make sense for us to to Fork.

🔹.startBroadcast(address)

function startBroadcast() external; 
function startBroadcast(address who) external; 
function startBroadcast(uint256 privatekey) external;

// Use the address to broadcast things.
vm.startBroadcast(config.account);
Raffle raffle = new Raffle(
);
vm.stopBroadcast();

🔹.stages, scope and type of tests

unit
integrations
forked
staging <- run tests on a mainnet or testnet
fuzzing
stateful fuzz
stateless fuzz
formal verification <- turn your code into mathematical proofs

🔹.verify-contract

forge verify-contract 0xA7Deda6D9a52A43E39C655453C2F7b3a203Da671 src/Raffle. sol: Raffle --etherscan-api-key $ETHERSCAN_API_KEY --rpc-url $SEPOLIA_RPC_URL --show-standard-json-input > json.json

if for some reason your code doesn't automatically update your code doesn't automatically verify this is how to do. --> [t=69099]

🔹.ERC20Token

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract OurToken is ERC20 {
    constructor(uint256 initialSupply) ERC20("OurToken", "OT") {
        _mint(msg.sender, initialSupply);
    }
}

🔹.transferFrom

function _spendAllowance(
    address owner, 
    address spender, 
    uint256 amount
) internal virtual {
    // Gets the amount of spender currently authorized by the owner
    // allowance is record by mapping(address => mapping(address => uint256)) _allowances;
    uint256 currentAllowance = allowance(owner, spender);  
    require(currentAllowance >= amount, "ERC20: insufficient allowance");

    unchecked {
        if (currentAllowance != type(uint256).max) {
            // Renewal of authorization
            _approve(owner, spender, currentAllowance - amount);
        }
    }
}

function transferFrom(
    address from,
    address to,
    uint256 amount
) public virtual override returns (bool) {
    _spendAllowance(from, msg.sender, amount);  // Consumption authorization
    _transfer(from, to, amount);
    return true;
}

transferFrom() use _spendAllowance() to check and consume the authorized amount, use _transfer() to do transfer.

📌 sum & F:

Finished a learning raffle course, passed all the tests and deployed to sepolia, pushed to GitHub. learned Foundry ERC20s, did some tests with the help of AI.Drive into Advanced Foundry.

lesson 11

20 Feb:

📌 harvest:

🔹.IPFS

IPFS drastically different than a blockchain is they din't have execution it's just decentralized storage.
Unlike a blockchain where every single node in a blockchain is going to have a copy of the entire blockchain ipfs nodes get to optionally choose which data they want to pin.
Pinata is an IPFS third-party hosting service, we can upload files to IPFS without having to run IPFS nodes.
Filecoin and arweave are two decentralized storage platforms that we could alternatively use instead of ipfs.

🔹.compare stirngs

string memory expectedName = "Dogie"; 
string memory actualName = basicNft.name();
//assert(expectedName == actualName); assert(keccak256(abi.encodePacked(expectedName)) == keccak256(abi.encodePacked(actualName));

Compare the two of them we would just compare the hashes instead of looping through the array.
we can convert our strings to bytes and convert the bytes to a byes 32 and we just compare the hashes of both of those.

🔹.SVG NFT

Store NFT in Scalable Vector Graphics (SVG) format directly in a smart contract, never lose.
NFT has the ability to change dynamically.

🔹.differences between a unit test and an integration test-->[t=78423]

Unit : Testing a specific part of a contract.(only test FundMe.sol)
Integration : Testing how our contracts works with each other.(test combined FundMe.sol with deployFundMe.s.sol)

📌 sum & F:

Learned ERC721, IPFS storage for NFT (test on sepolia), SVG format NFT for full on-chain storage (test on anvil, sepolia is insufficient funds for gas).spent some time on unit testing.

lesson 11

21 Feb:

📌 harvest:

🔹.encode->[t=79079]

abi.encode("string")
bi.encodePacked("string")
bytes("string")

abi.encodePacked() it's the encode function but it compresses stuff if we wanted to encode some string but we wanted to save space and we didn't need the perfect low-level binary of it.
EncodePacked and bytes get the same result.
Dncode:

abi.decode(encodeString(), (string))
string(EncodePacked()

🔹.call

// Example Function Selector:
0xa9059cbb 
// Example Function Signature:
"transfer(address, uint256)"

The Function Selector for each function is the hash of its first 4 bytes. bytes4(keccak256(bytes("transfer(address,uint256)")));

    // use selector and calldata to call a function
    function callTransferFunctionDirectly(address someAddress, uint256 amount) public returns (bytes4, bool) {
        (bool success, bytes memory returnData) = address(this).call(
            // getDataToCallTransfer(someAddress, amount);
            abi.encodeWithSelector(getSelectorOne(), someAddress, amount)
        );
        return (bytes4(returnData), success);
    }

call calls only the methods of the target contract based on the ABI encoding (Function Selector + Arguments Encoding).

🔹.stable coin

Classification of stable coin

Algorithmic stable coins use some sort of autonomous permissionless code to Mint and burn tokens whereas a govern stable coin have some human interaction that mints and burns the coins and keeps them stable.

Classification of collateral:

exogenous collateral is collateral that originates from outside the protocol
endogenous collateral originates from inside the protocol
one of the easier ways to Define what type of collateral protocol is using is to ask this question if the stable coin fails does the underlying collateral also fail if yes it's endogenous if no it's exogenous. exogenously collateralized stable coins are typically over collateralized.
was the collateral created with the sole purpose of being collateral or does the protocol own the issuance of the underlying collateral if the answer is yes to either one of those then it's endogenous collateral

RAI:

so protocols like RAI have come a long way to do some type of hybrid between endogenous and exogenously collateralized stable coin.

who is minting these stable coins and pay Stability Fee?

people who want to own more eth. (maximize your position)
put eth into one of these stable coin protocols minted stable coin and then sell the stable coin for more eth.

📌 sum & F:

Today I learned abi.encode,call function with Selector, and have a basic understanding of stablecoins.Start to learn the building of stablecoins project.

lesson 12

22 Feb:

📌 harvest:

🔹.address cast

// ✅ tokenCollateralAddress inherit IERC20
IERC20(tokenCollateralAddress)  
// ❌ tokenCollateralAddress inherit ERC20, But the contract  of tokenCollateralAddress itself is not ERC20
ERC20(tokenCollateralAddress)   
// ✅ The contract  of vrfCoordinator itself is VRFCoordinatorV2_5Mock, vrfCoordinator address points to a VRFCoordinatorV2_5Mock contract that has been deployed
VRFCoordinatorV2_5Mock(vrfCoordinator)

Convert the address to a contract interface.

🔹.Reentrant

function withdraw(uint256 amount) external {
    require(balance[msg.sender] >= amount, "Not enough balance"); 
    // ⚠️ A reentrant attack may occur here
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
    balance[msg.sender] -= amount; 
}

    // contract Attacker, call withdraw again when ETH is received.
    receive() external payable {
        if (address(target).balance > 0) {
            target.withdraw(1 ether);
        }

// use ReentrancyGuard
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract SecureContract is ReentrancyGuard {
    function withdraw(uint256 amount) external nonReentrant {}
}

nonReentrant is required for any function that involves an external contract interaction and may cause a change in funds.
If the contract changes its state before invoking the external contract, it can effectively prevent reentrant attacks.

🔹.burnDsc

function _burnDsc(uint256 amountDscToBurn, address onBehalfOf, address dscFrom) private {
    s_DSCMinted[onBehalfOf] -= amountDscToBurn;
    // user approve this,this invoke the transferFrom of dsc through ABI to transfer token to this
    // because only the token holder can call the burn function
    bool success = i_dsc.transferFrom(dscFrom, address(this), amountDscToBurn);
    // This conditional is hypothetically unreachable
    if (!success) {
        revert DSCEngine__TransferFailed();
    }
    // now the token owner is this ,this can call the burn
    i_dsc.burn(amountDscToBurn);
}

user approve token to DSCEngine, DSCEngine invoke transferFrom to transfer token to itself, it own the token and can call the burn.

📌 sum & F:

Today I basically understand some of the implementation logic of DSCEngine, such as depositCollateral, MintDsc, redeemCollateral, burnDsc, learned how to implement them.

lesson 12

23 Feb:

📌 harvest:

🔹.Fuzz Testing

Foundry Fuzzing = Stateless fuzzing
Foundry Invariant = Stateful fuzzing
Fuzz Testing: supply random data to your system in an attempt to break it.
Invariant: Property of our system that should always hold.
Stateless fuzzing & statefull fuzzing:

stateful fuzzing is where the final state of your previous fuzz run is the starting state of the next fuzz run.
Statefull fuzzing is when you give random data and random function calls to a system to see if it breaks.

🔹.Open Invariant Testing

fail_on_revert = false

contract OpenInvariantsTest is StdInvariant, Test {
function setUp() external {
    deployer = new DeployDSC();
    (dsc, dsce, config) = deployer.run();
    (_, _, weth, wbtc,) = config.activeNetworkConfig();
    targetContract(address(dsce));
}
function invariant_protocolMustHaveMoreValueThanTotalSupply() public view{...}
}

At competitive audit a lot of times will have revert on false, so you can write up invarant test quickly with mini handlers.
But the open invarant have major flaw where it's probably making a bunch of silly calls, maybe it's just trying to deposit collateral but it keeps using random collateral addresses that don't make any sense. So this is great for very small contracts.

🔹.Handler

contract tHandler is Test {

constructor(DSCEngine _dscEngine, DecentralizedStableCoin _dsc) {...}

function depositCollateral(uint256 collateralSeed, uint256 amountCollateral) public {
    ERC20Mock collateral = _getCollateralFromSeed(collateralSeed);
    amountCollateral = bound(amountCollateral, 1, MAX_DEPOSIT_SIZE);

    vm.startPrank(msg.sender);
    collateral.mint(msg.sender, amountCollateral);
    collateral.approve(address(dsce), amountCollateral);
    dsce.depositCollateral(address(collateral), amountCollateral);
    vm.stopPrank();
}

/// Helper Functions
function _getCollateralFromSeed(uint256 collateralSeed) private view returns (ERC20Mock) {
    if (collateralSeed % 2 == 0) {
        return weth;
    } else {
        return wbtc;
    }
}

the downside of always aiming for revert to be ture, is that if you make your Handler too specific, maybe you'll actually narrow it down and remove edge cases that would break the system that are valid right.

📌 sum & F:

Today, I finished learning the content of the DSCEngine contract, this contract is the most complex that I have learned at present, I just understand the code logic, and I am not familiar with it. Trying to write a few unit tests that afternoon didn't go well either, I will slowly write the rest in the future. Start learn Advanced Testing in the evening.

lesson 12

24 Feb:

📌 harvest:

🔹.ghost variable

    uint256 public timesMintIsCalled;
    // address[] public usersWithCollateralDeposited;
function mintDsc(uint256 amount/*, uint256 addressSeed*/) public {
    // here's the problem, you have to restrict the sender to who has deposited collateral.
    // address sender = usersWithCollateralDeposited[addressSeed % usersWithCollateralDeposited.length];
    (uint256 totalDscMinted, uint256 collateralValueInUsd) = dsce.getAccountInformation(msg.sender);

    int256 maxDscToMint = (int256(collateralValueInUsd) / 2) - int256(totalDscMinted);

    if (maxDscToMint < 0) {
        return;
    }
    amount = bound(amount, 0, uint256(maxDscToMint));
    if (amount == 0) {
        return;
    }
    vm.startPrank(msg.sender);
    dsce.mintDsc(amount);
    vm.stopPrank();

    timesMintIsCalled++;
}

it must be because one of these returns is hitting and it's not finishing this call.
we can use called ghost variable to track this.
we could keep moving this up to figure out where it's actually being called and to continue to debug this.

🔹.ContinueOnRevert
ContinueOnRevert is going to be the quicker looser test.
FailOnRevert is going to make sure that every single transaction that you run your invariant test is going to pass.

🔹.use Oracles in a safer way

library OracleLib {
    error OracleLib__StalePrice();

    uint256 private constant TIMEOUT = 3 hours;

    function staleCheckLatestRoundData(AggregatorV3Interface chainlinkFeed)
        public
        view
        returns (uint80, int256, uint256, uint256, uint80)
    {...}
}
using OracleLib for AggregatorV3Interface;

We should add some checks in our code to make sure that if oracle price feed breaks or if something in here breaks our system isn't broken.
We want to check to make sure that these prices aren't stale(whether updating every 3600 seconds).
If a price is stale, the function will revert, and render the DSCEngine unusable.
We'll have this stale price check be on AggregatorV3Interface.

📌 sum & F:

Completed the stablecoin course, but lacked practice. In this process, I not only learned how to implement the contract of stablecoin, but more importantly, I learned a lot of testing skills, which need to be practiced in the future to master.

lesson 13

25 Feb:

📌 harvest:

🔹.Merkle Proof

"inputs": [
    "0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D",
    "25000000000000000000"
],
"proof": [
    "0x0fd7c981d39bece61f7499702bf59b3114a90e66b51ba2c53abdf7b62986c00a",
    "0xe5ebd1e1b5a5478a944ecab36a9a954ac3b6b8216875f6524caa7a1d87096576"
],
"root": "0xaa5d581231e596618465a56aa0f5870ba6e20785fe436d5bfb82b08662ccc7c4",
"leaf": "0xd1445c931158119b00449ffcac3c947d028c0c359c34a6646d95962b3b55c6ad"

The data in proof is the sibling of the parent node and is used to reproduce the hash path. root is the same.

Merkel trees is a cryptographic data structure using hashes.
Merkel proofs allow us to prove that some piece of data that we want is in fact in a group of data.(to prove you're part of a group)
often used in airdrops and also verifying State changes in smart contracts and in rollups.

🔹.SafeERC20

using SafeERC20 for IERC20;

i_airdropToken.safeTransfer(account, amount);

SafeERC20 is alibrary, it wrappers around ERC20 operations that throw on failure.if we can't for some reason send tokens to the address, it'll handle that for us.

🔹.signing and verifying signatures

EIP 191
Ox19 <1 byte version> <version specific data> <data to sign>

EIP 712(version Ox01)
Ox19 0x01 <domainSeparator> <hashStruct(message)>
<domainSeparator> = <hashStruct(eip712Domain)>
struct eip712Domain = {
string name
string version
uint256 chainld
address verifyingContract
bytes32 salt }

function _buildDomainSeparator() private view returns (bytes32) {
    return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
    }

EIP–712 is version 0x01 of EIP–191, it defines a standard of structured data signature，which solves the security and readability problems of signing raw data directly.
EIP-191 standardizes what the sign data should look like.
EIP-712 standardizes the format of the version specific data and the data to sign.

📌 sum & F:

Today I learn about merkle proof, then use it to airdrop tokens to users who are eligible.

lesson 13

26 Feb:

📌 harvest:

🔹.ECDSA Singnatures

ECDSA is used to:
Generate key pairs
Create Signatures
Verify Signatures

The specific curve used in ecdsa in ethereum is the setp256K1 curve.

The Elliptic Curve Digital Signature Algorithm (ECDSA)

🔹.EIP-4844(Blob)->[t=106061]

Ethereum's Proto-Danksharding

Blobs are a new transaction type that allows us to store data on-chain for a Short period of time.
We can't access the data itself, but we can aocess a hash of the data with the new BLOBHASH opcode.
Blobs were added because rollups wanted a cheaper way to validate transactions.

🔹.test claim

bytes32 digest = airdrop.getMessageHash(user, amountToCollect);

// get the signature
(uint8 v, bytes32 r, bytes32 s) = vm.sign(userPrivKey, digest);

// gasPayer claims the airdrop for the user
vm.prank(gasPayer);
airdrop.claim(user, amountToCollect, proof, v, r, s);

🔹.use cast to sign msghash

cast wallet sign --no-hash MessageHash --private-key xxx
0x04209f8dfd0ef06724e83d623207ba8c33b6690e08772f8887a4eaf9a66b9182188938adea374fa542ad5ddde24bdc981f5e26a628e65fb425a68db8a938f6761c

when you use cast wallet sign you create one one single signature however what we need is v r s broken up individually.

--no-hash: The message has already been hashed in the getMessageHash function.

🔹.Split Signature

function splitSignature(bytes memory sig) internal pure returns (uint8 v, bytes32 r, bytes32 s) {
    if (sig.length != 65) {
        revert __SplitSignatureScript__InvalidSignatureLength();
    }

    assembly {
        r := mload(add(sig, 32))
        s := mload(add(sig, 64))
        v := byte(0, mload(add(sig, 96)))
    }
}

🔹.tryRecover

// receiving a hash of the original message
function tryRecover(
    bytes32 hash,
    bytes memory signature
) internal pure returns (address recovered, RecoverError err, bytes32 errArg)

// receives the `r` and `vs` short-signature fields separately.
function tryRecover(
    bytes32 hash,
    uint8 v,
    bytes32 r,
    bytes32 s
) internal pure returns (address recovered, RecoverError err, bytes32 errArg)

It is normal to have more than one tryRecover in ECDSA.sol because they are Overloading.

📌 sum & F:

Today you learned about signing messages and verifying signatures through the program. Why do I get a different MessageHash from unit tests and cast call to getMessageHash with the same input parameters and the same MerkleAirdrop contract address? I can't get the same MessageHash no matter how I test it.

lesson 13

27 Feb:

📌 practice:

🔹.test all on Anvil and sepolia

# (0) 0xcd7559aab753f89e17d50b38712e1043bbbaccca (airdrop eligible)
# (1) 0xfaa00ae9e0b9d5b4e25ce7c335cd1ce76969db63 (gas fee payer)

# choose a address to be the airdrop claimer which is allowed to get the airdrop and put it into Interact.s.sol.

# use the MakeMerkle.s.sol to recreate the Merkle Proof and root for this address, then put them into DeployMerkleAirdrop.s.sol and Interact.s.sol.

# use DeployMerkleAirdrop.s.sol to deploy the two contract, mint token and transfer it to MerkleAirdrop.
forge script script/DeployMerkleAirdrop.s.sol:DeployMerkleAirdrop --rpc-url https://eth-sepolia.g.alchemy.com/v2/xxx --private-key xxx --broadcast -vvvv
# == Anvil Return ==
# 0: contract MerkleAirdrop 0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82
# 1: contract BagelToken 0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0

# == Sepolia Return ==
# 0: contract MerkleAirdrop 0xa571518aE1b329f7E9f968770e3A046bB6AAaad0
# 1: contract BagelToken 0x06C96Bf66aBD9F767EE10A3E807E5a1a0Eb72F89

# When an accident occurs during deployment, it not do mint and transfer, you can manually make up for it in this way
cast send 0x06C96Bf66aBD9F767EE10A3E807E5a1a0Eb72F89 "mint(address,uint256)" 0xa571518aE1b329f7E9f968770e3A046bB6AAaad0 100000000000000000000 --rpc-url https://eth-sepolia.g.alchemy.com/v2/xxx --private-key xxx

# call the getMessageHash to get MessageHash
cast call 0xa571518aE1b329f7E9f968770e3A046bB6AAaad0 "getMessageHash(address,uint256)" 0xcd7559aab753f89e17d50b38712e1043bbbaccca 25000000000000000000 --rpc-url https://eth-sepolia.g.alchemy.com/v2/xxx

# use privatekey to sign the MessageHash
cast wallet sign --no-hash 0xd448c2673189f6ff30d6f96d9f7ed07dc3fafbac96bbba5a44a059db35e4dfaa --private-key xxx

# put the signture into Interact.s.sol
Use the rock to get boob to help jack get the airdrop

# use Interact.s.sol to get (1) to claim airdrop for (0)
forge script script/Interact.s.sol:ClaimAirdrop --rpc-url https://eth-sepolia.g.alchemy.com/v2/xxx --private-key xxx --broadcast -vv

# check the airdrop token has been claimed
cast call 0x06C96Bf66aBD9F767EE10A3E807E5a1a0Eb72F89 "balanceOf(address)" 0xcd7559aab753f89e17d50b38712e1043bbbaccca --rpc-url https://eth-sepolia.g.alchemy.com/v2/xxx
cast --to-dec 0x0000000000000000000000000000000000000000000000015af1d78b58c40000

📌 sum & F:

Learned Merkle Trees and Signatures through a ClaimAirdrop contract, Basically know the application of Merkle Trees and how to sign the message and verify the signature in smart contract. Finally, test the whole process on the test network.

lesson 14

28 Feb:

📌 harvest:

🔹.way of upgrade smart contracts

1.not really upgrading method or the parameterization method:

Can't add new storage
Can't add new logic

2.social Yeet method or the migration method:

People migrating and over into using this new one that the upgrade

Pros:

Truest to blockchain values
Easiest to audit

Cons:

Lot of work to convince users to move
Different addresses

3.Proxies

🔹.Proxy Terminology:

Whenever I want to upgrade I just deploy a new implementation contract and point my proxy to that new implementation. do contracts B's logic in contract A.
all my storage variables are going to be stored in the proxy contract and not in the implementation contract.

1.The Implementation Contract

Which has all our code of our protocol. When we upgrade, we launch a brand new implemenation contract.

2.The proxy contract.

Which points to which implementation is the "correct"one, and routes everyone's function calls to that contract

3.The user

They make calls to the proxy

4.The admin

This is the user (or group of users/voters) who upgrade to new implementation contracts.

🔹.Gotchas:

1.Storage Clashes

this means we can only append new storage variables in new implementation contracts and we can't reorder or change old ones.

2.Function Selector Clashes

there are two ways to avoid this:

transparent proxy pattern: in this methodology admins are only allowed to called admin functions and they can't call any functions in the implementation contract and users can only call functions in the implementation contract and not any admin contracts.
Universal Upgradeable Proxies (UUPS Smart Contract Proxy Pattern)

🔹.how upgrading actually works ->[t=110874]

allows us to borrow functions and then no matter whatever variables name in contract A, it only saves according to the storage slots location and the other thing that's interesting is that even if you don't have variables it'll still save to storage slots.

contract SmallProxy is Proxy {
    // This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1
    bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    function setImplementation(address newImplementation) public {
        assembly {
            sstore(_IMPLEMENTATION_SLOT, newImplementation)
        }
    }

    function _implementation() internal view override returns (address implementationAddress) {
        assembly {
            implementationAddress := sload(_IMPLEMENTATION_SLOT)
        }
    }

    // helper function
    function getDataToTransact(uint256 numberToUpdate) public pure returns (bytes memory) {
        return abi.encodeWithSignature("setValue(uint256)", numberToUpdate);
    }

    function readStorage() public view returns (uint256 valueAtStorageSlotZero) {
        assembly {
            valueAtStorageSlotZero := sload(0)
        }
    }
}

contract ImplementationA {
    uint256 public value;

    function setValue(uint256 newValue) public {
        value = newValue;
    }
}

The "Transact" button is used to manually send any calldata to the contract, simulating a call invoke.
But this contract has no setVule function, it will Trigger fallback() at the inherited Proxy contract and delegatecall logical contract.
The Proxy reads the ImplementationA address in the storage and uses the calldata to executes delegatecall and finally executes ImplementationA.setValue(777).

🔹.Implementation(logical) Contract Initialize

contract Logic is Initializable, UUPSUpgradeable, OwnableUpgradeable {
    constructor() {
        _disableInitializers();
    }

    function initialize() initializer public {
        Ownable_init(); //sets owner to: owner = msg. sender
        UUPSUpgradeable_init(); //to say this is a upps upgradable contract 
    }
}

Constructors are not used in Implementation Contract:

In Proxy mode, storage variables are stored in proxy contracts, not logical contracts.
However, if the logical contract has a constructor, its storage will only be initialized in its own storage space and cannot be stored in the Proxy contract.
So you should have the Proxy call initialize() of the logical contract to set the initial value after the proxy contract is deployed.

📌 sum & F:

The key of upgrade contract is to know the use of Initializable, OwnableUpgradeable and UUPSUpgradeable. Figure out the relationship between proxy contracts and logical contracts.

lesson 15

1 Mar:

📌 harvest:

🔹.smart contract account (SCA & AA account)

These alt-memepol nodes are going to deploy your contract for you it's going to always be routed through this EntryPoint.sol which is going to do something validation and then it's going to be routed to your smart contract account.
it's EntryPoint.sol that handles every single account abstraction user operations sent, all of these alt-memepol nodes calling this contract call this function called handleOps.
instead of sending a regular transaction object to the blockchain, those alt-mempool nodes will send a useroperation to the entrypoint Dos contract which will call handleOps() to call your contract and call the custom logic that you built in your validateUserOp().

eip-4337

🔹.create a MinimalAccount.sol

// @ztmy whenever we send a user operation(UserOp) to the entrypoint, it need to call this execute function to call the DAPP
// @ztmy the owner of this minimal account can be our EOA account(Direct call)  or it can be the entry point.
function execute(address dest, uint256 value, bytes calldata functionData) external requireFromEntryPointOrOwner {
    (bool success, bytes memory result) = dest.call{value: value}(functionData);
    if (!success) {
        revert MinimalAccount__CallFailed(result);
    }
}

// A signature is valid, if it's the MinimalAccount owner
// @ztmy this is the function that the entrypoint contract is going to be calling
function validateUserOp(PackedUserOperation calldata userOp, bytes32 userOpHash, uint256 missingAccountFunds)
    external
    requireFromEntryPoint
    returns (uint256 validationData)
{
    // @ztmy use userOp.signature to valid the userOpHash
    validationData = _validateSignature(userOp, userOpHash);
    // _validateNonce()
    _payPrefund(missingAccountFunds);
}

MinimalAccount.sol is a smart contract account, above are two core functions of it.

🔹.test direct call the execute

// @ztmy whenever we send a user operation(UserOp) to the entrypoint, it need to call this execute function to call the DAPP
function execute(address dest, uint256 value, bytes calldata functionData) external requireFromEntryPointOrOwner {
    (bool success, bytes memory result) = dest.call{value: value}(functionData);
    if (!success) {
        revert MinimalAccount__CallFailed(result);
    }
}

// core of test:
address dest = address(usdc);
uint256 value = 0;
bytes memory functionData = abi.encodeWithSelector(ERC20Mock.mint.selector, address(minimalAccount), AMOUNT);
// Act
vm.prank(minimalAccount.owner());
minimalAccount.execute(dest, value, functionData);

the owner of this minimal account can be our EOA account(Direct call) or it can be the entry point.

🔹.create SendPackedUserOp.s.sol

// 1. Generate the unsigned data
// @ztmy Fill the parameters in the PackedUserOperation struct,  except for signature.
uint256 nonce = vm.getNonce(minimalAccount) - 1;
PackedUserOperation memory userOp = _generateUnsignedUserOperation(callData, minimalAccount, nonce);

// 2. Get the userOp Hash
bytes32 userOpHash = IEntryPoint(config.entryPoint).getUserOpHash(userOp);
// @ztmy Convert the Hash to ERC-191 format digest
bytes32 digest = userOpHash.toEthSignedMessageHash();

// 3. Sign it
// @ztmy sign the userOpHash then add it to userOp
(v, r, s) = vm.sign(config.account, digest);
userOp.signature = abi.encodePacked(r, s, v); // Note the order

Create SendPackedUserOp.s.sol to create the parameter PackedUserOperation, which is what the alt-mempool needs to get.
SendPackedUserOp.s.sol do these three things in step.

🔹.test validateUserOp can be seccess called by entrypoint

function testValidationOfUserOps() public {
    // Arrange
    assertEq(usdc.balanceOf(address(minimalAccount)), 0);
    address dest = address(usdc);
    uint256 value = 0;

    // @ztmy Firstly our contract call usdc mint()
    bytes memory functionData = abi.encodeWithSelector(ERC20Mock.mint.selector, address(minimalAccount), AMOUNT);

    // @ztmy Then entrypoint contract call our contract execute() to execute mint()
    bytes memory executeCallData =
        abi.encodeWithSelector(MinimalAccount.execute.selector, dest, value, functionData);

    PackedUserOperation memory packedUserOp = sendPackedUserOp.generateSignedUserOperation(
        executeCallData, helperConfig.getConfig(), address(minimalAccount)
    );

    // @ztmy EntryPoint.getUserOpHash() will hash the packedUserOp exclude the signature.
    bytes32 userOperationHash = IEntryPoint(helperConfig.getConfig().entryPoint).getUserOpHash(packedUserOp);
    uint256 missingAccountFunds = 1e18;

    // Act
    vm.prank(helperConfig.getConfig().entryPoint);
    uint256 validationData = minimalAccount.validateUserOp(packedUserOp, userOperationHash, missingAccountFunds);
    // @ztmy probably should parse the validationdata but since our codebase is pretty simple 
    // and we just know it's returning a one or a zero (SIG_VALIDATION_SUCCESS == 0)
    assertEq(validationData, 0);
}

It's going to be these alt-mempo nodes who are going to submit the transaction to the entrypoint.
The entrypoint is going to call validateUserOp() to validate a transaction on our account.
Then it's going to pass the transaction information to our account and then our account will be the message.sender and it need to call the execute() to call the DAPP.

📌 sum & F:

Learned the working process of a smart contract account, and how to create a simple one.

lesson 15

2 Mar:

📌 harvest:

🔹.Mempool

Bundler is the Mempool processor for ERC-4337 transactions, equivalent to "Alt-Mempool".
Ordinary transactions enter the public Mempool, from which miners/validators select transactions.
The UserOperation enters Bundler (private Mempool), which is then uniformly committed by Bundler to the EntryPoint contract.

🔹.ZK Sync system contracts

ZK Sync has a lot of system contracts at very specific addresses that govern a lot of the functionality that goes on in zync. the contract deployer being one of the most important ones, this is also why when trying to deploy a smart contract to ZK sync we can have a hard time.

NonceHolder system contract has a mapping of every single account every single account address and the nonce that they currently are working with.

bootloader system contract you can kind of think as like the super admin system contract of all these system contracts.
Whenever you send this type 1113 transaction it will be rerouted to this, this is how ZK sync has account abstraction built in.
You can kind of think of this as the entry point smart contract on ethereum mainnet.
the message. sender is always going to be this.

🔹.Lifecycle of a Type 113 (0x71) Transaction on ZK Sync

msg.sender is the bootloader system contract

Phase 1: Validation

User Sends Transaction: The user sends the transaction to the "zkSync API client" (a type of "light node").
Nonce Check: The zkSync API client checks if the nonce is unique by querying the NonceHolder system contract.
Validate Transaction: The zkSync API client calls validateTransaction, which must update the nonce.
Nonce Update Verification: The zkSync API client verifies that the nonce has been updated.
Payment Handling: The zkSync API client calls either:
- payForTransaction, or
- prepareForPaymaster & validateAndPayForPaymasterTransaction.
Bootloader Payment Verification: The zkSync API client ensures that the bootloader is paid.

Note: All validation steps occur on the "light node" (API client). The ZK Sync system consists of:

Light Nodes (API client nodes)

Main Node (the main sequencer node, which is currently centralized but will be decentralized in the future).

Phase 2: Execution

Transaction Submission: The zkSync API client passes the validated transaction to the main node / sequencer (currently the same entity).
Execute Transaction: The main node calls executeTransaction.
Post-Transaction (if applicable): If a paymaster was used, the postTransaction function is called.

recap of all the things ->[t=124316]

🔹.Call System Contract

# set this up then zk sync will allow you call the systems contract
is-system = true

SystemContractsCaller.systemCallWithPropagatedRevert(
    uint32(gasleft()),
    address(NONCE_HOLDER_SYSTEM_CONTRACT),
    0,
    abi.encodeCall(INonceHolder.incrementMinNonceIfEquals, (_transaction.nonce))
);

on ZK sync there are a lot of admin smart contracts called system smart contracts where they have admin level power that over the global of the chain.

this is what's known as a system call simulation

Tips: they actually have an AI that has read all of their documentation that does a pretty good job of answering questions related specifically to ZK sync docs it's in the Discord it's a great tool

🔹.comparison

ZK Sync Node == Alt-Mempool

bootloader == entrypoint

(struct) Transaction == PackedUserOperation

validateUserOp == validateTransaction

entrypoint based account abstraction the from is going to be whatever node or user actually created the transaction whereas on zync with Native account abstraction the from is actually going to be the smart contract wallet itself:

Bundler sends UserOperation → entrypoint
SCA direct sends EIP-712 Signature transaction(113) → Bootloader

📌 sum & F:

From this lesson, I learned how to do account abstraction on a chain that doesn't have native account abstraction but has account abstraction via an entrypoint smart contract and an Alt-Mempool, then also learned how to do account abstraction on a chain that has a account abstraction built in.

lesson 16

3 Mar:

📌 harvest:

🔹.DAO

Voting Mechanism Token based voting Skin in the game voting Proof of personhood or participation

put the implementation of the voting into two categories:
onchain voting and offchain voting

Aragon:
A set of tools and infrastructure is provided to enable users to create and manage DAOs without code required.

🔹.some feature

// Checkpoint：
// Make sure to use the voting weights that were used when the proposal was created
// Subsequent token transfers do not affect voting rights
struct Checkpoint {
    uint32 fromBlock;   
    uint256 votes;      
}
// Each address has its own checkpoint history


// Activate voting rights, will effect at the next block
token.delegate(VOTER);


// permission setting
// 1. Anyone can submit a proposal to the Governor
// 2. After the proposal is passed, only the Governor can submit an execution plan to TimeLock
timelock.grantRole(proposerRole, address(governor));
// anybody can execute a past proposal
timelock.grantRole(executorRole, address(0));
// Remove administrator rights
timelock.revokeRole(adminRole, msg.sender);

// TimeLock is responsible for execution as the owner of Box
box.transferOwnership(address(timelock));

🔹.process of DAO

MyGovernor Contract:
Proposal creation and management, vote management

TimeLock Contract:
Delay execution, hold authority on other contracts, and finally execute the proposal

Governor(Create proposal, manage vote) -> TimeLock(Delay, execute)

the process of voting of a typical DAO:

1.Propose to the DAO

Voting Delay (Delay since proposal is created until voting starts)

2.Vote

Voting Period

3.Queue

min Delay (Delay that you have to wait before executing)

4.Execute

📌 sum & F:

Have a basic understanding of DAO and the process of voting.