I have a public uint variable denoting 'which round' it is and a function that advances rounds and does processing alongside the round advancement:

       uint public round;

       function completeRound() public inPaused() inRound() {
            if (round == 6) {
              // win
          } else {

If i run this in remix, it runs 4 times and then consistently fails on the 5th, indicating that a function suddenly needs to be payable:

transact to Playingwithsmartcontracts.completeRound errored: VM error: revert. revert The transaction has been reverted to the initial state. Note: The called function should be payable if you send value and the value you send should be less than your current balance. Debug the transaction to get more information.

If I comment out round.add(1) right under where reduceByHalf is called, the code works all day long. I can click it indefinitely with no errors in Remix.

Strangely, this started as an Enum to track the rounds and that had the same exact problem. While advancing the enum, i could do it 5 times before the above failure and commenting it out made everything work.

reduceByHalf code doesnt seem to be the offender, but it is shown below in case it has a bearing on the problem:

    struct Foo {
        address owner;
        uint mintedRound;
        uint winningRound;
    struct FooOwner {
        uint[] foos;
        uint totalWinningFoos;

    uint[][5] roundFoos;
    uint[][5] roundWinners;

    mapping(uint => Foo) public winningFoos;
    mapping(address => FooOwner) public fooOwners;

    uint totalWinningFoos;

    function shuffleFoos (uint256[] memory _array) internal view returns(uint[] memory){
        uint[] memory clone = cloneArray(_array, _array.length);
        for (uint256 i = 0; i < clone.length; i++) {
            uint256 n = i + uint256(keccak256(abi.encodePacked(msg.sender, block.timestamp))) % (clone.length - i);
            uint256 temp = clone[n];
            clone[n] = clone[i];
            clone[i] = temp;
        return clone;
    function cloneArray(uint256[] memory _array, uint256 _length) internal pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](_length);
        for (uint256 i = 0; i < _length; i++) {
            array[i] = _array[i];
        return array;

    function reduceByHalf() internal  {
        uint[] memory clone = shuffleFoos(roundFoos[round]);
        uint halfLength = 0;

        halfLength = roundFoos[round].length.div(2);
        for (uint w = 0; w < halfLength; w++) {
           uint fooId = clone[w];
           winningFoos[round].winningRound = round;
           address fooOwner = winningFoos[fooId].owner;
           fooOwners[fooOwner].totalWinningFoos = fooOwners[fooOwner].totalWinningFoos.add(1);    
        totalWinningFoos = totalWinningFoos.add(halfLength);

As far as I know, I am not sending value, and not sure why it only thinks im sending value on transaction execution 5.

Would anyone be able to help me understand what Remix/Solidity is mad about?

  • Supplied code doesn't compile, and it is too complex to try to guess what is missing. The only suspicious thing is the declaration uint[][5] x. I'd say solidity is odd, for a C/C++ like language it would interpret as an array of (uint[5]), for solidity it is an array of 5 (uint[]). – Ismael May 1 at 21:16

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Browse other questions tagged or ask your own question.