diff --git a/.github/workflows/blank.yml b/.github/workflows/blank.yml new file mode 100644 index 0000000..c622bbf --- /dev/null +++ b/.github/workflows/blank.yml @@ -0,0 +1,36 @@ +# This is a basic workflow to help you get started with Actions + +name: CI + +# Controls when the workflow will run +on: + # Triggers the workflow on push or pull request events but only for the "mainnet" branch + push: + branches: [ "mainnet" ] + pull_request: + branches: [ "mainnet" ] + + # Allows you to run this workflow manually from the Actions tab + workflow_dispatch: + +# A workflow run is made up of one or more jobs that can run sequentially or in parallel +jobs: + # This workflow contains a single job called "build" + build: + # The type of runner that the job will run on + runs-on: ubuntu-latest + + # Steps represent a sequence of tasks that will be executed as part of the job + steps: + # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it + - uses: actions/checkout@v3 + + # Runs a single command using the runners shell + - name: Run a one-line script + run: echo Hello, world! + + # Runs a set of commands using the runners shell + - name: Run a multi-line script + run: | + echo Add other actions to build, + echo test, and deploy your project. diff --git a/Burning.sol b/Burning.sol index 550ebb2..b1dbfed 100644 --- a/Burning.sol +++ b/Burning.sol @@ -4,14 +4,17 @@ import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./Iint.sol"; - +import "./Minting.sol"; +import "./IMinting.sol"; +import "./IGlipVault.sol"; contract TimechainProtocol is ReentrancyGuard{ // Define the structure for the protocol's Burning pool struct BurningPool { uint256 totalInputs; uint256 timeChainsLeft; mapping(uint=>mapping(uint=>uint)) slashingPercentage;//slashingpercent[number of investment][Amount]=slashpercent - mapping(uint => uint)amountStaked; + mapping(uint => uint)amountStaked;//Investment number-->amount staked + address Mintingaddress; uint256 noOfinvestments; address usdUsed; uint256 startingBlock; @@ -22,21 +25,23 @@ contract TimechainProtocol is ReentrancyGuard{ mapping(address => BurningPool) public BurningPools; // GLIPs vault to hold the slashed INT - mapping(address => uint256) public glipsVaultAmount; + // mapping(address => uint256) public glipsVaultAmount; address public stableCoin1; address public stableCoin2; address public stableCoin3; - address public stableCoin4; address public glipsVault; Iint public intToken; address public owner; - constructor(address _stableCoin1,address _stableCoin2,address _stableCoin3,address _stableCoin4,address _intToken) { + address public WeuFoundation; + constructor(address _stableCoin1,address _stableCoin2,address _stableCoin3,address _intToken,address weuFoundation,address _glipsVault) { stableCoin1 = _stableCoin1; stableCoin2=_stableCoin2; stableCoin3=_stableCoin3; - stableCoin4=_stableCoin4; + intToken=Iint(_intToken); + WeuFoundation= weuFoundation; + glipsVault =_glipsVault; owner = msg.sender; } @@ -51,7 +56,7 @@ contract TimechainProtocol is ReentrancyGuard{ require(_totalamount != 0,"the given amount cannot be equal to zero "); require(BurningPools[_protocolAddress].totalInputs == 0, "Burning pool already initialized"); require(BurningPools[_protocolAddress].noOfinvestments == 0,"The pool is already initialized"); - require(usdUsed == stableCoin1 || usdUsed == stableCoin2 || usdUsed ==stableCoin3 || usdUsed == stableCoin4 ,"The tokem used should be any one of them"); + require(usdUsed == stableCoin1 || usdUsed == stableCoin2 || usdUsed ==stableCoin3 ,"The tokem used should be any one of them"); BurningPools[_protocolAddress].totalInputs=_totalamount; BurningPools[_protocolAddress].timeChainsLeft=50; BurningPools[_protocolAddress].slashingPercentage[1][_totalamount]=2; @@ -59,6 +64,10 @@ contract TimechainProtocol is ReentrancyGuard{ BurningPools[_protocolAddress].amountStaked[1]=_totalamount; BurningPools[_protocolAddress].usdUsed=usdUsed; BurningPools[_protocolAddress].startingBlock = block.timestamp; + Minting minting=new Minting(); + address contaddress=address(minting); + IMinting(minting).initialize(usdUsed, WeuFoundation, address(intToken), _protocolAddress); + BurningPools[_protocolAddress].Mintingaddress=contaddress; //transfer the usd to this account,before that he need to give the approval for this contract IERC20(usdUsed).transferFrom(msg.sender,address(this),_totalamount); @@ -69,15 +78,17 @@ contract TimechainProtocol is ReentrancyGuard{ require(_protocolAddress!=address(0),"The address cannot be equal to zero address"); require(_totalamount != 0,"the given amount cannot be equal to zero "); BurningPool storage pool = BurningPools[_protocolAddress]; - + require(pool.noOfinvestments != 0,"The no of investments cannot be equal to zero "); + require(pool.Mintingaddress != address(0),"The pool Haven't initialized"); // Calculate the slashing percentage for the new supply of INT uint256 slashingPercentage = 100 / pool.timeChainsLeft; // Update the Burning pool data with the new inputs and slashing percentage pool.totalInputs += _totalamount; pool.noOfinvestments +=1; - pool.amountStaked[1]=_totalamount; + pool.amountStaked[pool.noOfinvestments]=_totalamount; pool.slashingPercentage[pool.noOfinvestments][_totalamount]=slashingPercentage; + IMinting(pool.Mintingaddress).InceaseMaxSupply(_totalamount); IERC20(pool.usdUsed).transferFrom(msg.sender,address(this),_totalamount); } @@ -100,7 +111,9 @@ contract TimechainProtocol is ReentrancyGuard{ // Update the Burning pool's total inputs after slashing pool.totalslashedAmount += slashedAmount; // Add the slashed amount to the GLIPs vault - glipsVaultAmount[msg.sender] += slashedAmount; + // glipsVaultAmount[msg.sender] += slashedAmount; + IERC20(pool.usdUsed).approve(glipsVault,slashedAmount); + IGlipVault(glipsVault).ReceiveAmount(_protocolAddress,slashedAmount,pool.usdUsed); // Decrease the number of timechains left pool.timeChainsLeft -= completedTimeChains; //send the amount to the glipsVault @@ -116,28 +129,29 @@ contract TimechainProtocol is ReentrancyGuard{ } - function burnandClaim(uint256 amount) external nonReentrant { + function burnandClaim(address _protocol,uint256 amount) external nonReentrant { require(amount!=0,"The address cannot be equal to zero address"); require(intToken.balanceOf(msg.sender)>= amount,"Not Sufficient Amount in your wallet"); - require(IERC20(stableCoin1).balanceOf(address(this))>=amount || IERC20(stableCoin2).balanceOf(address(this))>=amount || IERC20(stableCoin3).balanceOf(address(this))>=amount || IERC20(stableCoin4).balanceOf(address(this))>=amount,"No sufficient Amount in the pool"); - address currentStableCoin = findGreatest(stableCoin1, stableCoin2, stableCoin3, stableCoin4); + require(IERC20(stableCoin1).balanceOf(address(this))>=amount || IERC20(stableCoin2).balanceOf(address(this))>=amount || IERC20(stableCoin3).balanceOf(address(this))>=amount ); + BurningPool storage pool = BurningPools[_protocolAddress]; + require((block.timestamp - pool.startingBlock) >= 7 days,"The timechain had till not completed"); + address currentStableCoin = findGreatest(stableCoin1, stableCoin2, stableCoin3); + intToken.transferFrom(msg.sender,address(this),amount); intToken.burn(amount); IERC20(currentStableCoin).transfer(msg.sender,amount); } - function findGreatest(address _stableCoin1,address _stableCoin2,address _stableCoin3,address _stableCoin4) public view returns (address) { + function findGreatest(address _stableCoin1,address _stableCoin2,address _stableCoin3) public view returns (address) { // Using if-else statements address greatestCoin; - if ( IERC20(_stableCoin1).balanceOf(address(this))>= IERC20(_stableCoin2).balanceOf(address(this)) && IERC20(_stableCoin1).balanceOf(address(this)) >= IERC20(_stableCoin3).balanceOf(address(this)) && IERC20(_stableCoin1).balanceOf(address(this)) >= IERC20(_stableCoin4).balanceOf(address(this))) { + if ( IERC20(_stableCoin1).balanceOf(address(this))>= IERC20(_stableCoin2).balanceOf(address(this)) && IERC20(_stableCoin1).balanceOf(address(this)) >= IERC20(_stableCoin3).balanceOf(address(this)) ) { greatestCoin = _stableCoin1; - } else if (IERC20(_stableCoin2).balanceOf(address(this)) >= IERC20(_stableCoin1).balanceOf(address(this)) && IERC20(_stableCoin2).balanceOf(address(this)) >= IERC20(_stableCoin3).balanceOf(address(this)) && IERC20(_stableCoin2).balanceOf(address(this)) >= IERC20(_stableCoin4).balanceOf(address(this))) { + } else if (IERC20(_stableCoin2).balanceOf(address(this)) >= IERC20(_stableCoin1).balanceOf(address(this)) && IERC20(_stableCoin2).balanceOf(address(this)) >= IERC20(_stableCoin3).balanceOf(address(this))) { greatestCoin = _stableCoin2; - } else if (IERC20(_stableCoin3).balanceOf(address(this)) >= IERC20(_stableCoin1).balanceOf(address(this)) && IERC20(_stableCoin3).balanceOf(address(this)) >= IERC20(_stableCoin2).balanceOf(address(this)) && IERC20(_stableCoin3).balanceOf(address(this)) >= IERC20(_stableCoin4).balanceOf(address(this))) { + } else{ greatestCoin = _stableCoin3; - } else { - greatestCoin = _stableCoin4; - } + } return greatestCoin; } diff --git a/GlipsVault.sol b/GlipsVault.sol new file mode 100644 index 0000000..50cbd84 --- /dev/null +++ b/GlipsVault.sol @@ -0,0 +1,36 @@ +pragma solidity ^0.8.16; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +contract GlipsVault{ + + mapping(address => uint)public ProtocolAmount; + address public BurningPool; + address public Owner; + + constructor() + { + Owner=msg.sender; + } + modifier OnlyOwner() + { + require(msg.sender == Owner,"The owner needs to be msg.sender"); + _; + } + modifier OnlyBurning() + { + require(msg.sender == BurningPool,"The caller needs to be the burning contract"); + _; + } + function ReceiveAmount(address _protocol,uint _amount,address usdUsed)external OnlyBurning + { + require(_protocol != address(0),"The protocol address cannot be equal to address zero"); + require(_amount != 0,"The amount cannot be equal to zero "); + require(IERC20(usdUsed).allowance(BurningPool,address(this))>= _amount); + IERC20(usdUsed).transferFrom(BurningPool,address(this),_amount); + ProtocolAmount[_protocol]=_amount; + + } + function ChangeBurningContract(address _burningcontract)external OnlyOwner{ + require(_burningcontract != address(0),"The burning contract address cannot be equal to the zero address"); + BurningPool = _burningcontract; + } +} diff --git a/IBurning.sol b/IBurning.sol new file mode 100644 index 0000000..61ff1ad --- /dev/null +++ b/IBurning.sol @@ -0,0 +1,7 @@ +pragma solidity ^0.8.16; + +interface IBurning +{ + function initialize(uint,address,address,address)external; + function InceaseMaxSupply(uint)external; +} diff --git a/IGlipsVault.sol b/IGlipsVault.sol new file mode 100644 index 0000000..b99641a --- /dev/null +++ b/IGlipsVault.sol @@ -0,0 +1,7 @@ +pragma solidity ^0.8.16; + +interface IGlipVault +{ + function ReceiveAmount(address,uint ,address)external; + +} diff --git a/IMinting.sol b/IMinting.sol new file mode 100644 index 0000000..e98f02a --- /dev/null +++ b/IMinting.sol @@ -0,0 +1,7 @@ +pragma solidity ^0.8.16; + +interface IMinting +{ + function initialize(uint,address,address,address)external; + function InceaseMaxSupply(uint)external; +} diff --git a/INTtoken.sol b/INTtoken.sol index a66f1ce..aa07ce6 100644 --- a/INTtoken.sol +++ b/INTtoken.sol @@ -6,25 +6,27 @@ contract INT is ERC20 { address public weuFoundation; address public BurningAddress; address public Owner; + address public MintingAddress; constructor() ERC20("INT Token", "INPUT") { Owner = msg.sender; } - modifier onlyWEUFoundation() { - require(msg.sender == weuFoundation, "Only WEU Foundation can perform this action"); - _; - } modifier onlyOwner() { - require(msg.sender == owner, "Only WEU Foundation can perform this action"); + require(msg.sender == Owner, "Only WEU Foundation can perform this action"); _; } modifier onlyBurning(){ require(msg.sender == BurningAddress,"Only burning address can perform this action"); _; } + modifier onlyMinting() + { + require(msg.sender == MintingAddress,"Only Minting address can perform this action"); + _; + } - function mint(address account, uint256 amount) external onlyWEUFoundation { + function mint(address account, uint256 amount) external onlyMinting { require(account != address(0),"The account address should not be equal to zero address"); _mint(account, amount); } @@ -34,7 +36,7 @@ contract INT is ERC20 { weuFoundation = _weuFoundation; } - function changeBurningAddress(address _burningAddress)external onlyBurning{ + function changeBurningAddress(address _burningAddress)external onlyOwner{ require(_burningAddress != address(0),"The Burning address should not be equal to zero address"); BurningAddress = _burningAddress; } @@ -42,4 +44,29 @@ contract INT is ERC20 { _burn(msg.sender, amount); } -} \ No newline at end of file + function transfer(address to,uint256 value)public override virtual returns(bool) + { + require(msg.sender == weuFoundation,"the caller needs to be from WeuFoundation"); + address owner = _msgSender(); + _transfer(owner, to, value); + return true; + } + + function transferFrom(address _from,address _to,uint256 value)public override virtual returns(bool) + { + require(msg.sender == weuFoundation || msg.sender == BurningAddress,"the caller needs to be from WeuFoundation or the burning Contract"); + address spender = _msgSender(); + _spendAllowance(_from, spender, value); + _transfer(_from, _to, value); + return true; + } + + function approve(address spender,uint256 value)public override virtual returns(bool) + { + require(msg.sender == weuFoundation || spender == BurningAddress,"the caller needs to be from WeuFoundation or the to address needs to be the burning address"); + address owner = _msgSender(); + _approve(owner, spender, value); + return true; + } + +} diff --git a/Minting.sol b/Minting.sol index b2f1f91..0a9b926 100644 --- a/Minting.sol +++ b/Minting.sol @@ -1,42 +1,45 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.9; - -import "@openzeppelin/contracts/access/Ownable.sol"; -import "@openzeppelin/contracts/utils/math/SafeMath.sol"; - -contract MintingPool is Ownable { - using SafeMath for uint256; - - uint256 public timechain = 50; - uint256 public intToken = 1000000; - uint256 public slashPercentage = 2 * 10**6; // 2% represented as 2 * 10^6 (6 decimal places) - - // Function to burn and claim INT tokens based on the minting pool algorithm - function burnAndClaim() external onlyOwner returns (uint256) { - uint256 newSupply = 2000000; // Example: New inputs added to minting pool - - // Calculate the slashing percentage for the new supply - uint256 remainingTimechain = timechain.sub(5); // Assuming 5 timechain periods have passed - uint256 slashingPercentage = calculateSlashingPercentage(remainingTimechain); - - // Calculate the slashing amount for each portion - uint256 slashingAmountForExisting = intToken.mul(slashPercentage).div(10*8); // Divide by 10*8 due to 6 decimal places - uint256 slashingAmountForNew = newSupply.mul(slashingPercentage).div(10*8); // Divide by 10*8 due to 6 decimal places - - // Calculate the total slashed amount - uint256 totalSlashedAmount = slashingAmountForExisting.add(slashingAmountForNew); - - // Update the INT token balance in the minting pool after slashing - intToken = intToken.sub(totalSlashedAmount); - - // Decrease the timechain period - timechain--; - - return intToken; +pragma solidity ^0.8.16; + +import "./Iint.sol"; + + +contract Minting { + + uint public MaxSupply; + uint public PresentSupply; + address public BurningAddress; + mapping(address => uint) public Devamount; + address public WeuFoundation; + Iint public intToken; + address public ProtocolAddress; + modifier OnlyBurning(){ + require(msg.sender == BurningAddress,"The sender needs to be burning address"); + _; } - - // Function to calculate the slashing percentage for new supply based on the remaining timechain periods - function calculateSlashingPercentage(uint256 remainingTimechain) internal pure returns (uint256) { - return uint256(100 * 10*6).div(remainingTimechain); // Divide by 10*6 to get 6 decimal places + modifier OnlyFoundation(){ + require(msg.sender == WeuFoundation,"The sender needs to be WeuFoundation address"); + _; } -} \ No newline at end of file + constructor(){ + BurningAddress = msg.sender; + } + function initialize(uint _supply,address _weuFoundation,address _intToken,address _protocol)external OnlyBurning{ + require(ProtocolAddress == address(0),"The Protocol is already initialized"); + MaxSupply=_supply; + WeuFoundation=_weuFoundation; + intToken=Iint(_intToken); + ProtocolAddress =_protocol; + } + function InceaseMaxSupply(uint _supply)external OnlyBurning{ + require(_supply!=0,"The supply cannot be equal to zero "); + MaxSupply += _supply; + } + function mintSupply(uint _supply,address _dev)external OnlyFoundation { + require(_supply !=0 && _dev!=address(0),"The supply amount cannot be equal to zero and _dev address should not be equal to zero address"); + require(MaxSupply >= (PresentSupply+_supply)); + intToken.mint(_dev, _supply); + PresentSupply += _supply; + } + + +}