Update to oz v5.0

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

.github/workflows/slither.yml

@@ -0,0 +1,26 @@
+name: Slither Analysis
+
+on: [push]
+
+jobs:
+  analyze:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    - name: Run Slither
+      uses: crytic/[email protected]
+      id: slither
+      with:
+        node-version: 20
+        sarif: outputs.sarif
+        fail-on: none
+
+    - name: Upload SARIF file
+      uses: github/codeql-action/upload-sarif@v2
+      with:
+        sarif_file: ${{ steps.slither.outputs.sarif }}

.gitignore

@@ -1,9 +1,8 @@
-./node_modules
-.env
+.history/
+node_modules/
 package-lock.json
-.history
-
-./oracleServer/node_modules
-./oracleServer/.env
-node_modules
-build
+artifacts/
+cache/
+.openzeppelin/
+.env
+.DS_Store

.hintrc

@@ -0,0 +1,13 @@
+{
+  "extends": [
+    "development"
+  ],
+  "hints": {
+    "axe/forms": [
+      "default",
+      {
+        "label": "off"
+      }
+    ]
+  }
+}

contracts/Faucet.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.20;
+
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+import "./interfaces/ZTokenInterface.sol";
+
+contract Faucet is OwnableUpgradeable {
+    mapping(string => address) public assets;
+    address public avax;
+
+    event AvaxFinished(address _avax, address faucet, uint256 balance);
+
+     function init() external initializer {
+        __Ownable_init(msg.sender);
+    }
+
+
+    function setAsset(string memory asset, address _address) external onlyOwner {
+        require(_address != address(0), "address cannot be a zero address");
+        assets[asset] = _address;
+    }
+
+     function setAvax(address _address) external onlyOwner {
+        require(_address != address(0), "address cannot be a zero address");
+        avax = _address;
+    }
+
+    function getAsset(string memory asset, address receiver) external {
+        if(IERC20(avax).balanceOf(address(this)) > 0.02 ether){
+            if(IERC20(avax).balanceOf(msg.sender) < 0.02 ether){
+                IERC20(avax).approve(address(this), 0.02 ether);
+                bool _success = IERC20(avax).transferFrom(address(this), msg.sender, 0.02 ether);
+                if(!_success) revert();
+
+            }
+        } else {
+            emit AvaxFinished(avax, address(this), IERC20(avax).balanceOf(msg.sender));
+        }
+        bool success = ZTokenInterface(assets[asset]).mint(receiver, 1000000 ether);
+        if(!success) revert();
+    }
+
+
+}

contracts/Oracle.sol

@@ -1,35 +1,126 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
 
+pragma solidity 0.8.20;
+
+import "@openzeppelin/contracts/access/AccessControl.sol";
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "./interfaces/BakiOracleInterface.sol";
 
