Land Registry

 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
 
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
 
contract LandRegistry is
    ERC721,
    ERC721Enumerable,
    ERC721URIStorage,
    AccessControl,
    ReentrancyGuard,
    Pausable,
    EIP712
{
    using Counters for Counters.Counter;
    using SafeMath for uint256;
    using ECDSA for bytes32;
 
    // ========== CONSTANTS ==========
    bytes32 public constant REGISTRAR_ROLE = keccak256("REGISTRAR_ROLE");
    bytes32 public constant DISPUTE_RESOLVER_ROLE = keccak256("DISPUTE_RESOLVER_ROLE");
    bytes32 public constant TAX_AUTHORITY_ROLE = keccak256("TAX_AUTHORITY_ROLE");
    bytes32 public constant COURT_ROLE = keccak256("COURT_ROLE");
 
    // ========== STRUCTS ==========
    struct PaymentDetail {
        string paymentReference;
        string currency; // ISO 4217
        uint256 amount;
        bool isForeign;
        string sourceBank;
        string proofOfPayment;
        uint256 timestamp;
    }
 
    struct LandParcel {
        uint256 id;
        string parcelNumber;
        address owner;
        uint256 area; // sqm with 4 decimals
        string gpsPolygon; // GeoJSON
        string jurisdiction;
        string landUseType; // RESIDENTIAL/COMMERCIAL/AGRICULTURAL
        uint256 landRate; // Local currency per sqm
        bool hasDispute;
        uint256[] buildingIds;
        uint256[] parentParcels; // For merged/split parcels
        PaymentDetail[] paymentHistory;
        uint256 lastTaxPaid;
        string ipfsHash;
    }
 
    struct Building {
        uint256 id;
        string name;
        uint256 stories;
        uint256 builtArea;
        string constructionType;
    }
 
    struct SplitMergeRequest {
        uint256[] parcelIds;
        uint256[] newAreas;
        string[] newParcelNumbers;
        string[] newGpsPolygons;
        bool isMerge;
        bool approved;
        bytes[] approvalSignatures;
    }
 
    // ========== STATE VARIABLES ==========
    Counters.Counter private _parcelIdCounter;
    Counters.Counter private _buildingIdCounter;
 
    mapping(uint256 => LandParcel) private _parcels;
    mapping(uint256 => Building) private _buildings;
    mapping(string => bool) private _usedNationalIds;
    mapping(bytes32 => bool) private _usedSignatures;
    mapping(uint256 => SplitMergeRequest) private _splitMergeRequests;
    mapping(uint256 => uint256) private _parcelToRequest;
 
    uint256 public baseTaxRate = 100; // 1%
    uint256 public foreignTransferSurcharge = 200; // +2%
    uint256 public lateTaxPenalty = 50; // 0.5% per month
    uint256 public governanceApprovalThreshold = 2;
 
    // ========== EVENTS ==========
    event ParcelRegistered(uint256 indexed id, address owner);
    event ParcelTransferred(uint256 indexed id, address from, address to, uint256 taxPaid);
    event BuildingAdded(uint256 indexed parcelId, uint256 buildingId);
    event TaxPaid(uint256 indexed parcelId, uint256 amount, string currency);
    event DisputeFiled(uint256 indexed parcelId, string details);
    event DisputeResolved(uint256 indexed parcelId);
    event SplitRequested(uint256 indexed requestId, uint256 indexed originalParcelId);
    event MergeRequested(uint256 indexed requestId, uint256[] sourceParcelIds);
    event SplitCompleted(uint256 indexed requestId, uint256[] newParcelIds);
    event MergeCompleted(uint256 indexed requestId, uint256 newParcelId);
 
    // ========== MODIFIERS ==========
    modifier onlyRegistrar() {
        require(hasRole(REGISTRAR_ROLE, msg.sender), "Unauthorized: Registrar only");
        _;
    }
 
    modifier onlyTaxAuthority() {
        require(hasRole(TAX_AUTHORITY_ROLE, msg.sender), "Unauthorized: Tax authority only");
        _;
    }
 
    modifier noActiveRequest(uint256 parcelId) {
        require(_parcelToRequest[parcelId] == 0, "Parcel has active request");
        _;
    }
 
    // ========== CONSTRUCTOR ==========
    constructor()
        ERC721("NationalLandToken", "NLT")
        EIP712("LandRegistry", "1")
    {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(REGISTRAR_ROLE, msg.sender);
    }
 
    // ========== PAUSE/UNPAUSE FUNCTIONS ==========
    function pause() external onlyRole(DEFAULT_ADMIN_ROLE) {
        _pause();
    }
 
    function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) {
        _unpause();
    }
 
    // ========== CORE FUNCTIONS ==========
 
    function registerParcel(
        address owner,
        string memory parcelNumber,
        uint256 area,
        string memory gpsPolygon,
        string memory jurisdiction,
        string memory landUseType,
        uint256 landRate,
        string memory nationalId,
        string memory ipfsHash,
        bytes memory kycSignature
    ) external onlyRegistrar nonReentrant returns (uint256) {
        require(!_usedNationalIds[nationalId], "National ID already registered");
        require(_verifyKYC(owner, nationalId, kycSignature), "KYC verification failed");
 
        uint256 parcelId = _parcelIdCounter.current();
        _parcelIdCounter.increment();
 
        _parcels[parcelId] = LandParcel({
            id: parcelId,
            parcelNumber: parcelNumber,
            owner: owner,
            area: area,
            gpsPolygon: gpsPolygon,
            jurisdiction: jurisdiction,
            landUseType: landUseType,
            landRate: landRate,
            hasDispute: false,
            buildingIds: new uint256[](0),
            parentParcels: new uint256[](0),
            paymentHistory: new PaymentDetail[](0),
            lastTaxPaid: 0,
            ipfsHash: ipfsHash
        });
 
        _mint(owner, parcelId);
        _setTokenURI(parcelId, ipfsHash);
        _usedNationalIds[nationalId] = true;
 
        emit ParcelRegistered(parcelId, owner);
        return parcelId;
    }
 
    // ========== PARCEL TRANSFER & TAXATION ==========
    function transferParcel(
        uint256 parcelId,
        address buyer,
        string memory buyerNationalId,
        PaymentDetail memory payment
    ) external onlyRegistrar nonReentrant noActiveRequest(parcelId) {
        require(!_parcels[parcelId].hasDispute, "Parcel has active dispute");
        require(!_usedNationalIds[buyerNationalId], "Buyer ID already registered");
 
        address seller = _parcels[parcelId].owner;
 
        // Calculate tax
        uint256 taxRate = payment.isForeign ?
            baseTaxRate.add(foreignTransferSurcharge) : baseTaxRate;
        uint256 taxAmount = payment.amount.mul(taxRate).div(10000);
 
        // Record payment and tax
        _parcels[parcelId].paymentHistory.push(payment);
        _parcels[parcelId].paymentHistory.push(PaymentDetail({
            paymentReference: string(abi.encodePacked("TAX-", payment.paymentReference)),
            currency: payment.currency,
            amount: taxAmount,
            isForeign: payment.isForeign,
            sourceBank: "National Treasury",
            proofOfPayment: string(abi.encodePacked("TAX-RECEIPT-", payment.paymentReference)),
            timestamp: block.timestamp
        }));
        _parcels[parcelId].lastTaxPaid = block.timestamp;
 
        // Execute transfer
        _transfer(seller, buyer, parcelId);
        _parcels[parcelId].owner = buyer;
        _usedNationalIds[buyerNationalId] = true;
 
        emit ParcelTransferred(parcelId, seller, buyer, taxAmount);
        emit TaxPaid(parcelId, taxAmount, payment.currency);
    }
 
    // ========== BUILDING MANAGEMENT ==========
    function addBuilding(
        uint256 parcelId,
        string memory name,
        uint256 stories,
        uint256 builtArea,
        string memory constructionType
    ) external onlyRegistrar returns (uint256) {
        uint256 buildingId = _buildingIdCounter.current();
        _buildingIdCounter.increment();
 
        _buildings[buildingId] = Building({
            id: buildingId,
            name: name,
            stories: stories,
            builtArea: builtArea,
            constructionType: constructionType
        });
 
        _parcels[parcelId].buildingIds.push(buildingId);
        emit BuildingAdded(parcelId, buildingId);
        return buildingId;
    }
 
    // ========== PARCEL SPLIT/MERGE ==========
    function requestSplit(
        uint256 parcelId,
        uint256[] memory newAreas,
        string[] memory newParcelNumbers,
        string[] memory newGpsPolygons
    ) external onlyRegistrar noActiveRequest(parcelId) {
        require(newAreas.length > 1, "Must split into at least 2 parcels");
        require(newAreas.length == newParcelNumbers.length, "Mismatched arrays");
        require(newAreas.length == newGpsPolygons.length, "Mismatched polygons");
        require(!_parcels[parcelId].hasDispute, "Parcel has dispute");
 
        uint256 requestId = uint256(keccak256(abi.encodePacked(parcelId, block.timestamp)));
 
        _splitMergeRequests[requestId] = SplitMergeRequest({
            parcelIds: _asSingletonArray(parcelId),
            newAreas: newAreas,
            newParcelNumbers: newParcelNumbers,
            newGpsPolygons: newGpsPolygons,
            isMerge: false,
            approved: false,
            approvalSignatures: new bytes[](0)
        });
 
        _parcelToRequest[parcelId] = requestId;
        emit SplitRequested(requestId, parcelId);
    }
 
    function requestMerge(
        uint256[] memory parcelIds,
        string memory newParcelNumber
    ) external onlyRegistrar {
        require(parcelIds.length > 1, "Need multiple parcels to merge");
 
        uint256 requestId = uint256(keccak256(abi.encodePacked(parcelIds[0], block.timestamp)));
 
        _splitMergeRequests[requestId] = SplitMergeRequest({
            parcelIds: parcelIds,
            newAreas: new uint256[](0),
            newParcelNumbers: _asSingletonArray(newParcelNumber),
            newGpsPolygons: new string[](0),
            isMerge: true,
            approved: false,
            approvalSignatures: new bytes[](0)
        });
 
        for (uint i = 0; i < parcelIds.length; i++) {
            require(_parcelToRequest[parcelIds[i]] == 0, "Parcel has active request");
            _parcelToRequest[parcelIds[i]] = requestId;
        }
 
        emit MergeRequested(requestId, parcelIds);
    }
 
    function approveRequest(
        uint256 requestId,
        bytes memory signature
    ) external onlyRegistrar {
        SplitMergeRequest storage request = _splitMergeRequests[requestId];
        require(!request.approved, "Already approved");
 
        bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
            keccak256("SplitMergeApproval(uint256 requestId,bool isMerge)"),
            requestId,
            request.isMerge
        )));
        require(!_usedSignatures[digest], "Signature already used");
        address signer = digest.recover(signature);
        require(hasRole(REGISTRAR_ROLE, signer), "Invalid signer");
        _usedSignatures[digest] = true;
        request.approvalSignatures.push(signature);
 
        if (request.approvalSignatures.length >= governanceApprovalThreshold) {
            _executeRequest(requestId);
        }
    }
 
    // ========== DISPUTE RESOLUTION ==========
    function fileDispute(uint256 parcelId, string memory details)
        external
        onlyRole(DISPUTE_RESOLVER_ROLE)
        noActiveRequest(parcelId)
    {
        _parcels[parcelId].hasDispute = true;
        emit DisputeFiled(parcelId, details);
    }
 
    function resolveDispute(uint256 parcelId)
        external
        onlyRole(DISPUTE_RESOLVER_ROLE)
    {
        _parcels[parcelId].hasDispute = false;
        emit DisputeResolved(parcelId);
    }
 
    // ========== TAX ADMINISTRATION ==========
    function setTaxRate(uint256 newRate) external onlyTaxAuthority {
        require(newRate <= 1000, "Exceeds maximum 10% tax rate");
        baseTaxRate = newRate;
    }
 
    function collectDelayedTax(uint256 parcelId, uint256 monthsDelayed)
        external
        onlyTaxAuthority
    {
        uint256 penalty = _parcels[parcelId].landRate
            .mul(_parcels[parcelId].area)
            .mul(lateTaxPenalty)
            .mul(monthsDelayed)
            .div(10000);
 
        _parcels[parcelId].paymentHistory.push(PaymentDetail({
            paymentReference: string(abi.encodePacked("PENALTY-", parcelId)),
            currency: "LOCAL",
            amount: penalty,
            isForeign: false,
            sourceBank: "Tax Authority",
            proofOfPayment: string(abi.encodePacked("PENALTY-INVOICE-", parcelId)),
            timestamp: block.timestamp
        }));
 
        emit TaxPaid(parcelId, penalty, "LOCAL");
    }
 
    // ========== VIEW FUNCTIONS ==========
    function getParcelDetails(uint256 parcelId) public view returns (
        LandParcel memory parcel,
        Building[] memory buildings,
        PaymentDetail[] memory payments
    ) {
        parcel = _parcels[parcelId];
        buildings = new Building[](parcel.buildingIds.length);
 
        for (uint256 i = 0; i < parcel.buildingIds.length; i++) {
            buildings[i] = _buildings[parcel.buildingIds[i]];
        }
 
        return (parcel, buildings, parcel.paymentHistory);
    }
 
    function getRequestDetails(uint256 requestId) public view returns (
        SplitMergeRequest memory request,
        LandParcel[] memory parcels
    ) {
        request = _splitMergeRequests[requestId];
        parcels = new LandParcel[](request.parcelIds.length);
 
        for (uint i = 0; i < request.parcelIds.length; i++) {
            parcels[i] = _parcels[request.parcelIds[i]];
        }
    }
 
    // ========== PRIVATE FUNCTIONS ==========
    function _executeRequest(uint256 requestId) private {
        SplitMergeRequest storage request = _splitMergeRequests[requestId];
 
        if (request.isMerge) {
            _executeMerge(requestId);
        } else {
            _executeSplit(requestId);
        }
 
        request.approved = true;
    }
 
    function _executeSplit(uint256 requestId) private {
        SplitMergeRequest storage request = _splitMergeRequests[requestId];
        uint256 originalParcelId = request.parcelIds[0];
        LandParcel storage original = _parcels[originalParcelId];
 
        uint256[] memory newParcelIds = new uint256[](request.newAreas.length);
        uint256 totalArea = 0;
 
        for (uint i = 0; i < request.newAreas.length; i++) {
            totalArea = totalArea.add(request.newAreas[i]);
 
            uint256 newParcelId = _parcelIdCounter.current();
            _parcelIdCounter.increment();
 
            _parcels[newParcelId] = LandParcel({
                id: newParcelId,
                parcelNumber: request.newParcelNumbers[i],
                owner: original.owner,
                area: request.newAreas[i],
                gpsPolygon: request.newGpsPolygons[i],
                jurisdiction: original.jurisdiction,
                landUseType: original.landUseType,
                landRate: original.landRate,
                hasDispute: false,
                buildingIds: new uint256[](0),
                parentParcels: _asSingletonArray(originalParcelId),
                paymentHistory: original.paymentHistory,
                lastTaxPaid: original.lastTaxPaid,
                ipfsHash: original.ipfsHash // Default to original IPFS hash; update off-chain if necessary
            });
 
            _mint(original.owner, newParcelId);
            _setTokenURI(newParcelId, original.ipfsHash);
            newParcelIds[i] = newParcelId;
        }
 
        require(totalArea == original.area, "Area mismatch in split");
        _burn(originalParcelId);
        emit SplitCompleted(requestId, newParcelIds);
    }
 
    function _executeMerge(uint256 requestId) private {
        SplitMergeRequest storage request = _splitMergeRequests[requestId];
 
        // Verify parcels can be merged
        uint256 totalArea = 0;
        address commonOwner = _parcels[request.parcelIds[0]].owner;
        string memory commonJurisdiction = _parcels[request.parcelIds[0]].jurisdiction;
 
        for (uint i = 0; i < request.parcelIds.length; i++) {
            LandParcel storage parcel = _parcels[request.parcelIds[i]];
            require(parcel.owner == commonOwner, "Different owners");
            require(keccak256(bytes(parcel.jurisdiction)) == keccak256(bytes(commonJurisdiction)), "Different jurisdictions");
            require(!parcel.hasDispute, "Parcel has dispute");
 
            totalArea = totalArea.add(parcel.area);
        }
 
        // Create merged parcel
        uint256 newParcelId = _parcelIdCounter.current();
        _parcelIdCounter.increment();
 
        _parcels[newParcelId] = LandParcel({
            id: newParcelId,
            parcelNumber: request.newParcelNumbers[0],
            owner: commonOwner,
            area: totalArea,
            gpsPolygon: "", // To be set by off-chain service
            jurisdiction: commonJurisdiction,
            landUseType: _parcels[request.parcelIds[0]].landUseType,
            landRate: _calculateAverageRate(request.parcelIds),
            hasDispute: false,
            buildingIds: _combineBuildingIds(request.parcelIds),
            parentParcels: request.parcelIds,
            paymentHistory: _combinePaymentHistories(request.parcelIds),
            lastTaxPaid: block.timestamp,
            ipfsHash: "" // To be updated off-chain
        });
 
        _mint(commonOwner, newParcelId);
        // Optionally, set token URI when IPFS hash is available
        _setTokenURI(newParcelId, "");
 
        // Burn original parcels
        for (uint i = 0; i < request.parcelIds.length; i++) {
            _burn(request.parcelIds[i]);
            _parcelToRequest[request.parcelIds[i]] = 0;
        }
 
        emit MergeCompleted(requestId, newParcelId);
    }
 
    function _calculateAverageRate(uint256[] memory parcelIds) private view returns (uint256) {
        uint256 total = 0;
        for (uint i = 0; i < parcelIds.length; i++) {
            total = total.add(_parcels[parcelIds[i]].landRate);
        }
        return total.div(parcelIds.length);
    }
 
    function _combineBuildingIds(uint256[] memory parcelIds) private view returns (uint256[] memory) {
        uint256 totalBuildings = 0;
        for (uint i = 0; i < parcelIds.length; i++) {
            totalBuildings = totalBuildings.add(_parcels[parcelIds[i]].buildingIds.length);
        }
 
        uint256[] memory combined = new uint256[](totalBuildings);
        uint256 counter = 0;
 
        for (uint i = 0; i < parcelIds.length; i++) {
            for (uint j = 0; j < _parcels[parcelIds[i]].buildingIds.length; j++) {
                combined[counter] = _parcels[parcelIds[i]].buildingIds[j];
                counter++;
            }
        }
 
        return combined;
    }
 
    function _combinePaymentHistories(uint256[] memory parcelIds) private view returns (PaymentDetail[] memory) {
        uint256 totalPayments = 0;
        for (uint i = 0; i < parcelIds.length; i++) {
            totalPayments = totalPayments.add(_parcels[parcelIds[i]].paymentHistory.length);
        }
 
        PaymentDetail[] memory combined = new PaymentDetail[](totalPayments);
        uint256 counter = 0;
 
        for (uint i = 0; i < parcelIds.length; i++) {
            for (uint j = 0; j < _parcels[parcelIds[i]].paymentHistory.length; j++) {
                combined[counter] = _parcels[parcelIds[i]].paymentHistory[j];
                counter++;
            }
        }
 
        return combined;
    }
 
    function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;
        return array;
    }
 
    function _verifyKYC(address, string memory, bytes memory) private pure returns (bool) {
        return true; // Integration with KYC provider should be implemented
    }
 
    // ========== OVERRIDES ==========
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId,
        uint256 batchSize
    ) internal override(ERC721, ERC721Enumerable) {
        super._beforeTokenTransfer(from, to, tokenId, batchSize);
        require(!paused(), "Transfers paused");
        require(!_parcels[tokenId].hasDispute, "Parcel has dispute");
        require(_parcelToRequest[tokenId] == 0, "Parcel in split/merge process");
    }
 
    function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
        super._burn(tokenId);
    }
 
    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }
 
    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721Enumerable, AccessControl)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

ERC721 - For NFT-based land title representation
ERC721Enumerable - For efficient parcel indexing and listing
ERC721URIStorage - For decentralized metadata storage
AccessControl - For role-based permissions
ReentrancyGuard - For protection against reentrancy attacks
Pausable - For emergency circuit breaker functionality
EIP712 - For structured data signing