contract LossProtection is BaseHook {
    // Event tracking
    mapping(address => LiquidityEvent[]) public userEvents;
    mapping(address => Claims[]) public claimEvents;
    
    // Hook permissions
    mapping(PoolId => uint256) public beforeSwapCount;
    mapping(PoolId => uint256) public afterSwapCount;
    mapping(PoolId => uint256) public beforeAddLiquidityCount;
    mapping(PoolId => uint256) public afterAddLiquidityCount;
    mapping(PoolId => uint256) public beforeRemoveLiquidityCount;
}

struct LiquidityEvent {
    bool isAdd;           // true for addLiquidity, false for removeLiquidity
    uint256 amountA;      // Amount of Token A (in wei)
    uint256 amountB;      // Amount of Token B (in wei)
    uint256 priceA;       // Price of Token A at event time (scaled, 1e18)
    uint256 priceB;       // Price of Token B at event time (scaled, 1e18)
    uint256 timestamp;    // Timestamp of the event
}

struct Claims {
    uint256 valueHold;    // Value of holding tokens
    uint256 valuePool;    // Value of pool tokens
    uint256 totalAddedA;  // Total amount of token A added
    uint256 totalAddedB;  // Total amount of token B added
    uint256 withdrawnA;   // Amount of token A withdrawn
    uint256 withdrawnB;   // Amount of token B withdrawn
    uint256 priceA;       // Price of token A at claim time
    uint256 priceB;       // Price of token B at claim time
    uint256 timestamp;    // Timestamp of the claim
}

// Hook automatically tracks these operations
function _afterAddLiquidity(...) internal override
function _afterRemoveLiquidity(...) internal override

// Get insurance for latest claim
function claimInsurance(address user) public view returns (uint256 insuranceAmount, bool hasLoss)

// Get insurance for specific claim
function getInsuranceForClaim(address user, uint256 claimIndex) public view returns (uint256 insuranceAmount, bool hasLoss)

// Get total insurance across all claims
function getTotalInsurance(address user) public view returns (uint256 totalInsurance, uint256 totalLosses)

// Check eligibility
function isEligibleForInsurance(address user) public view returns (bool eligible, uint256 totalInsurance)

// Get claim count
function getClaimCount(address user) public view returns (uint256)

// Get specific claim
function getClaim(address user, uint256 index) public view returns (Claims memory)

// Get oracle prices
function getOraclePrice(address currency0, address currency1) public pure returns (uint256 priceA, uint256 priceB)

event ClaimCreated(
    address indexed user,
    uint256 valueHold,
    uint256 valuePool,
    uint256 totalAddedA,
    uint256 totalAddedB,
    uint256 withdrawnA,
    uint256 withdrawnB,
    uint256 priceA,
    uint256 priceB,
    uint256 timestamp
);

event LiquidityEventRecorded(
    address indexed user,
    bool isAdd,
    uint256 amountA,
    uint256 amountB,
    uint256 timestamp
);

function getHookPermissions() public pure override returns (Hooks.Permissions memory) {
    return Hooks.Permissions({
        beforeInitialize: false,
        afterInitialize: false,
        beforeAddLiquidity: true,
        afterAddLiquidity: true,
        beforeRemoveLiquidity: false,
        afterRemoveLiquidity: true,
        beforeSwap: true,
        afterSwap: true,
        // ... other permissions
    });
}

// Check if user has insurance to claim
(uint256 insurance, bool hasLoss) = lossProtection.claimInsurance(userAddress);

if (hasLoss) {
    console.log("Insurance amount:", insurance);
    // Process insurance claim
}

// Get total insurance across all claims
(uint256 totalInsurance, uint256 totalLosses) = lossProtection.getTotalInsurance(userAddress);

console.log("Total insurance needed:", totalInsurance);
console.log("Number of loss events:", totalLosses);

// Get details of a specific claim
Claims memory claim = lossProtection.getClaim(userAddress, 0);

console.log("Claim valueHold:", claim.valueHold);
console.log("Claim valuePool:", claim.valuePool);
console.log("Impermanent loss:", claim.valueHold - claim.valuePool);