Overview of the Escrow Contract

The escrow contract will include the following features:

  • Parties Involved: A buyer and a seller.
  • Deposit Funds: The buyer deposits funds into the contract.
  • Release Funds: The seller can request the release of funds once the conditions are met.
  • Refund Mechanism: If the transaction is unsuccessful, the buyer can request a refund.

Escrow Contract Implementation

Below is the complete code for a simple escrow contract written in Solidity.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Escrow {
    address public buyer;
    address public seller;
    uint public amount;
    enum State { AWAITING_PAYMENT, AWAITING_DELIVERY, COMPLETE, REFUNDED }
    State public state;

    event PaymentDeposited(address indexed buyer, uint amount);
    event PaymentReleased(address indexed seller, uint amount);
    event RefundIssued(address indexed buyer, uint amount);

    modifier onlyBuyer() {
        require(msg.sender == buyer, "Only buyer can call this function");
        _;
    }

    modifier onlySeller() {
        require(msg.sender == seller, "Only seller can call this function");
        _;
    }

    modifier inState(State _state) {
        require(state == _state, "Invalid state for this operation");
        _;
    }

    constructor(address _seller) {
        buyer = msg.sender;
        seller = _seller;
        state = State.AWAITING_PAYMENT;
    }

    function deposit() external payable onlyBuyer inState(State.AWAITING_PAYMENT) {
        require(msg.value > 0, "Deposit must be greater than zero");
        amount = msg.value;
        state = State.AWAITING_DELIVERY;
        emit PaymentDeposited(buyer, amount);
    }

    function releasePayment() external onlySeller inState(State.AWAITING_DELIVERY) {
        payable(seller).transfer(amount);
        state = State.COMPLETE;
        emit PaymentReleased(seller, amount);
    }

    function issueRefund() external onlyBuyer inState(State.AWAITING_DELIVERY) {
        payable(buyer).transfer(amount);
        state = State.REFUNDED;
        emit RefundIssued(buyer, amount);
    }
}

Explanation of Key Components

  1. State Management: The contract uses an enum State to manage the various states of the escrow process:
  • AWAITING_PAYMENT: The initial state where the buyer can deposit funds.
  • AWAITING_DELIVERY: The state after the buyer has deposited funds, waiting for the seller to deliver the goods or services.
  • COMPLETE: The state indicating that the payment has been successfully released to the seller.
  • REFUNDED: The state indicating that the buyer has received their funds back.
  1. Modifiers:
  • onlyBuyer: Ensures that only the buyer can call certain functions.
  • onlySeller: Ensures that only the seller can call the release function.
  • inState: Checks that the contract is in the correct state for the operation being performed.
  1. Events: The contract emits events to log important actions, making it easier to track the flow of funds and state changes.

Interaction with the Escrow Contract

To interact with the escrow contract, here’s how the flow would work:

  1. Deployment: The contract is deployed by the seller, specifying their address.
  2. Deposit: The buyer calls the deposit function with Ether to initiate the escrow.
  3. Release Payment: Once the buyer confirms receipt of the goods/services, the seller can call releasePayment.
  4. Refund: If the transaction fails, the buyer can call issueRefund to get their money back.

Best Practices

  • Testing: Always test your smart contracts thoroughly using frameworks like Truffle or Hardhat. Consider edge cases, such as what happens if the buyer tries to issue a refund after the payment is released.
  • Security: Be cautious of reentrancy attacks. In this simple escrow contract, we use the checks-effects-interactions pattern to mitigate such risks.
  • Gas Optimization: Minimize state variables and use appropriate data types to save gas costs.

Conclusion

This tutorial provided a comprehensive guide to building a decentralized escrow system using Solidity. By implementing the features outlined above, you can create a secure and efficient way for two parties to engage in transactions without the need for a trusted intermediary.

Learn more with useful resources