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;
    uint256 public totalLiquidity;
    uint256 public lockedLiquidity;
    uint256 public constant BASIS_POINTS = 10_000;

    mapping(address => uint256) public capitalProvided;

    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;

    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;

    event CapitalProvided(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 ClaimPaid(uint256 indexed id, uint256 payout);

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

    function provideCapital(uint256 amount) external {
        require(amount > 0, "Zero");
        token.transferFrom(msg.sender, address(this), amount);
        capitalProvided[msg.sender] += amount;
        totalLiquidity += amount;
        emit CapitalProvided(msg.sender, amount);
    }

    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);
    }

    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);
    }

    function approveClaim(uint256 claimId) external onlyOracle {
        require(claims[claimId].status == ClaimStatus.Pending, "Not pending");
        claims[claimId].status = ClaimStatus.Approved;
    }

    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);
    }

    function availableLiquidity() public view returns (uint256) {
        return totalLiquidity - lockedLiquidity;
    }
}