Can't transfer value from mapping inside mapping

Question

The title of this issue might seem strange because I can't figure out exactly what the problem is. But here is what is happening:

pragma solidity ^0.4.13;

contract Escrow {
  address public owner;
  uint public fee;

  //Balances temporarily made public for testing; to be removed
  mapping (address =>  mapping (address => uint)) public balances;

  function Escrow() public {
    owner = msg.sender;
  }

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

  //Fee should be set in PPM
  function setFee(uint price) onlyOwner external {
    fee = price;
  }

  function start(address payee) payable external {
    balances[msg.sender][payee] = balances[msg.sender][payee] + msg.value;
  }

  function end(address payer, address payee) onlyOwner external {
    uint value = balances[payer][payee];
    //uint paidFee = value / (1000000 / fee);
    //uint payment = value - paidFee;
    //payee.transfer(payment);
    //owner.transfer(paidFee);
    //balances[payer][payee] = 0
    payee.transfer(value)
  }
}

I've commented out a bunch of lines that I would like to get working in the end function, because I can't get even the other parts working.

Steps:

1. Creat contract from first address in testRPC

2. I call start, from the second address in my testRPC, sending 2 ETH, to the last address: start("0xb631fc401038e191fa38c4ff20dcce8d13eb6ebc" , { from "0x1c34d277b51ec49536fe7843e289933e0f8020ed", value: 2000000000000000000000 })

3. I check: balances("0x1c34d277b51ec49536fe7843e289933e0f8020ed", "0xb631fc401038e191fa38c4ff20dcce8d13eb6ebc"), I see 0: uint256: 2000000000000000000 --So far so good.

4. This is where I get into trouble. If I call end("0x1c34d277b51ec49536fe7843e289933e0f8020ed", "0xb631fc401038e191fa38c4ff20dcce8d13eb6ebc"), I get: transact to Escrow.end errored: VM Exception while processing transaction: out of gas

If I change end to just return balances[payer][payee], I get 0.

If I change end to just transfer 1 ETH to payee, I get a gas error.

So I can't figure out what the source of this issue is. Can you give any advice?

Answer 1

end() method of this contract should be payable as there is transfer inside the method. And also use safeMath.sol of OpenZeppelin for any mathematical calculation inside contract. I rewrite the code. Please find:

safeMath.sol

pragma solidity ^0.4.21;

/**
 * @author OpenZeppelin
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a * b;
        assert(a == 0 || c / a == b);
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}

escrow.sol

pragma solidity ^0.4.21;

import './safeMath.sol';

contract Escrow {

    using SafeMath for uint;

    address public owner;
    uint public fee;

    mapping (address =>  mapping (address => uint)) public balances;

    function Escrow() public {
        owner = msg.sender;
    }

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

    //Fee should be set in PPM
    function setFee(uint price) onlyOwner external {
        fee = price;
    }

    function start(address payee) payable external {
        balances[msg.sender][payee] = balances[msg.sender][payee] + msg.value;
    }

    function end(address payer, address payee) onlyOwner payable external {
        uint value = balances[payer][payee];
        uint paidFee = value.div(uint(1000000).div(fee));
        uint payment = value.sub(paidFee);
        payee.transfer(payment);
        owner.transfer(paidFee);
        balances[payer][payee] = 0;
        payee.transfer(value);
    }
}

Answer 2

The code you pasted here works fine, except the forgotton ; at payee.transfer(value).

My guess is that as the error says, you simply didn't provide enough gas.

Answer 3

I think you need to add the from account in step 4, like you have in step 2 but without any value. Otherwise it doesn't know what account to charge for gas.

Answer 4

From your code

function start(address payee) payable external {
    balances[msg.sender][payee] = balances[msg.sender][payee] + msg.value;
  }

To call this function ,

start("0xb631fc401038e191fa38c4ff20dcce8d13eb6ebc" , { from "0x1c34d277b51ec49536fe7843e289933e0f8020ed", value: 2000000000000000000000 })

You passed Value and now your value is stored on balances[msg.sender][payee] finally after adding.
Lets jump on second function

function end(address payer, address payee) onlyOwner external {
    uint value = balances[payer][payee];
     payee.transfer(value);  
  }

for the first time you transact this function then all your value is transferred to an address of payee.
for the second time you transact this function then you have no value left then you get the vm error.

If you have not did this mistake then check web3js. please pass optional parameter.

end("0x1c34d277b51ec49536fe7843e289933e0f8020ed", "0xb631fc401038e191fa38c4ff20dcce8d13eb6ebc",{from,gasPrice,gas})

options - Object (optional): The options used for calling.
        from - String (optional): The address the call “transaction” should be made from.
        gasPrice - String (optional): The gas price in wei to use for this call “transaction”.
        gas - Number (optional): The maximum gas provided for this call “transaction” (gas limit).