init commit 2

Author: Al-Qa-qa

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "solidity.formatter": "forge"
+}

foundry.toml

@@ -3,4 +3,6 @@ src = "src"
 out = "out"
 libs = ["lib"]
 
+mappings = ["@openzeppelin/=lib/openzeppelin-contracts"]
+
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

lib/openzeppelin-contracts

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+contract BankV1 {
+    mapping(address account => bool activated) private activatedAccounts;
+    mapping(address account => uint256 password) private accountsPasswords;
+    mapping(address account => uint256 balance) private accountsBalances;
+
+    /// @notice Create new Account in the Bank
+    /// @param password Account password that will be used in authentication when withdrawing
+    function createAccount(uint256 password) external {
+        activatedAccounts[msg.sender] = true;
+        accountsPasswords[msg.sender] = password;
+    }
+
+    /// @notice adding provided account balance by the value of sent Ether
+    /// @dev Allows anyone to deposit ether to any
+    /// @param account The account receiving the deposited Ether
+    function depositEther(address account) external payable {
+        require(activatedAccounts[account], "Account is not activated yet");
+        require(msg.value > 0, "No Ether sent");
+
+        accountsBalances[account] += msg.value;
+    }
+
+    /// @notice Withdrawing ether from a given account and send him to the recipent
+    /// @dev the sender provide a valid password for the account to withdraw from it
+    /// @param account The account to withdraw ether from
+    /// @param password The password for that account
+    /// @param amount The amount to withdraw
+    /// @param recipent The receiver of ether
+    function withdrawEther(address account, uint256 password, uint256 amount, address recipent) external {
+        require(activatedAccounts[account], "Account is not activated yet");
+        require(accountsPasswords[account] == password, "Account is not activated yet");
+        require(accountsBalances[account] >= amount, "Amount to withdraw exceeds balance");
+
+        accountsBalances[account] -= amount;
+        (bool success,) = recipent.call{value: amount}("");
+        require(success, "Withdrawal Failed");
+    }
+}

script/Counter.s.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+contract BankV2 {
+    mapping(address account => uint256 balance) private accountsBalances;
+
+    /// @notice Adding sender balance by the amount of ether sent
+    function depositEther() external payable {
+        require(msg.value > 0, "No Ether sent");
+        accountsBalances[msg.sender] += msg.value;
+    }
+
+    /// @notice withdraw All ether hold by the caller and send them to him
+    /// @dev reverts if there is no ether hold by the caller
+    function withdrawEther() external {
+        uint256 withdrawalAmount = accountsBalances[msg.sender];
+        require(withdrawalAmount > 0, "No ether to withdraw");
+
+        (bool success,) = msg.sender.call{value: withdrawalAmount}("");
+        require(success, "Withdrawal Failed");
+
+        accountsBalances[msg.sender] = 0;
+    }
+}

src/BankV1.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+import {IERC20} from "forge-std/interfaces/IERC20.sol";
+
+contract BankV3 {
+    mapping(address account => uint256 balance) private accountsBalances;
+
+    address public immutable USDT;
+
+    constructor(address usdt) {
+        USDT = usdt;
+    }
+
+    /// @notice Adding sender balance by the amount of USD
+    /// @param amount The amount to deposit to the caller
+    function depositUSD(uint256 amount) external payable {
+        require(amount > 0, "No USD sent");
+        bool success = IERC20(USDT).transferFrom(msg.sender, address(this), amount);
+        require(success, "Transfering Failed");
+
+        accountsBalances[msg.sender] += amount;
+    }
+
+    /// @notice withdraw the amount of USD send the caller and send them to receipent
+    /// @param amount the amount of USD to withdraw
+    /// @param receipent The receiver that we will take the withdrawn USD
+    function withdrawUSD(uint256 amount, address receipent) external {
+        uint256 withdrawalAmount = accountsBalances[msg.sender];
+        require(withdrawalAmount >= amount, "Amount to withdraw exceeds balance");
+
+        bool success = IERC20(USDT).transfer(receipent, amount);
+        require(success, "Transfering Failed");
+        accountsBalances[msg.sender] -= amount;
+    }
+
+    /// @notice withdraw USD with calling a Fallcak function
+    /// @param amount the amount of USD to withdraw
+    /// @param receipent The receiver that we will take the withdrawn USD
+    /// @param data The Fallback function signature we will call on receipent
+    function withdrawFallbackUSD(uint256 amount, address receipent, bytes memory data) external {
+        uint256 withdrawalAmount = accountsBalances[msg.sender];
+        require(withdrawalAmount >= amount, "Amount to withdraw exceeds balance");
+
+        bool success = IERC20(USDT).transfer(receipent, amount);
+        require(success, "Transfering Failed");
+        accountsBalances[msg.sender] -= amount;
+
+        (bool fallbackSuccess,) = receipent.call(data);
+        require(fallbackSuccess, "Fallback Function reverted");
+    }
+}

