רישום נכסים מבוסס בלוקצ'יין: חוזים חכמים, NFTs, נאמנות

עבדנו על פרויקטים שבהם מרשמי נכסים מסורתיים עיכבו עסקאות ב-4–6 שבועות, והיסטוריית הבעלות אבדה בארכיוני נייר. מרשם נכסים מבוסס בלוקצ'יין פותר בעיות אלה: שרשרת העברות בעלות שקופה, עסקאות אטומיות (העברה בו-זמנית של NFT ותשלום באמצעות נאמנות), בעלות חלקית להשקעות, ותנאי העברה הניתנים לתכנות. הפלטפורמה שלנו משתמשת בטוקני ERC-721 לטוקניזציה של נדל"ן, ומאפשרת רישום בעלות על בלוקצ'יין ומרשם מבוזר. חוזים חכמים לנדל"ן הופכים עסקאות לאוטומטיות, בעוד חוזי נאמנות חכמים מבטיחים החלפות מאובטחות. מרשם כזה מהיר פי מאות מנייר — עסקה אורכת 5–15 דקות במקום שבועות. יישמנו 10+ פרויקטים, כולל מרשמים לנדל"ן מסחרי וטוקניזציה של מגרשים. פיתוח MVP מתחיל ב-$15,000, והלקוחות שלנו חוסכים עד 80% בעלויות משפטיות באמצעות אוטומציה. נבחן את הפרויקט שלך תוך 24 שעות — צור קשר.

ההקשר המשפטי: האתגר הראשון

מגבלה מרכזית: ברוב תחומי השיפוט, זכויות קניין נוצרות על ידי רישום ממשלתי, לא על ידי רשומה בבלוקצ'יין. מרשם בלוקצ'יין חייב להיות רשמי (פרויקט ממשלתי) או לפעול כשכבה שנייה (Layer 2) מעל המרשם הרשמי — תוך מעקב אחר עסקאות, פישוט התהליך, אך הרישום הסופי בקדסטר המדינתי נשאר חובה.

חריג: נכסים דיגיטליים (נדל"ן וירטואלי במטאוורסים, זכויות כרייה בחלק מתחומי השיפוט, בעלות חלקית מבוססת ניירות ערך).

עבור נכסי מקרקעין — תבנית 'הבלוקצ'יין כנוטריון': אנו מתעדים עובדות ומסמכים, אך הכוח המשפטי נשאר בידי הרשויות הרשמיות.

כיצד מרשם בלוקצ'יין מגן מפני הונאה?

כל נכס הוא NFT נדל"ן ייחודי עם מטא-דאטה (מספר קדסטרלי, כתובת, שטח, מסמכים ב-IPFS). הרשומה בבלוקצ'יין אינה ניתנת לשינוי: איש אינו יכול לשנות היסטוריה או להסתיר שעבודים. בעת העברת בעלות, נבדקים שעבודים ועיקולים פעילים — החוזה החכם חוסם את העסקה אם קיימים שעבודים פעילים. בזכות זאת, מרשמים כאלה מפחיתים סכסוכים משפטיים ב-80%.

contract PropertyRegistry is ERC721URIStorage, AccessControl {
    bytes32 public constant REGISTRAR_ROLE = keccak256("REGISTRAR_ROLE");
    bytes32 public constant NOTARY_ROLE = keccak256("NOTARY_ROLE");

    struct Property {
        string cadastralNumber;
        string propertyType;
        string address_;
        uint256 area;
        bytes32 documentsHash;
        uint256 registeredAt;
        uint256 lastTransferAt;
        bool encumbered;
        string encumbranceDetails;
    }

    mapping(uint256 => Property) public properties;
    mapping(string => uint256) public cadastralToToken;
    mapping(uint256 => Lien[]) public propertyLiens;

    struct Lien {
        address creditor;
        uint256 amount;
        uint256 expiresAt;
        string description;
        bool active;
    }

    event PropertyRegistered(uint256 indexed tokenId, string cadastralNumber, address owner);
    event PropertyTransferred(uint256 indexed tokenId, address from, address to, uint256 price);
    event LienAdded(uint256 indexed tokenId, address creditor, uint256 amount);

    function registerProperty(
        address owner,
        string calldata cadastralNumber,
        string calldata propertyType,
        string calldata address_,
        uint256 area,
        bytes32 documentsHash,
        string calldata metadataURI
    ) external onlyRole(REGISTRAR_ROLE) returns (uint256 tokenId) {
        require(cadastralToToken[cadastralNumber] == 0, "Already registered");
        tokenId = uint256(keccak256(abi.encodePacked(cadastralNumber)));
        properties[tokenId] = Property({
            cadastralNumber: cadastralNumber,
            propertyType: propertyType,
            address_: address_,
            area: area,
            documentsHash: documentsHash,
            registeredAt: block.timestamp,
            lastTransferAt: block.timestamp,
            encumbered: false,
            encumbranceDetails: ""
        });
        cadastralToToken[cadastralNumber] = tokenId;
        _safeMint(owner, tokenId);
        _setTokenURI(tokenId, metadataURI);
        emit PropertyRegistered(tokenId, cadastralNumber, owner);
        return tokenId;
    }

    function addLien(
        uint256 tokenId,
        address creditor,
        uint256 amount,
        uint256 duration,
        string calldata description
    ) external onlyRole(NOTARY_ROLE) {
        propertyLiens[tokenId].push(Lien({
            creditor: creditor,
            amount: amount,
            expiresAt: block.timestamp + duration,
            description: description,
            active: true
        }));
        properties[tokenId].encumbered = true;
        emit LienAdded(tokenId, creditor, amount);
    }

    function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) internal override {
        super._beforeTokenTransfer(from, to, tokenId, batchSize);
        if (from != address(0)) {
            require(!hasActiveLiens(tokenId), "Property has active liens");
        }
    }

    function hasActiveLiens(uint256 tokenId) public view returns (bool) {
        Lien[] memory liens = propertyLiens[tokenId];
        for (uint i = 0; i < liens.length; i++) {
            if (liens[i].active && block.timestamp < liens[i].expiresAt) return true;
        }
        return false;
    }
}

