Exploring a Rental Agreement Smart Contract

In the world of blockchain and smart contracts, real-world processes can be automated with transparency and security. In this article, we’ll delve into a simplified example of a “Rental Agreement” smart contract and break down its key components.

Understanding the Contract

Let’s dissect this Solidity smart contract:

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

contract RentalAgreement {
    address public landlord;
    address public tenant;
    uint256 public rentAmount;
    uint256 public depositAmount;
    uint256 public leaseDuration;
    uint256 public startTime;
    bool public isActive;
    bool public isTerminated;

    modifier onlyLandlord() {
        require(msg.sender == landlord, "Only the landlord can call this function");
        _;
    }

    modifier onlyTenant() {
        require(msg.sender == tenant, "Only the tenant can call this function");
        _;
    }

    modifier isActiveContract() {
        require(isActive, "This contract is not active");
        _;
    }

    constructor() {
        landlord = 0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B;
        tenant = 0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c;
        rentAmount = 2000 ether;
        depositAmount = 4000 ether;
        leaseDuration = 30 days;
        startTime = block.timestamp;
        isActive = true;
        isTerminated = false;
    }

    function payRent() public onlyTenant isActiveContract payable {
        require(msg.value == rentAmount, "Incorrect rent amount");

        // Record rent payment and update contract status
        // For this example, we'll assume that the rent payment is successfully recorded.
        // You could add more complex logic to track payments and update the contract accordingly.
        // For demonstration purposes, we'll update the contract status to indicate a successful rent payment.
        isActive = true; // Rent payment received, contract remains active.
    }

    function terminateContract() public onlyLandlord isActiveContract {
        require(block.timestamp >= startTime + leaseDuration, "Lease duration not completed");

        // Logic to terminate the contract and return deposit
        // For this example, we'll assume that the contract termination and deposit return are successful.
        // You could add more complex logic to handle termination and deposit return securely.
        // For demonstration purposes, we'll update the contract status and return the deposit to the tenant.
        isTerminated = true; // Contract terminated.
        isActive = false;    // Contract is no longer active.
        payable(tenant).transfer(depositAmount); // Return deposit to tenant.
    }
}

Key Components

• Landlord and Tenant: Ethereum addresses of the landlord and tenant involved in the rental agreement.
• Rent and Deposit: Amounts of rent and security deposit, specified in ether.
• Lease Duration: Duration of the lease in seconds (30 days in this example).
• isActive and isTerminated: Boolean flags indicating the status of the contract.

Contract Functionality

This smart contract allows:

• The tenant to payRent with the correct rent amount, recording the payment and updating the contract status.
• The landlord to terminateContract after the lease duration, returning the deposit to the tenant.

Conclusion

Smart contracts, like this “Rental Agreement” example, showcase the potential of blockchain technology to automate and enhance real-world processes. However, it’s important to remember that real-world contracts involve legal and regulatory considerations that must be addressed when implementing such solutions.