Scroll to top

DeFi Assurance - Coming Soon

DeFi Assurance is a decentralized risk-protection system designed to cover losses in decentralized finance without relying on traditional Assurance companies. Instead of insurers, brokers, and paperwork, DeFi Assurance is powered by smart contracts, community capital pools, and on-chain rules deployed on blockchains like Ethereum or BNB Chain.

DeFi Assurance — Bullet-Only Overview

Purpose :

Decentralized risk-protection system for DeFi.
Eliminates need for traditional insurers, brokers, or paperwork.

Core Components :

Smart contracts
Community capital pools
On-chain rules
Deployed on Ethereum, BNB Chain, and similar blockchains

Coverage / Protection Against :

Smart-contract hacks
Protocol failures
Oracle attacks
Stablecoin de-pegging
Exchange exploits

How It Works :

Users pay premiums into Assurance pools.
Capital providers stake funds, earn rewards for taking risk.
Fully automated and transparent :

Terms encoded in smart contracts
Claims evaluated via on-chain data, oracles, governance.
Approved payouts executed automatically

Key Principles / Mechanics :

Risk is redistributed, not eliminated.
Capital providers earn higher returns for higher-risk coverage.
Premium pricing is dynamic, based on demand, perceived risk, liquidity.
Encourages long-term financial protection for users.

Advantages :

Permissionless: Anyone can participate, no KYC needed
Global access
Transparent & auditable: All funds, claims, payouts visible on-chain
Non-custodial: Users retain control over their funds
Potential for higher returns for capital providers

Risks / Considerations :

Incorrect claim assessments
Oracle manipulation
Governance attacks
Insufficient capital during large losses

Popular Protocols :

Nexus Mutual
InsurAce
Unslashed

Conclusion / Takeaway :

Acts as a safety layer for DeFi
Enables users to manage risk
Maintains decentralization, transparency, and trustless execution

DeFi Assurance Protocol

DeFi Assurance

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

/*
---------------------------------------------------------
DeFi Assurance - Prototype Insurance Contract
---------------------------------------------------------
⚠️ Educational / prototype 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; // protocol being insured
        uint256 amount; // coverage 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");
        _;
    }

    // ==========================
    // CAPITAL PROVIDERS
    // ==========================

    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 // e.g. 500 = 5%
    ) 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
        );
    }

    // ==========================
    // CLAIMS
    // ==========================

    function fileClaim(uint256 coverageId) external {
        Coverage storage cov = coverages[coverageId];

        require(cov.user == msg.sender, "Not owner");
        require(cov.active, "Inactive");
        require(block.timestamp <= cov.endTime, "Expired");
        require(!cov.claimed, "Already claimed");

        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 {
        Claim storage c = claims[claimId];
        require(c.status == ClaimStatus.Pending, "Not pending");

        c.status = ClaimStatus.Approved;

        emit ClaimApproved(claimId);
    }

    function rejectClaim(uint256 claimId) external onlyOracle {
        Claim storage c = claims[claimId];
        require(c.status == ClaimStatus.Pending, "Not pending");

        c.status = ClaimStatus.Rejected;

        Coverage storage cov = coverages[c.coverageId];
        cov.claimed = false;

        emit ClaimRejected(claimId);
    }

    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
    // ==========================

    function updateOracle(address newOracle) external onlyOracle {
        oracle = newOracle;
    }

    // ==========================
    // VIEW HELPERS
    // ==========================

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