DeFi Assurance DECENTRALIZED RISK PROTECTION PROTOCOL

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
/*
 DeFi Assurance — Prototype Insurance Contract
 ⚠️  Educational only — NOT audited, NOT production ready
*/

interface IERC20 {
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function balanceOf(address user) external view returns (uint256);
}

contract DeFiAssurance {
    IERC20  public immutable token;
    address public oracle;           // claim assessor / DAO / multisig
    uint256 public totalLiquidity;
    uint256 public lockedLiquidity;
    uint256 public constant BASIS_POINTS = 10_000;

    // ── CAPITAL PROVIDERS ──────────────────────────
    mapping(address => uint256) public capitalProvided;

    // ── COVERAGE STRUCT ────────────────────────────
    struct Coverage {
        address user;
        bytes32 protocolId;
        uint256 amount;
        uint256 premium;
        uint256 startTime;
        uint256 endTime;
        bool    active;
        bool    claimed;
    }
    uint256 public coverageCounter;
    mapping(uint256 => Coverage) public coverages;

    // ── CLAIM STRUCT ───────────────────────────────
    enum ClaimStatus { None, Pending, Approved, Rejected, Paid }
    struct Claim {
        uint256     coverageId;
        address     user;
        uint256     filedAt;
        ClaimStatus status;
    }
    uint256 public claimCounter;
    mapping(uint256 => Claim) public claims;

    // ── EVENTS ─────────────────────────────────────
    event CapitalProvided (address indexed provider, uint256 amount);
    event CapitalWithdrawn(address indexed provider, uint256 amount);
    event CoveragePurchased(uint256 indexed id, address indexed user,
        bytes32 protocolId, uint256 amount, uint256 premium, uint256 expiry);
    event ClaimFiled   (uint256 indexed id, uint256 coverageId);
    event ClaimApproved(uint256 indexed id);
    event ClaimRejected(uint256 indexed id);
    event ClaimPaid    (uint256 indexed id, uint256 payout);

    constructor(address _token, address _oracle) {
        token = IERC20(_token); oracle = _oracle;
    }
    modifier onlyOracle() { require(msg.sender == oracle, "Not oracle"); _; }

    // ── PROVIDE / WITHDRAW CAPITAL ─────────────────
    function provideCapital(uint256 amount) external {
        require(amount > 0, "Zero amount");
        token.transferFrom(msg.sender, address(this), amount);
        capitalProvided[msg.sender] += amount;
        totalLiquidity += amount;
        emit CapitalProvided(msg.sender, amount);
    }
    function withdrawCapital(uint256 amount) external {
        require(capitalProvided[msg.sender] >= amount, "Insufficient");
        require(totalLiquidity - lockedLiquidity >= amount, "Liquidity locked");
        capitalProvided[msg.sender] -= amount;
        totalLiquidity -= amount;
        token.transfer(msg.sender, amount);
        emit CapitalWithdrawn(msg.sender, amount);
    }

    // ── BUY COVERAGE ───────────────────────────────
    function buyCoverage(
        bytes32 protocolId, uint256 coverageAmount,
        uint256 duration,   uint256 premiumRateBP
    ) external {
        require(duration > 0, "Invalid duration");
        uint256 premium = (coverageAmount * premiumRateBP) / BASIS_POINTS;
        require(totalLiquidity - lockedLiquidity >= coverageAmount, "Pool insufficient");
        token.transferFrom(msg.sender, address(this), premium);
        lockedLiquidity += coverageAmount;
        coverages[++coverageCounter] = Coverage({
            user: msg.sender,         protocolId: protocolId,
            amount: coverageAmount,   premium: premium,
            startTime: block.timestamp, endTime: block.timestamp + duration,
            active: true,             claimed: false
        });
        emit CoveragePurchased(coverageCounter, msg.sender, protocolId,
            coverageAmount, premium, block.timestamp + duration);
    }

    // ── FILE CLAIM ─────────────────────────────────
    function fileClaim(uint256 coverageId) external {
        Coverage storage cov = coverages[coverageId];
        require(cov.user == msg.sender, "Not owner");
        require(cov.active && !cov.claimed, "Invalid");
        require(block.timestamp <= cov.endTime, "Expired");
        cov.claimed = true;
        claims[++claimCounter] = Claim({
            coverageId: coverageId, user: msg.sender,
            filedAt: block.timestamp, status: ClaimStatus.Pending
        });
        emit ClaimFiled(claimCounter, coverageId);
    }

    // ── ORACLE APPROVE / REJECT ────────────────────
    function approveClaim(uint256 claimId) external onlyOracle {
        require(claims[claimId].status == ClaimStatus.Pending, "Not pending");
        claims[claimId].status = ClaimStatus.Approved;
        emit ClaimApproved(claimId);
    }
    function rejectClaim(uint256 claimId) external onlyOracle {
        require(claims[claimId].status == ClaimStatus.Pending, "Not pending");
        claims[claimId].status = ClaimStatus.Rejected;
        coverages[claims[claimId].coverageId].claimed = false;
        emit ClaimRejected(claimId);
    }

    // ── PAYOUT ─────────────────────────────────────
    function payoutClaim(uint256 claimId) external {
        Claim storage c = claims[claimId];
        require(c.status == ClaimStatus.Approved, "Not approved");
        Coverage storage cov = coverages[c.coverageId];
        require(cov.active, "Inactive");
        c.status = ClaimStatus.Paid; cov.active = false;
        lockedLiquidity -= cov.amount; totalLiquidity -= cov.amount;
        token.transfer(c.user, cov.amount);
        emit ClaimPaid(claimId, cov.amount);
    }

    // ── ADMIN / VIEW ───────────────────────────────
    function updateOracle(address newOracle) external onlyOracle { oracle = newOracle; }
    function availableLiquidity() public view returns (uint256) {
        return totalLiquidity - lockedLiquidity;
    }
}