My Dapp work on the private testnet but not in the public one

Question

I have created this simple Dapp and it work fine in the private testnet & java VM inside Remix and outside it using a web interface. The problem come when it will be used in the "public" testnet (Ropsten). It send the transaction and execute the function but never send the ether from the contract to the address. I' ve already set the value of the contract to the correct value.

Sorry for bad English

pragma solidity ^0.4.0;

contract DApp
{
    uint256 acconto;
    uint256 saldo;
    address committent;
    address technician;
    bool done = false;
    uint timeFinish;

modifier onlyCom
{
    if (msg.sender != committent)
    {
        assert(true);
    }
    else
    {
        _;
    }
}

function DApp (uint256 _acconto, uint256 _saldo, address _technician, uint _Time) payable public
{
    if (msg.value >= _acconto + _saldo) {
    acconto = _acconto * 1000000000000000000;
    saldo = _saldo * 1000000000000000000;
    committent = msg.sender;
    technician = _technician;
    timeFinish = block.timestamp + _Time;

    technician.transfer(acconto);
    } else revert();
}

function Done () public onlyCom
{
    done = true;
}

function reciveReward () payable public
{
    if(done == true)
    {
        technician.transfer(saldo);
        selfdestruct(this);
    }
    else
    {
        if(block.timestamp >= timeFinish)
        {
            committent.transfer(saldo);
            selfdestruct(this);
        }

        assert(true);
    }
}
}

Edit: This is how it should work: I write the data for the transaction

In the photo I putted the value of contract with an error, I will correct it in the last photo. Basically now the deployer is paying 4 ether + transaction cost. The "acconto" goes directly to the technician address. The rest remains into the contract.

This is the change of money (In the first try only the first part of the contract worked fine because the value wasn' t enough)

I remaded the whole transaction at the receiveReward call the remaining part goes to technician and all worked as I wanted.

Why in the Ropsten Test Net it doesn' t work? It doesn' t send ether or am I looking in the wrong direction?

Answer 1

Try this, should be logically identical. I found a couple of syntax errors:

pragma solidity ^0.4.0;

contract DApp {
    uint256 acconto;
    uint256 saldo;
    address committent;
    address technician;
    bool started;
    uint256 timeFinish;

    modifier onlyCom() { require(msg.sender == committent); _; }
    modifier onlyAfter(uint _time) { require(now > _time); _; }

    constructor (uint256 _acconto, uint256 _saldo, address _technician) public {
        technician = _technician;
        committent = msg.sender;
        acconto = _acconto;
        saldo = _saldo;
        started = false;
    }

    function start(uint256 _time) public onlyCom() payable {
        require(started == false);
        require(msg.value >= acconto + saldo);
        started = true;
        timeFinish = now + _time;
        technician.transfer(acconto);
    }

    function good() public onlyCom() { selfdestruct(technician); }
    function bad() public onlyCom() onlyAfter(timeFinish) { selfdestruct(committent); }
}

Answer 2

Some issues that appears when switching from a private testnet to a public network:

• Not enough gas. Some IDEs and wallet can estimate the correct value of gas required by a transaction, but when your program creates the transaction it will use a default value that can be not enough (it used to be 100k).

• Gas price too low. In a private testnet often the price is fixed and all transactions will be processed. In a public testnet the gas price will fluctuate with the demand. Low gas price might cause a transaction to take longer to be mined.

• Not waiting for confirmation of the transaction. In a private testnet transactions are confirmed quickly, but in a public network your transaction have to compete with others pending transactions for space in blocks. It might take several blocks before your transaction is confirmed, and until them your contract will not reflect the changes made in the transaction.