RWA Nexus Bridge

RWA Nexus Bridge is a hybrid cross-chain protocol designed to revolutionize the tokenization, transfer, verification, and liquidity unlocking of real-world assets (RWAs) like invoices, bonds, treasuries, real estate, commodities, private equity, and carbon credits. It leverages Chainlink's CCIP for secure programmable messaging, LayerZero's ONFT for omnichain NFT transfers, Hedera's Smart Contract Service (HSCS) and Token Service (HTS) for low-cost minting, and Chainlink oracles for tamper-proof verification. The goal is to solve blockchain fragmentation by enabling seamless RWA flows from cost-efficient chains like Hedera to liquidity-rich ecosystems like Ethereum, with built-in fractionalization for micro-ownership and integrations for DeFi liquidity (e.g., trading on Uniswap and lending on Aave). This positions it as a foundational infrastructure for the growing RWA sector, projected to reach $13-25 trillion by 2030 through the tokenization of traditional finance assets.

The project emphasizes level-5 security to prevent hacks (historical bridge losses exceed $2.8 billion), atomic transactions to avoid double-spending, and real-world event verification (e.g., proof-of-payment via bank APIs relayed through oracles).

Core Architecture and Components

The protocol is divided into source and destination contracts, with a hybrid bridge model:

1. Source Chain (Hedera Testnet for Minting): Uses RWAMinterHybrid.sol to tokenize RWAs. HTS creates native non-fungible tokens (e.g., for unique invoices), wrapped as ONFT for cross-chain portability. Minting costs are ultra-low (< $0.001/tx), making it ideal for high-volume RWAs.

1.1. Mint Process: Call mintRWAWithHTS to create an HTS token with metadata (e.g., "Invoice: $10,000, Payment Due"), assign a serial as tokenId, and mint as ERC-721 for ONFT compatibility. 1.2 Hybrid Send: hybridSendRWA burns the ONFT on source via LayerZero (_lzSend for fast transfer) and sends verification data (tokenId, metadata, requiredValue) via CCIP for redundant security.

1. Destination Chain (Ethereum Sepolia for Settlement): Uses RWASettlerHybrid.sol to receive the ONFT (minted via LayerZero _credit), process CCIP messages, verify with Chainlink oracles, and settle.

2.1 Verification: verifyWithChainlink checks oracle data (e.g., price as proxy for payment amount) against requiredValue, ensures freshness (<1 hour to prevent stale proofs), and validates >0 for integrity—simulating bank API relay for real-world confirmation. 2.2 Settlement: If verified, mark as settled, unlock the asset (transfer NFT to user), and enable DeFi hooks.

1. Hybrid Bridge Logic:

3.1 LayerZero ONFT: Handles the RWA NFT transfer (burn on source, mint on destination) with embedded data for settlement. 3.2 Chainlink CCIP: Relays secure messages (arbitrary calldata for instructions like "verify payment before unlock"), ensuring atomicity and risk management. 3.3 Oracle Relay: Chainlink Data Feeds simulate external proofs (e.g., payment confirmation from bank API via interleaved price checks for integrity); in production, use Chainlink Functions for direct API calls.

1. Post-Settlement Features:

4.1 Fractionalization: fractionalizeRWA burns the original NFT and mints ERC-1155 shares (e.g., divide a $100k bond into 1,000 $100 fractions), distributed to recipients for micro-ownership—democratizing access to high-value RWAs. 4.2 Uniswap Trading Liquidity: tradeOnUniswap approves and transfers the settled NFT (or fractions) to Uniswap's NonfungiblePositionManager, allowing liquidity provision (e.g., mint a position with MintParams for token0/token1 pairs, adding RWA as collateral for trading). 4.3 Aave Lending: Similar hook (not in code but extendable): Approve and supply to Aave Pool for yielding as collateral.

Detailed Flow for an RWA (e.g., Tokenized Invoice)

1. Minting on Hedera: User calls mintRWAWithHTS to create an HTS NFT with metadata (e.g., invoice details, proof link). HTS ensures low-cost, compliant tokenization; ONFT wraps it for cross-chain.
2. Hybrid Transfer: hybridSendRWA burns the ONFT on Hedera (LayerZero) and sends data via CCIP (e.g., requiredValue for payment threshold).
3. Receive on Ethereum: LayerZero _lzReceive mints the NFT; CCIP ccipReceive relays data—both trigger settleRWA.
4. Verification: Chainlink oracle checks payment proof (price >= requiredValue, fresh data)—prevents double-spending by validating timestamp and value.
5. Settlement and Liquidity: If verified, unlock NFT, fractionalize into shares, approve/transfer to Uniswap for trading (mint liquidity position via MintParams—e.g., pair with USDC for RWA/USDC pool), or supply to Aave for lending/yields.
6. Frontend Demo: React app connects wallet, selects chains, mints/transfers, shows status (e.g., "Settled: Yes, Fractionalized: 1000 shares, Traded on Uniswap").

