2024.09.23#

1. Remix IDE

• File Extension of Solidity : .sol
• Ctrl + S -> Compile
• Deploy -> Simulate Ethereum chain -> run smart contracts

2. Basic

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
contract HelloWeb3{
    string public _string = "Hello Web3!";
}

• // SPDX-License-Identifier: MIT -> Denotes license identifier (MIT for example)
• pragma solidity ^0.8.21; -> Only allow compiler version 0.8.21 ~ 0.9.0(0.8.21 for example)
• contract HelloWeb3 -> Similar as class in other programming language (HelloWeb3 for example). also,we call it “合約”
• string public _string = "Hello Web3!"; -> Declared Variables
• string : Value type

• public : visibility

• _string : Value name,Define by your self
• "Hello Web3!" : Value

function <functionName>(<Type> <ParameterName>) <visibility> <modifier> returns (<Type>) 

<Type> <parameter1> : Input parameter,e.g. int a

Also,you can input more than 1 parameter

<modifier> :

2024.09.24#

1. Variables

data storage locations:

scope:

contract Example {
    uint public count;
    function increment() public pure returns (uint) {
        uint localCount = 0; 
        return localCount;
    }
}

2. Array

//fixed-sized arrays
<type>[<length>] <name>;
<type>[] memory <name> = new <type>[](<length>);
uint[9] array;
uint[] memory array3 = new uint[](5);

//dynamic-sized array
uint[] array1;
bytes array2;    //dynamic byte array

• .length -> return array’s length dynamic array :
• .push -> add 0element at the end of array
• .puxh(x) -> add xelement at the end of array
• .pop -> remove the last element of array

3. Struct

struct Student{
    uint id;
    uint score; 
}
//4 ways to assign value
function method1() external{
    Student storage _student = student; //copy Student
    _student.id = 11;
    _student.score = 100;
}
function method2() external{
    student.id = 1;
    student.score = 80;
}
function method3() external {
    student = Student(3, 90);
}
function method4() external {
    student = Student({id: 4, score: 60});
}

4. Map key -> Value

mapping(<KeyType> => <ValueType>) public <name>;
mapping(address => uint) public balances;

<name>[<key>] = <Value>;
balances[msg.sender] = 100;

2024.09.25#

1. constant/immutable

2. Control flow same as C

//if-else
function ifElseTest(uint256 _number) public pure returns(bool){
    if(_number == 0){
        return(true);
    }else{
        return(false);
    }
}
//for loop
function forLoopTest() public pure returns(uint256){
    uint sum = 0;
    for(uint i = 0; i < 10; i++){
        sum += i;
    }
    return(sum);
}
//while
function doWhileTest() public pure returns(uint256){
    uint sum = 0;
    uint i = 0;
    do{
        sum += i;
        i++;
    }while(i < 10);
    return(sum);
}
//Insertion Sort
function insertionSort(uint[] memory a) public pure returns(uint[] memory) {
    for (uint i = 1;i < a.length;i++){
        uint temp = a[i];
        //uint j=i-1;
        uint j=i;    //uint can
        while( (j >= 1) && (temp < a[j-1])){    
        (temp < a[j])
            a[j] = a[j-1];
            j--;
        }
        a[j] = temp;
    }
    return(a);
}

2024.09.27#

1. constructor If variables is dynamic dicision when deploy,we can use constructor to assign (similar as decorator)

address owner; 
constructor(address initialOwner) {
    owner = initialOwner; 
}

2. modifier use to modify the behavior of function

address public owner;
bool public paused;

constructor() {
	owner = msg.sender;
	paused = false;
}

modifier onlyOwner() {
	require(msg.sender == owner, "Not authorized");
	_;//continue to run function
}

modifier whenNotPaused() {
	require(!paused, "Contract is paused");
	_;
}

function setPause(bool _paused) public onlyOwner {
	paused = _paused;
}

function changeOwner(address newOwner) public onlyOwner whenNotPaused {
	owner = newOwner;
}

3. event When event be triggered,it will be recorded in log

event Transfer(address indexed from, address indexed to, uint256 value);

