slashedStakeWithProposal

[123456788940]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8;

import "./INT1.sol";
import "./IStaking.sol";
contract Evaluator {

Staking public stakingContract; // Reference to the staking contract
INTToken public INT;
uint totalTimechains=50 weeks;
uint public timechainDuration = 1 weeks;
uint public nextTimechainStart;
uint public selectedEvaluators;
address public owner;

struct _Evaluator {
address addr;
uint stake;
bool selected;

}

modifier onlyOwner(){
require(owner==msg.sender);
_;
}

mapping(address => _Evaluator) public evaluators;
address[] public selectedEvaluatorsQueue;

constructor(address _owner, address _INT, address _stakingContract) {
owner = _owner;
INT =INTToken(_INT);
stakingContract = Staking(_stakingContract); // Initialize the staking contract address
nextTimechainStart = block.timestamp + timechainDuration;
totalTimechains=50 weeks;
}

function takeEvaluatorRole(uint _stake) public {
uint _minStake = stakingContract.minStake(); // Get the minimum stake from the staking contract
require(!evaluators[msg.sender].selected, "evaluator not selected");
require(_stake >= _minStake, "Minimum stake not met");

require(block.timestamp <= nextTimechainStart, "Timechain ended");

require(selectedEvaluators <= 4, "Must not be more or less");
require(INT.transferFrom(msg.sender, address(this), _stake));

evaluators[msg.sender] = _Evaluator({
    addr: msg.sender,
    stake: _stake,
    selected: true
  
});

}

function addEvaluator(address evaluator) public onlyOwner{
require(msg.sender == owner, "Only owner has access");
require(evaluators[msg.sender].selected, "evaluator not selected");
selectedEvaluatorsQueue.push(evaluator);
selectedEvaluators++;
}

// Function to trigger the start of a new timechain
function startNewTimechain() public onlyOwner {
require(block.timestamp >= nextTimechainStart, "Timechain not ended yet");
totalTimechains-=1; // decrease the total timechains count
nextTimechainStart = block.timestamp + timechainDuration;
}

}

[123456788940]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8;
import "./INT1.sol";
import "./Riccis.sol";

contract _Proposal {
uint public _minStake;
INTToken public INT;
Staking public stakingContract;

struct Proposal {
address proposer;
uint stake;
uint endorsementCount;
bool isEndorsed;

}

Proposal[] public proposals;

uint public totalProposals;
address public councilMember;

event ProposalResult(bool indexed isAccepted, uint indexed proposalIndex);

constructor(address _councilMember, INTToken _INTToken, Staking _stakingContract) {
councilMember = _councilMember;
INT = INTToken(_INTToken);
stakingContract=Staking(_stakingContract);
}

function propose(bool _isPublicProposal, uint _stake) external payable {
_minStake = stakingContract.minStake();
require(INT.transferFrom(msg.sender, address(this), _stake), "Transfer failed");
require(_stake >= _minStake, "one must pay 10 tokens");
proposals.push(Proposal({
proposer: msg.sender,
stake: _stake,
endorsementCount: 0,
isEndorsed: _isPublicProposal

}));
totalProposals++;

}

function finalizeProposal(uint256 _proposalIndex) external {
require(_proposalIndex < proposals.length, "Invalid proposal index");
require(msg.sender == councilMember, "Only council members can finalize proposals");

require(!proposals[_proposalIndex].isEndorsed);

proposals[_proposalIndex].isEndorsed=true;
emit ProposalResult(true, _proposalIndex);
}
}

[123456788940]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8;
import "./INT1.sol";
import "./Riccis.sol";

contract _Proposal {
uint public _minStake;
INTToken public INT;
Staking public stakingContract;
struct Proposal {
address proposer;
uint stake;
uint endorsementCount;
bool isEndorsed;
bool isAccepted;
}

Proposal[] public proposals;

uint public totalProposals;
address public councilMember;

event ProposalResult(bool indexed isAccepted, uint indexed proposalIndex);

constructor(address _councilMember, INTToken _INTToken, Staking _stakingContract) {
councilMember = _councilMember;
INT = INTToken(_INTToken);
stakingContract=Staking(_stakingContract);
}

function propose(bool _isTreasuryProposal, uint _stake) external payable {
_minStake = stakingContract.minStake();

    require(INT.transferFrom(msg.sender, address(this), _stake), "Transfer failed");

require(_stake >= _minStake);
proposals.push(Proposal({
proposer: msg.sender,
stake: _stake,
endorsementCount: 0,
isEndorsed: _isTreasuryProposal,
isAccepted: false
}));
totalProposals++;

}

function finalizeProposal(uint256 _proposalIndex) external {
require(_proposalIndex <= proposals.length, "Invalid proposal index");
require(msg.sender == councilMember, "Only council members can finalize proposals");

require(!proposals[_proposalIndex].isEndorsed);

proposals[_proposalIndex].isEndorsed=true;
emit ProposalResult(true, _proposalIndex);

}
}

[123456788940]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8;

contract Staking {
Staking public stakingContract;
uint public minStake;
mapping(uint=>_stake) public Stake;
struct _stake{
bool staked;
bool withdrawn;
}

constructor(uint _minimumStake) {
    // Initialize the staking contract reference
    stakingContract = Staking(address(this));
    minStake=_minimumStake;
}

// Function to set the minimum stake requirement
function setMinimumStake(uint _minimumStake) external {
    require(msg.sender == address(this), "Only the staking contract can set the minimum stake");
    minStake = _minimumStake;
}

// Function to get the minimum stake requirement
function minimumStake() external view returns (uint) {
    return minStake;
}

// Function to allow users to stake tokens
function stakeTokens(uint _amount) external {
    require(_amount >= minStake, "Amount is less than the minimum stake");
    require(!Stake[_amount].staked);
    Stake[_amount].staked=true;
    
   
}

}

[123456788940]

@shivasai780 this is for you to see

[123456788940]

Yes, in Solidity, when you declare an array or use an index to access elements, the indexing starts from 0. So, if you have an array with a length of 4, for example, the valid indices to access elements in that array would be 0, 1, 2, and 3. This means that there are a total of 4 elements in the array, and if you add one more element, the array would have a length of 5, and the valid indices would then be 0, 1, 2, 3, and 4.

[shivasai780]

@123456788940 you can put a modifier for only owner
and also you kept the next timechain in the constructor means it will only execute once ,after that how you will get or update the next timechain again

[123456788940]

@shivasai780 for you to see