Frontend dk

BACKENDHARDHAT/.gitignore

@@ -0,0 +1,11 @@
+node_modules
+.env
+coverage
+coverage.json
+typechain
+typechain-types
+
+#Hardhat files
+cache
+artifacts
+

BACKENDHARDHAT/README.md

@@ -0,0 +1,13 @@
+# Sample Hardhat Project
+
+This project demonstrates a basic Hardhat use case. It comes with a sample contract, a test for that contract, and a script that deploys that contract.
+
+Try running some of the following tasks:
+
+```shell
+npx hardhat help
+npx hardhat test
+REPORT_GAS=true npx hardhat test
+npx hardhat node
+npx hardhat run scripts/deploy.js
+```

BACKENDHARDHAT/contracts/Lock.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.9;
+
+// Uncomment this line to use console.log
+// import "hardhat/console.sol";
+
+contract Lock {
+    uint public unlockTime;
+    address payable public owner;
+
+    event Withdrawal(uint amount, uint when);
+
+    constructor(uint _unlockTime) payable {
+        require(
+            block.timestamp < _unlockTime,
+            "Unlock time should be in the future"
+        );
+
+        unlockTime = _unlockTime;
+        owner = payable(msg.sender);
+    }
+
+    function withdraw() public {
+        // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
+        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);
+
+        require(block.timestamp >= unlockTime, "You can't withdraw yet");
+        require(msg.sender == owner, "You aren't the owner");
+
+        emit Withdrawal(address(this).balance, block.timestamp);
+
+        owner.transfer(address(this).balance);
+    }
+}

BACKENDHARDHAT/contracts/SendcUSD.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^ 0.8.2;
+interface IERC20Token {
+  function transfer(address, uint256) external returns (bool);
+  function approve(address, uint256) external returns (bool);
+  function transferFrom(address, address, uint256) external returns (bool);
+  function totalSupply() external view returns (uint256);
+  function balanceOf(address) external view returns (uint256);
+  function allowance(address, address) external view returns (uint256);
+
+  event Transfer(address indexed from, address indexed to, uint256 value);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+contract sendCeloOrEth{
+    uint testbalance ;
+    address payable receiver;
+    address payable owner;
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    address internal cUsdTokenAddress = 0x874069Fa1Eb16D44d622F2e0Ca25eeA172369bC1;
+
+// constructor(){
+//     owner = payable (msg.sender);
+// }
+
+    function donatecUSD( address payable  _receiver)public payable {
+        receiver = _receiver;
+
+      _receiver.transfer(msg.value);
+
+
+
+
+
+    }
+    function checkBalance() public view  returns(uint){
+        return IERC20Token(cUsdTokenAddress).balanceOf(msg.sender);
+    }
+
+    function getbalanceofreceiver()public view returns(uint){
+        return IERC20Token(cUsdTokenAddress).balanceOf(receiver);
+    }
+
+    receive() external payable {
+            // React to receiving ether
+        }
+        fallback() external payable {
+            // React to receiving ether
+        }
+
+}

BACKENDHARDHAT/contracts/joincommunity.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^ 0.8.2;
+
+import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
+import "../node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+
+
+contract joinCommunity is  Ownable{ 
+
+    IERC20  Token;
+    IERC20  cUSDToken;
+    address payable myaddress = payable(0xC877733b142f44AF7e2FA8d29A7065e56FF851fa);
+    mapping(address => bool) public join;
+    uint256 public amount =10;
+    address internal cUsdTokenAddress = 0x874069Fa1Eb16D44d622F2e0Ca25eeA172369bC1;
+    constructor(){
+ cUSDToken = IERC20(cUsdTokenAddress);
+    }
+   /*
+   * @ dev Activate function to cast the rehema tokens to The IERC20
+
+   */
+    function activate(address _rehemaToken )public onlyOwner{
+ Token = IERC20(_rehemaToken);
+    } 
+     function joinCommunityy() public{
+       require(join[msg.sender] !=true,"already a member");
+
+
+
+        Token.transfer(msg.sender,amount);
+        join[msg.sender] =true;
+
+}
+/*
+* @dev : getrehema balance of a member
+*/
+ function getBalanceofMember()public view returns(uint){
+        return Token.balanceOf(msg.sender);
+    }
+    function shareRehemaTokens(address payable _receiver,uint _amount) public payable{
+      require(Token.balanceOf(msg.sender) >= _amount,"You have less rehema tokens please top up");
+       Token.transfer(_receiver,amount);
+    } 
+
+    /*
+    *@dev buy rehema tokens for cUsd 
+    */
+    function buyRehemaTokensForcUSD(uint256 _amount)public payable  {
+      require(cUSDToken.balanceOf(msg.sender) >= _amount,"low balance");
+
+     require(cUSDToken.approve(address(this),_amount));
+
+  require(
+            cUSDToken.transferFrom(
+                msg.sender,
+                address(this),
+                _amount
+            ),
+            "Transefer Failed"
+        );
+Token.transfer(msg.sender,_amount *10);
+    }
+    /*
+    *@dev but for ethereum*/
+    function buyRehemaTokenForETH(uint256 _amount)public payable{
+      require( msg.sender.balance >= _amount,"Less amount in the account");
+      payable(address(this)).transfer(_amount);
+      Token.transfer(msg.sender,_amount*10);
+
+    }
+function balances()public view  onlyOwner returns(uint){
+  return cUSDToken.balanceOf(address(this));
+
+}
+function balancesthis()public view  onlyOwner returns(uint){
+  return address(this).balance;
+
+}
+
+receive() external payable {}
+fallback() external payable{}
+
+}

BACKENDHARDHAT/contracts/rehemaTokens.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^ 0.8.2;
+import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
+import "../node_modules/@openzeppelin/contracts/token/ERC20/ERC20.sol";
+contract RehemaToken is ERC20 ,Ownable{
+
+
+   constructor() ERC20("Rehema","RH"){
+
+
+    }
+    function mintToken(uint _rehemaTokens,address _joincommu) public  onlyOwner  {
+        _mint(_joincommu,10**18*_rehemaTokens);
+    }
+
+
+
+
+
+}