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) {

            disburse();

          }

    }



    // 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 {

          require(!wasSent);

          buyer.transfer(this.balance);

    }



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

    function expiredApproval() onlyOwner public {

          require(wasSent && !wasDelivered);

          wasDelivered = true;

          approved = true;

          disburse();

    }



    // Seller gets paid

    function redeemPayout() onlySeller public {

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

        payoutPaid = true;

        seller.transfer(payout);

    }



    // Escrow gets its commission

    function redeemEscrow() onlyOwner public {

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

        commissionPaid = true;

        owner.transfer(fee);

    }



    }