> ## Documentation Index
> Fetch the complete documentation index at: https://kleros-mintlify-6ebc7975.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Insurance Claim

> Example parametric insurance contract using Kleros V1 arbitration with ERC-792 and ERC-1497 to resolve disputed payout claims via juror rulings.

## Overview

This example demonstrates a parametric insurance contract that uses Kleros Court V1 to arbitrate disputed claims, following the ERC-792 arbitration standard and ERC-1497 evidence standard. The contract covers a specific insured event (for example, flight delay or crop failure) and pays out when jurors confirm the event occurred.

It follows the V1 arbitrable pattern documented on [docs.kleros.io](https://docs.kleros.io/).

***

## Contract

```solidity theme={null}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;

import "@kleros/erc-792/contracts/IArbitrable.sol";
import "@kleros/erc-792/contracts/IArbitrator.sol";
import "@kleros/erc-792/contracts/erc-1497/IEvidence.sol";

contract InsuranceClaim is IArbitrable, IEvidence {
    enum ClaimStatus { None, Disputed, Resolved }

    struct Policy {
        address payable insured;
        uint256 premium;
        uint256 coverage;
        uint256 expiresAt;
        string termsURI; // IPFS URI to the policy document (MetaEvidence)
    }

    struct Claim {
        uint256 policyID;
        ClaimStatus status;
        uint256 disputeID;
        uint256 ruling;
    }

    IArbitrator public arbitrator;
    bytes public arbitratorExtraData;

    mapping(uint256 => Policy) public policies;
    mapping(uint256 => Claim) public claims;
    mapping(uint256 => uint256) public disputeIDtoClaimID;
    uint256 public policyCount;
    uint256 public claimCount;

    uint256 constant numberOfRulingOptions = 2;
    // Ruling: 0 = Refuse, 1 = Approve claim, 2 = Deny claim
    uint256 constant APPROVE = 1;
    uint256 constant DENY = 2;

    constructor(IArbitrator _arbitrator, bytes memory _arbitratorExtraData) {
        arbitrator = _arbitrator;
        arbitratorExtraData = _arbitratorExtraData;
    }

    /// @dev Purchase an insurance policy. The terms document is the MetaEvidence.
    function purchasePolicy(
        uint256 _coverage,
        uint256 _duration,
        string calldata _termsURI
    ) external payable returns (uint256 policyID) {
        require(msg.value > 0, "Premium required");
        require(_coverage <= address(this).balance, "Insufficient pool");

        policyID = policyCount++;
        policies[policyID] = Policy({
            insured: payable(msg.sender),
            premium: msg.value,
            coverage: _coverage,
            expiresAt: block.timestamp + _duration,
            termsURI: _termsURI
        });

        // ERC-1497: register the policy terms as MetaEvidence, keyed by policyID.
        emit MetaEvidence(policyID, _termsURI);
    }

    /// @dev File a claim, creating a dispute in Kleros Court.
    function fileClaim(
        uint256 _policyID,
        string calldata _evidence
    ) external payable returns (uint256 claimID) {
        Policy storage policy = policies[_policyID];
        require(msg.sender == policy.insured, "Only insured");
        require(block.timestamp <= policy.expiresAt, "Policy expired");

        uint256 cost = arbitrator.arbitrationCost(arbitratorExtraData);
        require(msg.value >= cost, "Insufficient arbitration fee");

        claimID = claimCount++;
        uint256 disputeID = arbitrator.createDispute{value: msg.value}(
            numberOfRulingOptions,
            arbitratorExtraData
        );

        claims[claimID] = Claim({
            policyID: _policyID,
            status: ClaimStatus.Disputed,
            disputeID: disputeID,
            ruling: 0
        });
        disputeIDtoClaimID[disputeID] = claimID;

        // ERC-1497: link the dispute to the policy MetaEvidence and an evidence group.
        emit Dispute(arbitrator, disputeID, _policyID, claimID);
        emit Evidence(arbitrator, claimID, msg.sender, _evidence);
    }

    /// @dev Called by the arbitrator when the ruling is final.
    function rule(uint256 _disputeID, uint256 _ruling) external override {
        require(msg.sender == address(arbitrator), "Only arbitrator");
        require(_ruling <= numberOfRulingOptions, "Ruling out of bounds");

        uint256 claimID = disputeIDtoClaimID[_disputeID];
        Claim storage claim = claims[claimID];
        require(claim.status == ClaimStatus.Disputed, "Not disputed");

        claim.status = ClaimStatus.Resolved;
        claim.ruling = _ruling;

        if (_ruling == APPROVE) {
            Policy storage policy = policies[claim.policyID];
            policy.insured.transfer(policy.coverage);
        }
        // If DENY or refuse to rule, no payout.

        emit Ruling(arbitrator, _disputeID, _ruling);
    }

    /// @dev Fund the insurance pool.
    receive() external payable {}
}
```

***

## How It Works

1. **Policy purchase**: A user pays a premium and receives a policy with a defined coverage amount, duration, and terms document (stored on IPFS and announced as ERC-1497 MetaEvidence)
2. **Claim filing**: The insured submits evidence and pays the arbitration fee, which immediately creates a dispute in Kleros Court V1
3. **Juror evaluation**: Kleros jurors review the evidence against the policy terms and vote to approve or deny
4. **Payout or denial**: If approved, the coverage amount is transferred to the insured. If denied, no payout occurs

***

## Policy Terms (MetaEvidence)

The policy terms are an ERC-1497 MetaEvidence JSON document uploaded to IPFS:

```json theme={null}
{
  "title": "Insurance Claim",
  "description": "Evaluate whether the insured event occurred according to the policy terms.",
  "question": "Should this insurance claim be approved?",
  "rulingOptions": {
    "titles": ["Refuse to Rule", "Approve Claim", "Deny Claim"],
    "descriptions": [
      "The arbitrator refuses to rule.",
      "The insured event occurred; approve the payout.",
      "The insured event did not occur; deny the claim."
    ]
  },
  "category": "Insurance",
  "fileURI": "/ipfs/QmPolicyTerms..."
}
```

***

## Production Considerations

This example omits several features needed for production use:

* **Appeal support**: Allow either party to fund additional rounds
* **Claim period**: Add a review period before disputes are raised, allowing the insurer to approve claims without arbitration
* **Multi-claim policies**: Support multiple claims against a single policy
* **Pool solvency**: Add mechanisms to ensure the insurance pool can cover all outstanding policies
* **Premium pricing**: Calculate premiums based on risk models rather than fixed amounts