Documentation

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

import "@crypto-insurance/contracts/FlightInsurancePolicy.sol";
import "@chainlink/contracts/src/v0.8/ChainlinkClient.sol";

contract FlightDelayPolicy is FlightInsurancePolicy, ChainlinkClient {
    string public flightNumber;
    uint256 public departureDate;
    uint256 public delayThreshold;
    uint256 public coverageAmount;
    address public policyholder;
    
    enum PolicyStatus { Active, PaidOut, Expired }
    PolicyStatus public status;
    
    event PolicyCreated(string flightNumber, uint256 departureDate);
    event PolicyPaidOut(uint256 amount);
    
    constructor(
        string memory _flightNumber,
        uint256 _departureDate,
        uint256 _delayThreshold,
        uint256 _coverageAmount,
        address _policyholder
    ) {
        flightNumber = _flightNumber;
        departureDate = _departureDate;
        delayThreshold = _delayThreshold;
        coverageAmount = _coverageAmount;
        policyholder = _policyholder;
        status = PolicyStatus.Active;
        
        emit PolicyCreated(flightNumber, departureDate);
      }
    }
    
    function processClaim(uint256 delayDuration) external onlyOracle {
        require(status == PolicyStatus.Active, "Policy not active");
        
        if (delayDuration >= delayThreshold) {
            status = PolicyStatus.PaidOut;
            // Transfer coverage amount to policyholder
            (bool success, ) = policyholder.call{value: coverageAmount}("");
            require(success, "Transfer failed");
            
            emit PolicyPaidOut(coverageAmount);
          }
    }
      }
    }
}

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

import "@crypto-insurance/contracts/EventInsurancePolicy.sol";
import "@chainlink/contracts/src/v0.8/ChainlinkClient.sol";

contract EventCancellationPolicy is EventInsurancePolicy, ChainlinkClient {
    string public eventId;
    string public eventName;
    uint256 public eventDate;
    string public eventType;
    uint256 public ticketValue;
    uint256 public coverageAmount;
    address public policyholder;
    
    enum PolicyStatus { Active, PaidOut, Expired }
    enum CancellationReason { Cancelled, Postponed, VenueChanged, PerformerNoShow }
    
    PolicyStatus public status;
    
    event PolicyCreated(string eventId, string eventName, uint256 eventDate);
    event PolicyPaidOut(uint256 amount, CancellationReason reason);
    
    constructor(
        string memory _eventId,
        string memory _eventName,
        uint256 _eventDate,
        string memory _eventType,
        uint256 _ticketValue,
        address _policyholder
    ) {
        eventId = _eventId;
        eventName = _eventName;
        eventDate = _eventDate;
        eventType = _eventType;
        ticketValue = _ticketValue;
        coverageAmount = _ticketValue;
        policyholder = _policyholder;
        status = PolicyStatus.Active;
        
        emit PolicyCreated(eventId, eventName, eventDate);
      }
    }
    
    function processClaim(bytes calldata oracleData) external onlyOracle {
        require(status == PolicyStatus.Active, "Policy not active");
        
        // Decode oracle data
        (bool eventCancelled, CancellationReason reason) = abi.decode(
            oracleData, 
            (bool, CancellationReason)
        );
        
        if (eventCancelled) {
            status = PolicyStatus.PaidOut;
            
            // Transfer coverage amount to policyholder
            (bool success, ) = policyholder.call{value: coverageAmount}("");
            require(success, "Transfer failed");
            
            emit PolicyPaidOut(coverageAmount, reason);
          }
    }
      }
    }
}

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

import "@crypto-insurance/contracts/StablecoinInsurancePolicy.sol";
import "@chainlink/contracts/src/v0.8/ChainlinkClient.sol";

