Smart Contracts Overview

┌─────────────────────────────────────────────────────────────┐
│                     Core Protocol                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  OrderBook.sol          - Order matching engine            │
│  CBTFactory.sol         - Bond token creation              │
│  CollateralManager.sol  - Collateral handling              │
│  VaultFactory.sol       - Vault creation                   │
│  YieldRouter.sol        - Idle capital deployment          │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                     Periphery                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  OracleAdapter.sol      - Price feed aggregation           │
│  BridgeAdapter.sol      - Cross-chain integration          │
│  RelayerHub.sol         - Meta-transaction handling        │
│                                                             │
└─────────────────────────────────────────────────────────────┘

interface IOrderBook {
    struct Order {
        address maker;
        address asset;
        uint256 amount;
        uint256 rate;      // basis points
        uint256 maturity;
        bool isLend;
        OrderStatus status;
    }

    function placeLendOrder(
        address asset,
        uint256 amount,
        uint256 rate,
        uint256 maturity
    ) external returns (bytes32 orderId);

    function placeBorrowOrder(
        address asset,
        uint256 amount,
        uint256 maxRate,
        uint256 maturity
    ) external returns (bytes32 orderId);

    function cancelOrder(bytes32 orderId) external;

    function getOrder(bytes32 orderId) external view returns (Order memory);
}

interface ICBT is IERC20 {
    function underlying() external view returns (address);
    function maturity() external view returns (uint256);
    function redeem(uint256 amount) external returns (uint256);
    function redeemTo(address to, uint256 amount) external returns (uint256);
}

interface ICollateralManager {
    function deposit(address asset, uint256 amount) external;
    function withdraw(address asset, uint256 amount) external;

    function getCollateralValue(address user) external view returns (uint256);
    function getBorrowingPower(address user) external view returns (uint256);
    function getHealthFactor(address user) external view returns (uint256);

    function liquidate(
        address user,
        address debtAsset,
        uint256 debtAmount,
        address collateralAsset
    ) external returns (uint256 collateralSeized);
}

event OrderPlaced(
    bytes32 indexed orderId,
    address indexed maker,
    address asset,
    uint256 amount,
    uint256 rate,
    uint256 maturity,
    bool isLend
);

event OrderMatched(
    bytes32 indexed lendOrderId,
    bytes32 indexed borrowOrderId,
    uint256 matchedAmount,
    uint256 rate
);

event OrderCancelled(bytes32 indexed orderId);

event CollateralDeposited(
    address indexed user,
    address indexed asset,
    uint256 amount
);

event CollateralWithdrawn(
    address indexed user,
    address indexed asset,
    uint256 amount
);

event Liquidation(
    address indexed user,
    address indexed liquidator,
    address debtAsset,
    uint256 debtCovered,
    address collateralAsset,
    uint256 collateralSeized
);

// Emergency pause
function pause() external onlyAdmin;

// Granular pause
function pauseFunction(bytes4 selector) external onlyAdmin;

modifier nonReentrant() {
    require(!_locked, "Reentrant call");
    _locked = true;
    _;
    _locked = false;
}