function transfer(address _to, uint256 _value) public {
    emit Transfer(msg.sender, _to, _value);    //trigger event
}

4. override OverWrite the parent function

contract Parent {
    function foo() public virtual {
    }
}

contract Child is Parent {
    function foo() public override {
        //...
    }
}

2024.09.29#

1. Interface Define the interactions between contracts

interface Token {
    function transfer(address recipient, uint256 amount) external returns (bool);
}

contract MyToken is Token {
    mapping(address => uint256) public balances;

    function transfer(address recipient, uint256 amount) external override returns (bool) {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        balances[recipient] += amount;
        return true;
    }
}

1.1 IERC721

• event-Transfer:

event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

when tokenID moved from from to another address to

• event-ApprovalForAll:

event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

The token holder authorizes/de-authorizes an operator to manage all its tokens.

• function-balanceOf

function balanceOf(address owner) external view returns (uint256 balance);

return the number of tokens owned by owner

• function-ownerOf

function ownerOf(uint256 tokenId) external view returns (address owner);

return the address of owner of tokenID

and more…

2024.09.30#

1. Error Handling

• require Used to check if a condition is true If false,contract will be terminated

function withdraw(uint amount) public {
    require(amount <= balance, "Insufficient balance");
    balance -= amount;
    payable(msg.sender).transfer(amount);
}

• assert Used to check if a condition always be true

function decrement() public {
    assert(counter > 0);
    counter -= 1;
}

• error Custom error

error InsufficientBalance(uint requested, uint available);

function withdraw(uint amount) public {
    if (amount > balance)
        revert InsufficientBalance({
            requested: amount,
            available: balance
        });
    balance -= amount;
    payable(msg.sender).transfer(amount);
}

2024.10.02#

function saySomething() public pure returns(string memory){
    return("Nothing");
}

function saySomething(string memory something) public pure returns(string memory){
    return(something);
}

function f(uint8 _in) public pure returns (uint8 out) {
    out = _in;
}

function f(uint256 _in) public pure returns (uint256 out) {
    out = _in;
}

2024.10.03#

using Strings for uint256;
function getString1(uint256 _number) public pure returns(string memory){
    return _number.toHexString();
}

function getString2(uint256 _number) public pure returns(string memory){
    return Strings.toHexString(_number);
}

Dir
├── Import.sol
└── Yeye.sol

import './Yeye.sol';

//only a part that needed 
import { ContractName1, ContractName2 } from "path/to/file.sol";

//as to rename
import { ContractName as Alias } from "path/to/file.sol";

//package manager
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

//URL
import "https://github.com/username/repo/blob/main/Contract.sol";

2024.10.04#

event Received(address Sender, uint Value);
receive() external payable {
    emit Received(msg.sender, msg.value);
}

2024.10.06#

//recipient -> recipient's address
recipient.transfer(1 ether);
//if failed , it will revert automatically

bool success = recipient.send(1 ether);
//if failed , it won't revert
if (!success) {
    //if transfer failed...
}

(bool success, ) = recipient.call{value: 1 ether}("");
if(!success) {
	//if transfer failed...
}

2024.10.08#

function callSetX(address _Address, uint256 x) external {
    OtherContract(_Address).setX(x);
}

function callGetX(OtherContract _Address) external view returns (uint x) {
    x = _Address.getX();
}

Copy code
function callGetX2(address _Address) external view returns (uint x) {
    OtherContract oc = OtherContract(_Address);
    x = oc.getX();
}

Copy code
function setXTransferETH(address otherContract, uint256 x) payable external {
    OtherContract(otherContract).setX{value: msg.value}(x);
}

2024.10.10#

contract LogicContract {
    uint public number;

    function setNumber(uint _num) public {
        number = _num;
    }
}

contract ProxyContract {
    uint public number;

    function setNumber(address _logicContract, uint _num) public {
        (bool success, ) = _logicContract.delegatecall(
            abi.encodeWithSignature("setNumber(uint256)", _num)
        );
        require(success, "delegatecall failed");
    }
}

Afterall#

最後有一天因為段考忘記寫筆記，就被踢掉了QQ

沒拿到學習證書= =