Technical Details and Standards

• Token Standards: HTS for Hedera-native minting, ONFT (ERC-721 extension) for omnichain, ERC-1155 for fractions—ensures compatibility with DeFi (Uniswap V3 NFT manager for positions, Aave for collateral).
• Security: CCIP's risk management + LayerZero's semantic validation prevent failures; oracle checks add freshness/deviation thresholds.
• Gas/Optimization: Hedera for cheap mint (~$0.001), Ethereum for liquidity—hybrid minimizes cross-chain costs.
• Extensions: Add Chainlink Functions for real bank API relays; Uniswap SDK V4 for advanced liquidity (e.g., frame diffs from docs for video proofs if needed).

The project is a hybrid cross-chain protocol for tokenizing, transferring, verifying, settling, fractionalizing, and unlocking liquidity for real-world assets (RWAs) like invoices or bonds. I focused on feasibility for a solo effort: Prioritizing an MVP with functional end-to-end flow (mint on Hedera → hybrid transfer → verify/settle on Ethereum → fractionalize and integrate DeFi), testing on testnets, and a simple frontend for demos. Time was split roughly 60% on contracts, 20% on testing/debugging, 15% on frontend, and 5% on docs/video. Challenges included debugging cross-chain latency and inheritance conflicts in Solidity, but I kept it hackathon-viable by scoping to 2 chains (Hedera Testnet for source, Sepolia for destination) and using mock data for oracles. Technologies Used and How They Piece Together The stack is web3-native, emphasizing EVM compatibility for cross-chain, with a focus on security, low costs, and DeFi integrations. Here's the breakdown:

1. Smart Contracts (Solidity 0.8.20):

• Core Language and Libraries: Wrote ~500 lines of Solidity across two main contracts: RWAMinterHybrid.sol (source on Hedera) and RWASettlerHybrid.sol (destination on Sepolia). Used OpenZeppelin contracts (ERC-721 for NFTs, ERC-1155 for fractional shares, Ownable for access control) as bases to save time and ensure security. Inherited from LayerZero's ONFT721Core/ONFT721 for omnichain NFT transfers and Chainlink's CCIP libraries (IRouterClient, Client) for messaging.

• Hedera Smart Contract Service (HSCS) and Token Service (HTS): On the source, integrated HTS (system contract at 0x167 on Testnet) for native, low-cost RWA minting (createNonFungibleToken and mintToken from hedera-smart-contracts repo). This pieces in as the entry point: HTS creates the token with metadata (e.g., invoice details), wrapped in ONFT for bridging. Benefit: Ultra-low fees (< $0.001/tx) for minting, making it scalable for high-volume RWAs—Hedera's enterprise-grade consensus enhances reliability without Ethereum gas volatility.

• LayerZero V2 ONFT: For the token transfer layer—_debit burns on source, _credit mints on destination. Pieced with HTS: Mint via HTS serial as tokenId, then send via _lzSend with embedded data (tokenId, metadata, requiredValue). Benefit: Fast, low-latency omnichain (sub-second finality on supported chains), ideal for RWAs needing quick ownership shifts.

• Chainlink CCIP: For secure messaging—hybridSendRWA sends data redundantly via ccipSend (arbitrary calldata for verification instructions). On destination, ccipReceive triggers settleRWA. Benefit: Level-5 security (decentralized oracles, risk network) prevents hacks; integrates with Chainlink Data Feeds for payment proofs (verifyWithChainlink checks price >= requiredValue, freshness <1 hour, >0 validity—proxy for bank API relay). How Pieced Together: Hybrid flow: Mint with HTS + ONFT wrap → Send token via LayerZero + data via CCIP → Receive ONFT + CCIP message → Oracle verify → Settle/unlock. Inheritance overrides fixed conflicts (e.g., onlyOwner from Ownable/ONFT721Core). Deployment via Remix IDE for speed (compile, inject MetaMask, deploy to Testnet/Sepolia)—no Hardhat for simplicity, though I used Ignition modules for scripts in planning.

1. Frontend (React.js with TypeScript):

• Stack: Create React App bootstrap, wagmi/viem for web3 (useWriteContract for calls, useContractRead for status), RainbowKit for wallet connect/chain switching, Tailwind CSS for styling, react-spinners for loading. ~200 lines in App.tsx as a single-page dashboard. How Pieced Together: Wagmi config defines chains (Hedera ID 296, Sepolia 11155111 with RPCs). UI components: ConnectButton, dropdown for source/destination, input for metadata/tokenId/requiredValue, buttons for mintRWAWithHTS, hybridSendRWA, fractionalizeRWA, tradeOnUniswap. useContractRead polls isSettled/getMetadata. Runs locally (npm start), deployed to Vercel for live demo URL.