The problem Lotwise solves

Problem Solved by Lotwise

Lotwise, a DeFi platform that tokenizes real estate properties, addresses the significant barriers in traditional real estate investment, where high costs, illiquidity, and limited financial flexibility exclude most people. As of 04:50 PM WAT on Saturday, June 28, 2025, it leverages blockchain and Chainlink technology to revolutionize this trillion-dollar market, making it accessible, efficient, and secure.

What Problem It Solves

• High Entry Barriers: Traditional real estate requires substantial capital (e.g., $1M+), locking out small investors. Lotwise tokenizes properties into 1,000 ERC-721 tokens (e.g., $1,000 each), enabling affordable entry.
• Illiquidity: Selling property can take months or years; Lotwise offers instant liquidity through a marketplace for token trading.
• Limited Financial Utility: Property owners struggle to leverage assets for loans or income. Lotwise’s Aave integration unlocks borrowing and yield-earning potential.
• Geographic and System Constraints: Real estate value is often region-specific. Lotwise’s Chainlink CCIP enables cross-chain access (Ethereum, Polygon), broadening reach.
• Risk and Transparency Issues: Manual valuations and loan oversight are prone to errors or delays. Chainlink Data Feeds and Automation provide real-time, secure management.

What People Can Use It For

• Fractional Property Investment: Individuals can buy a portion of a property (e.g., 10 tokens for $10,000) without needing millions, diversifying like stocks.
• Earn Passive Income: Supply tokens to Aave via Chainlink Automation to earn yield (e.g., 5.2% APY) or claim distributed profits from property revenue.
• Secure Borrowing: Stake tokens as collateral on Aave to borrow funds (e.g., $6,000 against $10,000 in tokens), funding other goals without selling.
• Instant Trading: Use the marketplace to sell tokens at market prices (e.g., $1,050) anytime, converting illiquid assets to cash.
• Global Market Access: Leverage Chainlink CCIP to trade and use tokens across Ethereum, Polygon, Sepolia, and Mumbai, connecting global investors.

How It Makes Existing Tasks Easier/Safer

• Easier Investment: Simplifies buying property to a few clicks on a web app, skipping agent fees and paperwork, with Chainlink Functions verifying data.
• Faster Transactions: Enables token trades in seconds (vs. months for sales) via a Chainlink-powered marketplace, saving time.
• Safer Lending: Automates health factor monitoring (e.g., 85% threshold) and liquidation protection with Chainlink Automation, reducing default risks.
• Transparent Valuation: Updates token prices in real-time using Chainlink Data Feeds, ensuring fairness without manual appraisals.
• Secure Cross-Chain Transfers: Ensures safe token movement between networks with Chainlink CCIP, minimizing fraud or loss.
• Automated Profit Sharing: Distributes yield to owners automatically via Chainlink Automation, eliminating manual payout efforts.

Layman’s Perspective

Imagine Lotwise as a digital real estate game where you buy a $1,000 slice of a house, trade it like a collectible card, borrow money using it, or earn rent without managing tenants—all online! It’s safer with Chainlink’s smart checks (prices, loans), easier because you avoid real estate hassles, and open to anyone, anywhere, thanks to cross-chain tech.

Challenges we ran into

Challenges We Ran Into While Building Lotwise

Building Lotwise, a DeFi platform that tokenizes real estate properties, was a rewarding yet challenging endeavor during the 4-week Chainlink Hackathon timeline. One of the core hurdles we encountered was a significant dependency conflict involving Chainlink CCIP v1.6.0 and OpenZeppelin contracts, which impacted the smart contract development.

Challenge: Chainlink CCIP v1.6.0 and OpenZeppelin Conflict

• Bug/Hurdle: While integrating Chainlink CCIP for cross-chain token transfers in Lotwise.sol, we encountered a persistent "Identifier already declared" error during compilation with Hardhat. The error stemmed from a duplicate definition of the IERC165 interface, with the conflict traced to @chainlink/contracts/src/v0.8/vendor/openzeppelin-solidity/v5.0.2/contracts/utils/introspection/IERC165.sol. This occurred because Chainlink CCIP v1.6.0 bundles its own OpenZeppelin v5.0.2 internally, clashing with our direct installation of @openzeppelin/[email protected] for ERC-721, ERC721Enumerable, Ownable, ReentrancyGuard, and IERC20.

• Impact: The error halted contract compilation, delaying the addition of CCIP functionality and stalling progress on cross-chain features, a key Chainlink highlight. Attempts to import OpenZeppelin contracts from Chainlink’s node_modules failed for unexposed contracts like ReentrancyGuard.sol, exacerbating the issue.

• Solution: After researching Chainlink’s documentation and community forums (e.g., Discord), we confirmed this as a known packaging limitation in CCIP v1.6.0. The reliable workaround was to rely solely on our own OpenZeppelin installation. We took the following steps:

  1. Clean Environment: Ran npx hardhat clean, rm -rf node_modules, and rm package-lock.json to remove cached artifacts.
  2. Reinstall Dependencies: Executed npm install @openzeppelin/[email protected] to ensure a fresh, isolated OpenZeppelin v5.0.2 install, avoiding Chainlink’s bundled version.
  3. Update Imports: Revised Lotwise.sol imports to use our installation explicitly:

     import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
     import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
     import "@openzeppelin/contracts/access/Ownable.sol";
     import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
     import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
     

  4. Verify Configuration: Ensured hardhat.config.js had no remappings redirecting to Chainlink’s node_modules, relying on Hardhat’s default node_modules resolution.
  5. Test Compilation: Recompiled with npx hardhat compile, confirming the error resolved. We then proceeded with CCIP integration using the clean setup.

• Outcome: The contract compiled successfully, allowing us to implement the transferCrossChain function with Chainlink CCIP. We mocked the CCIP receiver locally and plan to deploy it to Mumbai testnet, ensuring cross-chain functionality for the demo.

Lessons Learned

• Dependency Management: This highlighted the importance of isolating third-party dependencies to avoid conflicts, a common pitfall in blockchain development.
• Community Resources: Chainlink’s Discord and documentation were invaluable for identifying the bug and workaround.
• Iterative Testing: Regular cleaning and retesting after dependency changes prevented cascading errors.

Time Management in a Short Period

Developing Lotwise within the 4-week hackathon timeframe required efficient time management to overcome these challenges and deliver a functional MVP. Here’s how we managed it:

• Prioritization: Focused on core features (tokenization, CCIP, Aave) first, tackling the dependency conflict early in Week 2 to avoid blocking later tasks.
• Incremental Progress: Broke down complex integrations (e.g., CCIP, Aave) into smaller, daily tasks (e.g., 1-2 days per Chainlink component), allowing quick iterations and testing.
• Leveraging Tools: Used Hardhat’s local testing to simulate issues before testnet deployment, saving time on debugging live environments.
• Community Support: Quickly tapped into Chainlink’s Discord for real-time advice, cutting research time.
• Daily Checkpoints: Set daily goals (e.g., compile contract, fix API) and reviewed progress each evening, adjusting the next day’s plan to stay on track.

This disciplined approach ensured we resolved the CCIP-OpenZeppelin conflict within days, integrated additional features like Aave, and kept the project on schedule for the hackathon demo, proving adaptability under tight constraints!