feat: impl basic ERC-20 token for WLD HUB

Author: martinvibes

foundry.toml

@@ -7,5 +7,5 @@ script = "script"
 
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options
 
-[default]
+remappings = ["forge-std/=lib/forge-std/src/"]
 fs_permissions = [{ access = "read-write", path = "./" }]

lib/forge-std

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function transfer(address recipient, 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 sender, address recipient, uint256 amount) external returns (bool);
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+contract ERC20Token is IERC20 {
+    string public name;
+    string public symbol;
+    uint8 public decimals;
+    uint256 private _totalSupply;
+
+    mapping(address => uint256) private _balances;
+    mapping(address => mapping(address => uint256)) private _allowances;
+
+    constructor(string memory tokenName, string memory tokenSymbol, uint8 tokenDecimals, uint256 initialSupply) {
+        name = tokenName;
+        symbol = tokenSymbol;
+        decimals = tokenDecimals;
+        _totalSupply = initialSupply * (10 ** uint256(decimals));
+        _balances[msg.sender] = _totalSupply;
+
+        emit Transfer(address(0), msg.sender, _totalSupply);
+    }
+
+    function totalSupply() external view override returns (uint256) {
+        return _totalSupply;
+    }
+
+    function balanceOf(address account) external view override returns (uint256) {
+        return _balances[account];
+    }
+
+    function transfer(address recipient, uint256 amount) external override returns (bool) {
+        _transfer(msg.sender, recipient, amount);
+        return true;
+    }
+
+    function allowance(address owner, address spender) external view override returns (uint256) {
+        return _allowances[owner][spender];
+    }
+
+    function approve(address spender, uint256 amount) external override returns (bool) {
+        _approve(msg.sender, spender, amount);
+        return true;
+    }
+
+    function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
+        _transfer(sender, recipient, amount);
+
+        uint256 currentAllowance = _allowances[sender][msg.sender];
+        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
+        _approve(sender, msg.sender, currentAllowance - amount);
+
+        return true;
+    }
+
+    function _transfer(address sender, address recipient, uint256 amount) internal {
+        require(sender != address(0), "ERC20: transfer from the zero address");
+        require(recipient != address(0), "ERC20: transfer to the zero address");
+        require(_balances[sender] >= amount, "ERC20: transfer amount exceeds balance");
+
+        _balances[sender] -= amount;
+        _balances[recipient] += amount;
+
+        emit Transfer(sender, recipient, amount);
+    }
+
+    function _approve(address owner, address spender, uint256 amount) internal {
+        require(owner != address(0), "ERC20: approve from the zero address");
+        require(spender != address(0), "ERC20: approve to the zero address");
+
+        _allowances[owner][spender] = amount;
+        emit Approval(owner, spender, amount);
+    }
+}

src/ERC20Token.sol

