Ngô Lê Nam Quyền | Register for Polkadot Codecamp

3-fullstack-scaffold-dot/yarn.lock

@@ -0,0 +1,4 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+

4-uniswapv2/contracts/IERC20.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+
+    function balanceOf(address account)
+        external
+        view
+        returns (uint256);
+
+    function transfer(address to, uint256 amount)
+        external
+        returns (bool);
+
+    function allowance(address owner, address spender)
+        external
+        view
+        returns (uint256);
+
+    function approve(address spender, uint256 amount)
+        external
+        returns (bool);
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) external returns (bool);
+}

4-uniswapv2/contracts/MyERC20.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "./interfaces/IERC20.sol";
+
+contract MyERC20 is IERC20 {
+    string private _name;
+    string private _symbol;
+    uint8 private _decimals;
+    uint private _totalSupply;
+
+    mapping(address => uint) private _balances;
+    mapping(address => mapping(address => uint)) private _allowances;
+
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        uint8 decimals_
+    ) {
+        _name = name_;
+        _symbol = symbol_;
+        _decimals = decimals_;
+    }
+
+    function name() external view override returns (string memory) {
+        return _name;
+    }
+
+    function symbol() external view override returns (string memory) {
+        return _symbol;
+    }
+
+    function decimals() external view override returns (uint8) {
+        return _decimals;
+    }
+
+    function totalSupply() external view override returns (uint) {
+        return _totalSupply;
+    }
+
+    function balanceOf(address owner) external view override returns (uint) {
+        return _balances[owner];
+    }
+
+    function allowance(
+        address owner,
+        address spender
+    ) external view override returns (uint) {
+        return _allowances[owner][spender];
+    }
+
+    function approve(address spender, uint value) external override returns (bool) {
+        _allowances[msg.sender][spender] = value;
+        emit Approval(msg.sender, spender, value);
+        return true;
+    }
+
+    function transfer(address to, uint value) external override returns (bool) {
+        _transfer(msg.sender, to, value);
+        return true;
+    }
+
+    function transferFrom(
+        address from,
+        address to,
+        uint value
+    ) external override returns (bool) {
+        uint currentAllowance = _allowances[from][msg.sender];
+        require(currentAllowance >= value, "ERC20: allowance exceeded");
+
+        unchecked {
+            _allowances[from][msg.sender] = currentAllowance - value;
+        }
+
+        _transfer(from, to, value);
+        return true;
+    }
+
+    function _transfer(address from, address to, uint value) internal {
+        require(to != address(0), "ERC20: transfer to zero address");
+        require(_balances[from] >= value, "ERC20: insufficient balance");
+
+        unchecked {
+            _balances[from] -= value;
+            _balances[to] += value;
+        }
+
+        emit Transfer(from, to, value);
+    }
+
+    function mint(address to, uint value) external {
+        _mint(to, value);
+    }
+
+    function _mint(address to, uint value) internal {
+        require(to != address(0), "ERC20: mint to zero address");
+
+        _totalSupply += value;
+        _balances[to] += value;
+
+        emit Transfer(address(0), to, value);
+    }
+}

4-uniswapv2/contracts/SimpleRouter.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "./UniswapV2Pair.sol";
+import "./IERC20.sol";
+
+contract SimpleRouter {
+    address public pair;
+    address public token0;
+    address public token1;
+
+    constructor(address _pair) {
+        pair = _pair;
+        token0 = UniswapV2Pair(_pair).token0();
+        token1 = UniswapV2Pair(_pair).token1();
+    }
+
+    // swap token0 -> token1
+    function swapExactToken0ForToken1(uint amountIn) external {
+        IERC20(token0).transferFrom(msg.sender, pair, amountIn);
+
+        (uint112 reserve0, uint112 reserve1,) =
+            UniswapV2Pair(pair).getReserves();
+
+        uint amountOut = getAmountOut(amountIn, reserve0, reserve1);
+
+        UniswapV2Pair(pair).swap(
+            0,
+            amountOut,
+            msg.sender,
+            new bytes(0)
+        );
+    }
+
+    // swap token1 -> token0
+    function swapExactToken1ForToken0(uint amountIn) external {
+        IERC20(token1).transferFrom(msg.sender, pair, amountIn);
+
+        (uint112 reserve0, uint112 reserve1,) =
+            UniswapV2Pair(pair).getReserves();
+
+        uint amountOut = getAmountOut(amountIn, reserve1, reserve0);
+
+        UniswapV2Pair(pair).swap(
+            amountOut,
+            0,
+            msg.sender,
+            new bytes(0)
+        );
+    }
+
+    function getAmountOut(
+        uint amountIn,
+        uint reserveIn,
+        uint reserveOut
+    ) internal pure returns (uint) {
+        require(amountIn > 0, "INSUFFICIENT_INPUT");
+        require(reserveIn > 0 && reserveOut > 0, "INSUFFICIENT_LIQ");
+
+        uint amountInWithFee = amountIn * 997;
+        uint numerator = amountInWithFee * reserveOut;
+        uint denominator = reserveIn * 1000 + amountInWithFee;
+
+        return numerator / denominator;
+    }
+}

4-uniswapv2/contracts/WETH.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract WETH {
+    string public name = "Wrapped Ether";
+    string public symbol = "WETH";
+    uint8  public decimals = 18;
+
+    event Approval(address indexed src, address indexed guy, uint wad);
+    event Transfer(address indexed src, address indexed dst, uint wad);
+    event Deposit(address indexed dst, uint wad);
+    event Withdrawal(address indexed src, uint wad);
+
+    mapping(address => uint) public balanceOf;
+    mapping(address => mapping(address => uint)) public allowance;
+
+    receive() external payable {
+        deposit();
+    }
+
+    function deposit() public payable {
+        balanceOf[msg.sender] += msg.value;
+        emit Deposit(msg.sender, msg.value);
+    }
+
+    function withdraw(uint wad) public {
+        require(balanceOf[msg.sender] >= wad, "not enough WETH");
+        balanceOf[msg.sender] -= wad;
+        payable(msg.sender).transfer(wad);
+        emit Withdrawal(msg.sender, wad);
+    }
+
+    function approve(address guy, uint wad) public returns (bool) {
+        allowance[msg.sender][guy] = wad;
+        emit Approval(msg.sender, guy, wad);
+        return true;
+    }
+
+    function transfer(address dst, uint wad) public returns (bool) {
+        return transferFrom(msg.sender, dst, wad);
+    }
+
+    function transferFrom(address src, address dst, uint wad)
+        public
+        returns (bool)
+    {
+        require(balanceOf[src] >= wad, "not enough");
+        if (src != msg.sender && allowance[src][msg.sender] != type(uint).max) {
+            require(allowance[src][msg.sender] >= wad, "not allowed");
+            allowance[src][msg.sender] -= wad;
+        }
+
+        balanceOf[src] -= wad;
+        balanceOf[dst] += wad;
+
+        emit Transfer(src, dst, wad);
+        return true;
+    }
+}