-contract BakiOracle is Ownable, BakiOracleInterface {
-    uint256 _NGNUSD;
-    uint256 _XAFUSD;
-    uint256 _ZARUSD;
+contract BakiOracle is AccessControl, BakiOracleInterface, Ownable {
+
+    bytes32 public constant DATA_FEED = keccak256("DATA_FEED");
+
+    mapping(string => address) private zTokenAddress;
+    mapping(address => uint256) private zTokenUSDValue;
+
+    string[] public zTokenList;
+    uint256 public collateralUSD;
+
+    constructor (address admin, address _datafeed, address _zusd, address _zngn, address _zzar, address _zxaf)  Ownable(admin) {
+        string[4] memory default_currencies = ["zusd", "zngn", "zzar", "zxaf"];
+        _grantRole(DATA_FEED, _datafeed);
+        _grantRole(DEFAULT_ADMIN_ROLE, admin);
+
+        zTokenAddress["zusd"] = _zusd;
+        zTokenAddress["zngn"] = _zngn;
+        zTokenAddress["zzar"] = _zzar;
+        zTokenAddress["zxaf"] = _zxaf;
+
+        zTokenList = default_currencies;
+    }
+
+    event AddZToken(string indexed _name, address _address);
+    event RemoveZToken(string indexed _name);
+    event SetZTokenUSDValue(string indexed _name, uint256 _value);
+    event SetZCollateralUSD(uint256 _value);
+
+    function addZToken(string calldata _name, address _address) external onlyRole(DEFAULT_ADMIN_ROLE) {
+
+        require(_address != address(0), "Address is invalid");
+        require(!checkIfTokenExists(_name), "zToken already exists");
+
+        zTokenAddress[_name] = _address;
+        zTokenList.push(_name);
+
+        emit AddZToken(_name, _address);
+    }
+
+    function getZToken(string calldata _name) public view returns(address) {
+        require(zTokenAddress[_name] != address(0), "zToken does not exist");
+
+        return zTokenAddress[_name];
+    }
 
-    function setNGNUSD(uint256 _value) external onlyOwner {
-        _NGNUSD = _value;
+    function getZTokenList() external view returns(string[] memory){
+        return zTokenList;
     }
 
-    function setXAFUSD(uint256 _value) external onlyOwner {
-        _XAFUSD = _value;
+    function removeZToken(string calldata _name) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        require(zTokenAddress[_name] != address(0), "zToken does not exist");
+
+        delete zTokenAddress[_name];
+
+        uint256 index;
+        bytes32 nameHash = keccak256(bytes(_name));
+        uint len = zTokenList.length;
+
+        for (uint256 i; i < len; i++) {
+            if (keccak256(bytes(zTokenList[i])) == nameHash) {
+                index = i;
+                break;
+            }
+        }
+
+        if (index < len) {
+            zTokenList[index] = zTokenList[len - 1];
+            zTokenList.pop();
+        }
+
+        emit RemoveZToken(_name);
     }
 
-    function setZARUSD(uint256 _value) external onlyOwner {
-        _ZARUSD = _value;
+    function checkIfTokenExists(string calldata _name) public view returns(bool){
+        bytes32 nameHash = keccak256(bytes(_name));
+        uint len = zTokenList.length;
+
+        for (uint256 i; i < len; i++) {
+            if (keccak256(bytes(zTokenList[i])) == nameHash) {
+                return true;
+            }
+        }
+        return false;
     }
 
-    function NGNUSD() external view override returns (uint256) {
-        return _NGNUSD;
+
+    function setZTokenUSDValue(
+        string calldata _name,
+        uint256 _value
+    ) external onlyRole(DATA_FEED) {
+        address zToken = getZToken(_name);
+
+        require(_value >= 1, "Invalid value");
+
+        zTokenUSDValue[zToken] = _value;
+
+        emit SetZTokenUSDValue(_name, _value);
     }
 
-    function XAFUSD() external view override returns (uint256) {
-        return _XAFUSD;
+    function getZTokenUSDValue(
+        string calldata _name
+    ) external view returns (uint256) {
+        address zToken = getZToken(_name);
+
+        return zTokenUSDValue[zToken];
     }
 
-    function ZARUSD() external view override returns (uint256) {
-        return _ZARUSD;
+    function setZCollateralUSD(uint256 _value) external onlyRole(DATA_FEED){
+
+        if (_value > 1000) {
+            collateralUSD = 1000;
+        } else {
+            collateralUSD = _value;
+        }
+
+        emit SetZCollateralUSD(_value);
     }
 }

contracts/Token.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.20;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "./interfaces/ZTokenInterface.sol";
+
+contract Token is ERC20, ZTokenInterface, Ownable {
+    // address private vault
+
+    /**
+    * Initializers
+     */
+   constructor(string memory name_, string memory symbol_, address admin_) ERC20(name_, symbol_) Ownable(admin_) {
+    }
+
+    event Mint(
+        address indexed _userAddress, 
+        uint256 _amount
+    );
+
+    event Burn(
+        address indexed _userAddress,
+        uint256 _amount
+    );
+
+
+    /**
+     * @dev these can only be called by the Vault contract
+     */
+    function mint(address _userAddress, uint256 _amount)
+        external
+        override
+        returns (bool)
+    {
+        _mint(_userAddress, _amount);
+
+        emit Mint(_userAddress, _amount);
+
+        return true;
+    }
+
+    function burn(address _userAddress, uint256 _amount)
+        external
+        override
+        returns (bool)
+    {
+        _burn(_userAddress, _amount);
+
+        emit Burn(_userAddress, _amount);
+
+        return true;
+    }
+
+   }