Smart Contract Insurance Protocol

A decentralized insurance system built on the Stacks blockchain using Clarity smart contracts. This protocol enables users to purchase insurance policies, contribute to a shared insurance pool, and file claims for coverage.

Overview

The Insurance Protocol provides a transparent, automated insurance system where:

• Users purchase policies with customizable coverage amounts
• Premiums are automatically calculated and pooled
• Claims are filed with evidence and reviewed by the contract owner
• Payouts are processed from the shared insurance pool

Key Features

🛡️ Policy Management

• Create Policies: Purchase insurance with custom coverage (min: 1 STX, max: 100 STX)
• Flexible Duration: Set policy duration up to 52,560 blocks (~1 year)
• Automatic Premium: Calculated as 10% of coverage amount
• Policy Tracking: Each user can manage up to 50 policies
• Cancellation: Cancel active policies and receive 50% premium refund

💰 Insurance Pool

• Shared Liquidity: All premiums contribute to a collective pool
• Transparent Tracking: View total pool balance and individual contributions
• Secure Payouts: Claims paid directly from the pool with validation

📋 Claims Processing

• File Claims: Submit claims with evidence (up to 256 characters)
• Status Tracking: Monitor claim status (pending/approved/rejected)
• Owner Review: Contract owner approves or rejects claims
• Automatic Payout: Approved claims trigger immediate STX transfer

🔒 Security Features

• Owner-only administrative functions
• Input validation on all parameters
• Authorization checks for policy operations
• Pool balance verification before payouts
• Duplicate claim prevention
• Policy expiration enforcement

Contract Functions

Public Functions

For Users

contribute-to-pool (amount uint)

• Contribute STX to the insurance pool
• Max contribution: 100 STX per transaction
• Returns: Amount contributed

create-policy (coverage uint) (duration uint)

• Create a new insurance policy
• Parameters:
  • coverage: Amount of coverage (1-100 STX)
  • duration: Policy duration in blocks (max 52,560)
• Premium: 10% of coverage
• Returns: Policy ID

file-claim (policy-id uint) (claim-amount uint) (evidence string-ascii-256)

• Submit an insurance claim
• Parameters:
  • policy-id: Your policy ID
  • claim-amount: Amount to claim (≤ coverage)
  • evidence: Claim justification (1-256 chars)
• Returns: Claim ID

cancel-policy (policy-id uint)

• Cancel an active policy
• Receives 50% premium refund
• Returns: Refund amount

For Contract Owner

approve-claim (claim-id uint)

• Approve a pending claim
• Transfers funds to claimant
• Marks policy as claimed
• Returns: true

reject-claim (claim-id uint)

• Reject a pending claim
• Updates claim status only
• Returns: true

set-min-premium (new-min uint)

• Update minimum premium requirement
• Must be between 0.1-1000 STX
• Must be less than max coverage
• Returns: true

set-max-coverage (new-max uint)

• Update maximum coverage limit
• Must be ≤ 10,000 STX
• Must be greater than min premium
• Returns: true

withdraw-excess (amount uint)

• Withdraw excess funds from pool
• Cannot exceed total pool balance
• Returns: Withdrawn amount

Read-Only Functions

get-policy (policy-id uint)

• Retrieve policy details
• Returns: Policy object or none

get-claim (claim-id uint)

• Retrieve claim details
• Returns: Claim object or none

get-user-policies (user principal)

• Get all policy IDs for a user
• Returns: List of policy IDs

get-pool-balance ()

• View total insurance pool balance
• Returns: Pool balance in microSTX

get-contribution (user principal)

• View user's total contributions
• Returns: Contribution amount

get-policy-count ()

• Get total number of policies created
• Returns: Policy counter

is-policy-valid (policy-id uint)

• Check if policy is active and valid
• Returns: true/false

get-min-premium () / get-max-coverage ()

• View current limits
• Returns: Amount in microSTX

Error Codes

Code	Error	Description
u100	err-owner-only	Function restricted to contract owner
u101	err-not-found	Policy or claim not found
u102	err-already-exists	Resource already exists
u103	err-insufficient-funds	Pool lacks sufficient funds
u104	err-invalid-amount	Amount out of valid range
u105	err-policy-expired	Policy has expired
u106	err-policy-active	Policy is still active
u107	err-claim-exists	Claim already filed for policy
u108	err-unauthorized	User not authorized
u109	err-invalid-status	Invalid claim status
u110	err-invalid-evidence	Evidence validation failed
u111	err-invalid-parameter	Parameter validation failed

Usage Example

;; 1. Contribute to the insurance pool
(contract-call? .insurance contribute-to-pool u10000000) ;; 10 STX

;; 2. Create a policy with 50 STX coverage for 10,000 blocks
(contract-call? .insurance create-policy u50000000 u10000)
;; Premium: 5 STX (10% of 50 STX)
;; Returns: u1 (policy ID)

;; 3. File a claim with evidence
(contract-call? .insurance file-claim u1 u25000000 "Smart contract exploit on 2025-11-01")
;; Returns: u1 (claim ID)

;; 4. Owner approves claim (owner only)
(contract-call? .insurance approve-claim u1)
;; Transfers 25 STX to claimant

;; 5. Check policy status
(contract-call? .insurance get-policy u1)

Data Structures

Policy Object

{
  owner: principal,        ;; Policy owner
  coverage: uint,          ;; Coverage amount in microSTX
  premium: uint,           ;; Premium paid
  start-block: uint,       ;; Policy start block
  end-block: uint,         ;; Policy expiration block
  active: bool,            ;; Policy status
  claimed: bool            ;; Whether claim was made
}

Claim Object

{
  policy-id: uint,               ;; Associated policy
  claimant: principal,           ;; Claim submitter
  amount: uint,                  ;; Claim amount
  timestamp: uint,               ;; Block height submitted
  status: (string-ascii 20),     ;; pending/approved/rejected
  evidence: (string-ascii 256)   ;; Claim evidence
}

Limitations

• Maximum 50 policies per user
• Evidence limited to 256 ASCII characters
• Policy duration capped at 52,560 blocks (~1 year)
• Single claim per policy
• Claims require manual owner approval
• No automated risk assessment

Security Considerations

1. Owner Privileges: Contract owner has significant power (claim approval, withdrawals)
2. Pool Solvency: Monitor pool balance to ensure claim coverage
3. Evidence: Evidence is stored on-chain but not cryptographically verified
4. No Oracles: System doesn't use external data feeds for validation
5. Governance: Consider implementing DAO governance for claim approvals

Development & Testing

Prerequisites

• Clarinet CLI
• Stacks blockchain node
• STX tokens for testing

Deployment

clarinet deploy

Testing

clarinet test