src/BankV2.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+import {IERC20} from "forge-std/interfaces/IERC20.sol";
+import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
+
+contract BankV4 is AccessControl {
+    mapping(address account => uint256 balance) public accountsBalances;
+
+    bytes32 public constant BLACKLISTED_WITHDRAW = keccak256("BLACKLISTED_WITHDRAW");
+
+    address public immutable USDT;
+
+    constructor(address usdt, address admin) {
+        USDT = usdt;
+        _grantRole(DEFAULT_ADMIN_ROLE, admin);
+    }
+
+    /// @notice Adding sender balance by the amount of USD sent
+    function depositUSD(uint256 amount) external {
+        require(amount > 0, "No USD sent");
+        bool success = IERC20(USDT).transferFrom(msg.sender, address(this), amount);
+        require(success, "Transfering Failed");
+
+        accountsBalances[msg.sender] += amount;
+    }
+
+    /// @notice withdraw the amount of USD send the caller and send them to receipent
+    /// @dev reverts if the caller is BLACKLISTED
+    /// @param amount the amount of USD to withdraw
+    /// @param receipent The receiver that we will take the withdrawn USD
+    function withdrawUSD(uint256 amount, address receipent) external {
+        require(!hasRole(BLACKLISTED_WITHDRAW, msg.sender), "Account is BlackListed");
+
+        uint256 withdrawalAmount = accountsBalances[msg.sender];
+        require(withdrawalAmount >= amount, "Amount to withdraw exceeds balance");
+
+        bool success = IERC20(USDT).transfer(receipent, amount);
+        require(success, "Transfering Failed");
+        accountsBalances[msg.sender] -= amount;
+    }
+
+    /// @notice Blacklist a given account and prevent him from withdrawing
+    /// @param account The account to add to blacklist
+    function blackListAccount(address account) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        bool success = _grantRole(BLACKLISTED_WITHDRAW, account);
+        require(success, "Account was already Black Listed");
+    }
+
+    /// @notice unBlacklist a given account and prevent him from withdrawing
+    /// @param account The account to remove from blacklist
+    function unBlackListAccount(address account) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        bool success = _revokeRole(BLACKLISTED_WITHDRAW, account);
+        require(success, "Account was not Black Listed");
+    }
+
+    /// @notice take the amount of USD hold by a given blacklisted account
+    /// @param account The blacklisted account to take his balance
+    /// @param receipent The receiver of the USD
+    function drainBlackListedBalance(address account, address receipent) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        require(hasRole(BLACKLISTED_WITHDRAW, account), "Accound is not BlackListed");
+
+        uint256 amount = accountsBalances[account];
+        bool success = IERC20(USDT).transfer(receipent, amount);
+        require(success, "Transfering Failed");
+        accountsBalances[msg.sender] = 0;
+    }
+}

src/BankV3.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+import {IERC20} from "forge-std/interfaces/IERC20.sol";
+
+contract BankV5 {
+    mapping(address account => uint256 balance) private accountsBalances;
+
+    address public immutable WETH;
+
+    constructor(address weth) {
+        WETH = weth;
+    }
+
+    /// @notice Adding sender balance by the amount of WETH sent
+    /// @param amount the amount of deposited WETH
+    function depositWETH(uint256 amount) external payable {
+        require(amount > 0, "No amount sent");
+        bool success = IERC20(WETH).transferFrom(msg.sender, address(this), amount);
+        require(success, "Transfering Failed");
+
+        accountsBalances[msg.sender] += amount;
+    }
+
+    /// @notice withdraw the amount of WETH send the caller and send them to receipent
+    /// @param amount the amount of WETH to withdraw
+    /// @param receipent The receiver that we will take the withdrawn WETH
+    function withdrawWETH(uint256 amount, address receipent) external {
+        uint256 withdrawalAmount = accountsBalances[msg.sender];
+        require(withdrawalAmount >= amount, "Amount to withdraw exceeds balance");
+
+        bool success = IERC20(WETH).transferFrom(address(this), receipent, amount);
+        require(success, "Transfering Failed");
+        accountsBalances[msg.sender] -= amount;
+    }
+}