Create a Yul code to show how data is encoded in calldata for int and uint types, arrays, addresses, bytes, strings, fixed byte arrays and structs.

How deadly is an unchecked math? Since every math in the assembly{} block is unchecked, what could go wrong?
See here.

    uint256 a = type(uint256).max;
    uint256 b = type(uint256).max / 2;

    assembly {
        let sum := add(a, b)
    }

    // What could go wrong 👀?

Commences once all implementations are closed.

See here.

    fallback() external {
        ++count;
        (bool success, ) = payable(msg.sender).call{value: 1}("");
        require(success);
    }

See here.

See here.

WIP alongside #3.

See here.

Should correspond to - https://solidity-by-example.org/error

1.you don't need to check for underflow and overflow, since it's version 0.8.17
2.add natspec documentation
3.caching value in some part of code will reduce gas instead of calling the opcode twice we can simply store the value in the stack and fetch it back for later use, e.g ` // Function to increment count by 1
function inc() public {
assembly {
// Assign count variable slot to countSlot.
let countSlot := count.slot

        // We update the value at the `count` slot by incrementing the
        // current value at the slot by 1, then calling an sstore() to overwrite the
        // value at slot 0.
        // However, this doesn't check for overflows and underflows, so we must make sure that
        // we do not go beyond the limit for our type maximum before making the update.
        // We are working with uint256, so the max is 0x("ff" * 32).
        if eq(sload(countSlot), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { revert(0, 0) }
        sstore(countSlot, add(sload(countSlot), 1))
    }
}

here we can simply reduce the gas value by doing something like this function inc() public {
assembly {
// Assign count variable slot to countSlot.
let countSlot := count.slot

        // We update the value at the `count` slot by incrementing the
        // current value at the slot by 1, then calling an sstore() to overwrite the
        // value at slot 0.
        // However, this doesn't check for overflows and underflows, so we must make sure that
        // we do not go beyond the limit for our type maximum before making the update.
        // We are working with uint256, so the max is 0x("ff" * 32).
        let cachedValue := sload(countSlot)
        if eq(cachedValue, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { revert(0, 0) }
        sstore(countSlot, add(cachedValue, 1))
    }
}

`
4. in the loop contract we don't need to initialize the value to zero they are already zero by default

See here.

Hey @0xfps,

while going through Structs.sol, the file looked like this:

That part is not commented and gonna be hard for new users to understand like what's going on here..What If I add comments in here?

Thanks!

i might be wrong but i think the call part using assembly might be wrong

• Counter
• EtherWallet
• for_loop
• Hello World
• if_else
• mapping
• simple_storage
• types
• yul_Erc20

implementation of pop and push for array
link here