Constructing an Ethereum Escrow Contract

We need a sophisticated escrow contract where the payment is to be split upon delivery of goods between the seller and the escrow (that gets a commission).

The escrow contract is deployed by the escrow which is the owner of the contract.

The buyer has to pay, upon which the seller should deliver the goods within a fixed time. If not delivered in time, the buyer is fully refunded. Otherwise, the buyer has a fixed time duration to approve or decline the goods. If neither approved nor declined, within the time frame, it is considered approved.

If the buyer declined the goods, it receives a full refund. If the buyer approved the goods, the payment is split between the escrow and the seller.

    contract Escrypto {

        bool wasPaid;

        bool wasSent;

        bool wasDelivered;

        bool commissionPaid;

        bool payoutPaid;

        bool approved;

        uint256 timeToDeliver;

        uint256 timeToApprove;

        uint256 paymentTime;

        uint256 commissionPercentage;

        address owner;

        address buyer;

        address seller;

        uint256 fee;

        uint256 payout;

    modifier canStillDeliver() {

            now < paymentTime + timeToDeliver;



    modifier canStillApprove() {

            now < paymentTime + timeToDeliver + timeToApprove;



    modifier onlySeller() {

            require(msg.sender == seller);



    modifier onlyBuyer() {

            require(msg.sender == buyer);



    modifier onlyOwner() {

            require(msg.sender == owner);



    constructor(uint256 _timeToDeliver, uint256 _timeToApprove, address _buyer, address _seller, uint256 _commissionPercentage) public {

            timeToDeliver = _timeToDeliver;

            timeToApprove = _timeToApprove;

            buyer = _buyer;

            seller = _seller;

            commissionPercentage = _commissionPercentage;


    // Buyer pays

    function pay() public payable {

            wasPaid = true;

            paymentTime = now;


    // Seller sent the goods

    function sent() canStilDeliver onlySeller public {

            wasSent = true;


    // Goods arrived and approved by buyer

    function arrived(bool _approved) canStillApprove onlyBuyer public {

          wasDelivered = true;

          if (_approved) {




    // Split the money between the seller and the escrow

    function disburse() internal {

          fee = (this.balance).mul(commissionPercentage).div(100);

          payout = this.balance.sub(fee);


    //   Nothing sent in time, refund the buyer in full

    function expiredDeliver() onlyOwner public {




    // Buyer did not approve or decline in time, refund the buyer in full

    function expiredApproval() onlyOwner public {

          require(wasSent && !wasDelivered);

          wasDelivered = true;

          approved = true;



    // Seller gets paid

    function redeemPayout() onlySeller public {

        require(wasDelivered && !payoutPaid && appproved);

        payoutPaid = true;



    // Escrow gets its commission

    function redeemEscrow() onlyOwner public {

        require(wasDelivered && !commissionPaid && approved);

        commissionPaid = true;