contract StablecoinDepegPolicy is StablecoinInsurancePolicy, ChainlinkClient {
    string public stablecoin;
    uint256 public coverageAmount;
    uint256 public depegThreshold; // Stored as price * 100 (e.g., 95 for $0.95)
    uint256 public startTime;
    uint256 public endTime;
    uint256 public observationPeriod; // in minutes
    address public policyholder;
    
    enum PolicyStatus { Active, PaidOut, Expired }
    PolicyStatus public status;
    
    event PolicyCreated(string stablecoin, uint256 coverageAmount, uint256 depegThreshold);
    event PolicyPaidOut(uint256 amount, uint256 actualPrice);
    
    constructor(
        string memory _stablecoin,
        uint256 _coverageAmount,
        uint256 _depegThreshold,
        uint256 _duration,
        uint256 _observationPeriod,
        address _policyholder
    ) {
        stablecoin = _stablecoin;
        coverageAmount = _coverageAmount;
        depegThreshold = _depegThreshold;
        startTime = block.timestamp;
        endTime = block.timestamp + (_duration * 1 days);
        observationPeriod = _observationPeriod * 1 minutes;
        policyholder = _policyholder;
        status = PolicyStatus.Active;
        
        emit PolicyCreated(stablecoin, coverageAmount, depegThreshold);
      }
    }
    
    function processClaim(bytes calldata oracleData) external onlyOracle {
        require(status == PolicyStatus.Active, "Policy not active");
        require(block.timestamp <= endTime, "Policy expired");
        
        // Decode oracle data
        (uint256 actualPrice, bool belowThresholdForPeriod) = abi.decode(
            oracleData, 
            (uint256, bool)
        );
        
        if (actualPrice < depegThreshold && belowThresholdForPeriod) {
            status = PolicyStatus.PaidOut;
            
            // Calculate payout amount based on severity
            uint256 deviation = 100 - actualPrice;
            uint256 payoutPercentage = (deviation * 2 > 100) ? 100 : deviation * 2;
            uint256 payoutAmount = (coverageAmount * payoutPercentage) / 100;
            
            // Transfer payout to policyholder
            (bool success, ) = policyholder.call{value: payoutAmount}("");
            require(success, "Transfer failed");
            
            emit PolicyPaidOut(payoutAmount, actualPrice);
          }
    }
      }
    }
}

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

import "@crypto-insurance/contracts/WeatherInsurancePolicy.sol";
import "@chainlink/contracts/src/v0.8/ChainlinkClient.sol";

contract WeatherImpactPolicy is WeatherInsurancePolicy, ChainlinkClient {
    // Location data
    int256 public latitude;
    int256 public longitude;
    string public locationName;
    
    // Weather parameters
    enum WeatherParameterType { TEMPERATURE, RAINFALL, SNOWFALL, WIND, SUNSHINE }
    enum ThresholdType { EXCEEDS, FALLS_BELOW, BETWEEN, OUTSIDE_RANGE }
    
    WeatherParameterType public weatherParameter;
    ThresholdType public thresholdType;
    int256 public thresholdValue;
    int256 public secondaryThreshold; // For BETWEEN and OUTSIDE_RANGE types
    
    // Policy details
    uint256 public startDate;
    uint256 public endDate;
    uint256 public coverageAmount;
    address public policyholder;
    string public description;
    
    enum PolicyStatus { Active, PaidOut, Expired }
    PolicyStatus public status;
    
    event PolicyCreated(string locationName, uint256 startDate, uint256 endDate);
    event PolicyPaidOut(uint256 amount, int256 actualWeatherValue);
    
    constructor(
        int256 _latitude,
        int256 _longitude,
        string memory _locationName,
        uint8 _weatherParameter,
        uint8 _thresholdType,
        int256 _thresholdValue,
        int256 _secondaryThreshold,
        uint256 _startDate,
        uint256 _endDate,
        uint256 _coverageAmount,
        address _policyholder,
        string memory _description
    ) {
        latitude = _latitude;
        longitude = _longitude;
        locationName = _locationName;
        weatherParameter = WeatherParameterType(_weatherParameter);
        thresholdType = ThresholdType(_thresholdType);
        thresholdValue = _thresholdValue;
        secondaryThreshold = _secondaryThreshold;
        startDate = _startDate;
        endDate = _endDate;
        coverageAmount = _coverageAmount;
        policyholder = _policyholder;
        description = _description;
        status = PolicyStatus.Active;
        
        emit PolicyCreated(locationName, startDate, endDate);
      }
    }
    
    function processClaim(bytes calldata oracleData) external onlyOracle {
        require(status == PolicyStatus.Active, "Policy not active");
        require(block.timestamp <= endDate, "Policy expired");
        
        // Decode oracle data
        (int256 actualWeatherValue, bool conditionMet) = abi.decode(
            oracleData, 
            (int256, bool)
        );
        
        if (conditionMet) {
            status = PolicyStatus.PaidOut;
            
            // Transfer coverage amount to policyholder
            (bool success, ) = policyholder.call{value: coverageAmount}("");
            require(success, "Transfer failed");
            
            emit PolicyPaidOut(coverageAmount, actualWeatherValue);
          }
    }
      }
    }
    
    function isThresholdMet(int256 value) internal view returns (bool) {
        if (thresholdType == ThresholdType.EXCEEDS) {
            return value > thresholdValue;
          }
    } else if (thresholdType == ThresholdType.FALLS_BELOW) {
            return value < thresholdValue;
          }
    } else if (thresholdType == ThresholdType.BETWEEN) {
            return value >= thresholdValue && value <= secondaryThreshold;
          }
    } else if (thresholdType == ThresholdType.OUTSIDE_RANGE) {
            return value < thresholdValue || value > secondaryThreshold;
          }
    }
        return false;
      }
    }
}