מהם היתרונות על פני מרשמי נייר?

תוכנית יישום שלב אחר שלב

1. ניתוח דרישות — קביעת המחסנית (Ethereum/Polygon/BNB Chain), המסגרת המשפטית, אינטגרציה עם מרשמים ממשלתיים.
2. עיצוב ארכיטקטורה — בחירת תקנים (ERC-721, ERC-1155), תבניות נאמנות, מודל פיצול.
3. פיתוח חוזים חכמים — מרשם נכסים, נאמנות, נכס מפוצל. אנו משתמשים ב-OpenZeppelin לאבטחה.
4. בדיקות — בדיקות יחידה עם Foundry, בדיקות אינטגרציה, פיזינג עם Echidna. ביקורת חובה עם Slither ו-Mythril.
5. אינטגרציה עם The Graph ו-IPFS — אינדוקס אירועים, אחסון מסמכים.
6. פריסה והדרכה — פריסה לרשת הנבחרת, CI/CD, הדרכת צוות.

מנגנון עסקה אטומית

עסקה אטומית היא החלפה בו-זמנית של NFT בכסף ללא מתווכים. הקונה מפקיד כספים בחוזה נאמנות; הנוטריון בודק תנאים (אין שעבודים, סט מסמכים מלא). לאחר שכל התנאים מתקיימים, ה-NFT מועבר לקונה והכספים למוכר. התהליך כולו אורך 5–15 דקות ומבטל את סיכון ההונאה. החלפות אטומיות הן תכונת ליבה המאפשרת החלפות ללא אמון.

ארכיטקטורה של מרשם נכסים

NFT נכס

כל נכס הוא טוקן ERC-721 נדל"ן ייחודי. המטא-דאטה מכיל את המספר הקדסטרלי, כתובת, שטח, וקישור למסמכים המאוחסנים ב-IPFS.

נאמנות לעסקאות