@@ -1,54 +1,51 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.13;
-
-interface IWLDToken {
-    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
-    function balanceOf(address account) external view returns (uint256);
-}
-
-contract WLDTokenLocker {
-    IWLDToken public wldToken;
-    uint256 public minLockDuration;
-    uint256 public maxLockDuration;
-
-    struct Lock {
-        uint256 amount;
-        uint256 unlockTime;
-    }
-
-    mapping(address => Lock) public locks;
-
-    event TokensLocked(address indexed user, uint256 amount, uint256 unlockTime);
-    event TokensWithdrawn(address indexed user, uint256 amount);
-
-    constructor(address _wldTokenAddress, uint256 _minLockDuration, uint256 _maxLockDuration) {
-        wldToken = IWLDToken(_wldTokenAddress);
-        minLockDuration = _minLockDuration;
-        maxLockDuration = _maxLockDuration;
-    }
-
-    function lockTokens(uint256 amount, uint256 lockDuration) external {
-        require(lockDuration >= minLockDuration, "Lock duration too short");
-        require(lockDuration <= maxLockDuration, "Lock duration too long");
-        require(wldToken.transferFrom(msg.sender, address(this), amount), "Transfer failed");
-
-        locks[msg.sender] = Lock({
-            amount: amount,
-            unlockTime: block.timestamp + lockDuration
-        });
-
-        emit TokensLocked(msg.sender, amount, block.timestamp + lockDuration);
-    }
-
-    function withdrawTokens() external {
-        Lock storage userLock = locks[msg.sender];
-        require(block.timestamp >= userLock.unlockTime, "Tokens are still locked");
-
-        uint256 amount = userLock.amount;
-        userLock.amount = 0;
-
-        require(wldToken.transferFrom(address(this), msg.sender, amount), "Transfer failed");
-
-        emit TokensWithdrawn(msg.sender, amount);
-    }
-}
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+interface IWLDToken {
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+}
+
+contract WLDTokenLocker {
+    IWLDToken public wldToken;
+    uint256 public minLockDuration;
+    uint256 public maxLockDuration;
+
+    struct Lock {
+        uint256 amount;
+        uint256 unlockTime;
+    }
+
+    mapping(address => Lock) public locks;
+
+    event TokensLocked(address indexed user, uint256 amount, uint256 unlockTime);
+    event TokensWithdrawn(address indexed user, uint256 amount);
+
+    constructor(address _wldTokenAddress, uint256 _minLockDuration, uint256 _maxLockDuration) {
+        wldToken = IWLDToken(_wldTokenAddress);
+        minLockDuration = _minLockDuration;
+        maxLockDuration = _maxLockDuration;
+    }
+
+    function lockTokens(uint256 amount, uint256 lockDuration) external {
+        require(lockDuration >= minLockDuration, "Lock duration too short");
+        require(lockDuration <= maxLockDuration, "Lock duration too long");
+        require(wldToken.transferFrom(msg.sender, address(this), amount), "Transfer failed");
+
+        locks[msg.sender] = Lock({amount: amount, unlockTime: block.timestamp + lockDuration});
+
+        emit TokensLocked(msg.sender, amount, block.timestamp + lockDuration);
+    }
+
+    function withdrawTokens() external {
+        Lock storage userLock = locks[msg.sender];
+        require(block.timestamp >= userLock.unlockTime, "Tokens are still locked");
+
+        uint256 amount = userLock.amount;
+        userLock.amount = 0;
+
+        require(wldToken.transferFrom(address(this), msg.sender, amount), "Transfer failed");
+
+        emit TokensWithdrawn(msg.sender, amount);
+    }
+}

src/WLDTokenLocker.sol

@@ -1,30 +1,30 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.13;
-
-interface IWLDToken {
-    function balanceOf(address account) external view returns (uint256);
-}
-
-contract WLDTokenVerifier {
-    IWLDToken public wldToken;
-    uint256 public minimumBalance;
-
-    event AccessGranted(address indexed user);
-    event AccessDenied(address indexed user);
-
-    constructor(address _wldTokenAddress, uint256 _minimumBalance) {
-        wldToken = IWLDToken(_wldTokenAddress);
-        minimumBalance = _minimumBalance;
-    }
-
-    function verifyAccess(address user) public returns (bool) {
-        uint256 balance = wldToken.balanceOf(user);
-        if (balance >= minimumBalance) {
-            emit AccessGranted(user);
-            return true;
-        } else {
-            emit AccessDenied(user);
-            return false;
-        }
-    }
-}
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+interface IWLDToken {
+    function balanceOf(address account) external view returns (uint256);
+}
+
+contract WLDTokenVerifier {
+    IWLDToken public wldToken;
+    uint256 public minimumBalance;
+
+    event AccessGranted(address indexed user);
+    event AccessDenied(address indexed user);
+
+    constructor(address _wldTokenAddress, uint256 _minimumBalance) {
+        wldToken = IWLDToken(_wldTokenAddress);
+        minimumBalance = _minimumBalance;
+    }
+
+    function verifyAccess(address user) public returns (bool) {
+        uint256 balance = wldToken.balanceOf(user);
+        if (balance >= minimumBalance) {
+            emit AccessGranted(user);
+            return true;
+        } else {
+            emit AccessDenied(user);
+            return false;
+        }
+    }
+}

src/WLDTokenVerifier.sol

@@ -17,6 +17,11 @@ contract CounterTest is Test {
         assertEq(counter.number(), 1);
     }
 
+    function test_not_equal_to_zero() public view {
+        uint256 count = counter.number();
+        assertEq(count, 0);
+    }
+
     function testFuzz_SetNumber(uint256 x) public {
         counter.setNumber(x);
         assertEq(counter.number(), x);