contract PropertyEscrow {
    enum EscrowState { CREATED, FUNDED, CONDITIONS_MET, COMPLETED, DISPUTED, REFUNDED }

    struct EscrowDeal {
        uint256 propertyTokenId;
        address seller;
        address buyer;
        address notary;
        uint256 price;
        IERC20 paymentToken;
        EscrowState state;
        uint256 createdAt;
        uint256 completionDeadline;
        bytes32[] requiredDocuments;
        mapping(bytes32 => bool) submittedDocuments;
    }

    PropertyRegistry public registry;
    mapping(uint256 => EscrowDeal) public deals;
    uint256 private _nextDealId;

    function createDeal(
        uint256 propertyTokenId,
        address buyer,
        address notary,
        uint256 price,
        address paymentToken,
        uint256 deadline,
        bytes32[] calldata requiredDocs
    ) external returns (uint256 dealId) {
        require(registry.ownerOf(propertyTokenId) == msg.sender, "Not owner");
        require(!registry.hasActiveLiens(propertyTokenId), "Property encumbered");

        dealId = _nextDealId++;
        EscrowDeal storage deal = deals[dealId];
        deal.propertyTokenId = propertyTokenId;
        deal.seller = msg.sender;
        deal.buyer = buyer;
        deal.notary = notary;
        deal.price = price;
        deal.paymentToken = IERC20(paymentToken);
        deal.state = EscrowState.CREATED;
        deal.completionDeadline = block.timestamp + deadline;
        deal.requiredDocuments = requiredDocs;

        registry.transferFrom(msg.sender, address(this), propertyTokenId);
        emit DealCreated(dealId, propertyTokenId, msg.sender, buyer);
    }

    function fundEscrow(uint256 dealId) external {
        EscrowDeal storage deal = deals[dealId];
        require(msg.sender == deal.buyer, "Not buyer");
        require(deal.state == EscrowState.CREATED, "Wrong state");

        deal.paymentToken.transferFrom(msg.sender, address(this), deal.price);
        deal.state = EscrowState.FUNDED;
    }

    function completeDeal(uint256 dealId) external {
        EscrowDeal storage deal = deals[dealId];
        require(msg.sender == deal.notary, "Not notary");
        require(deal.state == EscrowState.FUNDED, "Not funded");

        registry.transferFrom(address(this), deal.buyer, deal.propertyTokenId);
        deal.paymentToken.transfer(deal.seller, deal.price);
        deal.state = EscrowState.COMPLETED;
        emit DealCompleted(dealId, deal.propertyTokenId, deal.buyer, deal.seller);
    }

    function refundExpiredDeal(uint256 dealId) external {
        EscrowDeal storage deal = deals[dealId];
        require(block.timestamp > deal.completionDeadline, "Not expired");
        require(deal.state == EscrowState.FUNDED, "Wrong state");

        deal.paymentToken.transfer(deal.buyer, deal.price);
        registry.transferFrom(address(this), deal.seller, deal.propertyTokenId);
        deal.state = EscrowState.REFUNDED;
    }
}

בעלות חלקית

contract FractionalProperty is ERC20 {
    uint256 public propertyTokenId;
    PropertyRegistry public registry;
    uint256 public totalShares = 1_000_000;
    mapping(address => uint256) public unclaimedRent;
    uint256 public accumulatedRentPerShare;

    function distributeRent(uint256 amount) external onlyManager {
        require(totalSupply() > 0, "No shareholders");
        accumulatedRentPerShare += amount * 1e18 / totalSupply();
        paymentToken.transferFrom(msg.sender, address(this), amount);
    }

    function claimRent() external {
        uint256 owed = balanceOf(msg.sender) * accumulatedRentPerShare / 1e18 - unclaimedRent[msg.sender];
        unclaimedRent[msg.sender] += owed;
        paymentToken.transfer(msg.sender, owed);
    }
}

היסטוריית עסקאות ושרשרת בעלות

היסטוריה על השרשרת היא יתרון מרכזי. תת-גרף של The Graph מתעד את כל אירועי Transfer ובונה שרשרת בעלות מלאה עם מחירי עסקאות.

query PropertyHistory($tokenId: String!) {
  propertyTransfers(where: { tokenId: $tokenId }, orderBy: timestamp) {
    from {
      id
    }
    to {
      id
    }
    timestamp
    transactionHash
    price
    notary {
      id
      name
    }
  }
  liens(where: { propertyId: $tokenId }) {
    creditor {
      id
    }
    amount
    expiresAt
    active
    description
  }
}

מה כלול בפיתוח המערכת (תוצרים)

• תיעוד: ארכיטקטורה, מפרט חוזים חכמים, מדריך פריסה, הפניות API.
• חוזים חכמים: מרשם נכסים, נאמנות, נכס מפוצל — עם כיסוי בדיקות מלא.
• אינטגרציה עם IPFS לאחסון מסמכים ו-The Graph לאינדוקס.
• פרונטאנד: React + wagmi לצפייה בנכסים ועסקאות; פאנל נוטריון לניהול שעבודים ונאמנות.
• הגדרת CI/CD, פריסה לרשת הנבחרת (Ethereum, Polygon, BNB Chain).
• הדרכת הצוות שלך על תפעול המערכת.
• תמיכה לאחר פריסה: 3 חודשי תחזוקה ותיקוני באגים.

לוח זמנים לפיתוח

עלות פיתוח למערכת מלאה עם בעלות חלקית מתחילה ב-$30,000. הזמינו פיתוח מפתח-במפתח — נבחן את הפרויקט שלך תוך 24 שעות ונציע פתרון אופטימלי. אנו מבטיחים שקיפות בכל שלב. קבלו ייעוץ וביקורת טכנית לפרויקט שלכם.