IPayoutManager

Interface for claim payouts, loss distribution, and the liquidity waterfall.

View deployed contract addresses in the Contract Addresses section.

The PayoutManager handles the execution of claim payouts. When a claim is validated by the RiskManager or OptimisticClaimResolver, this contract coordinates the movement of funds through a multi-layer Liquidity Waterfall — gathering assets from adapters, private reinsurance, the Backstop Pool, and the Treasury to pay the claimant.

Interface

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.20;

import {Types} from "../libraries/helpers/Types.sol";

/**
 * @title IPayoutManager
 * @notice Interface for PayoutManager contract
 * @dev Allows RiskManager to execute claim payouts
 */
interface IPayoutManager {
    /**
     * @notice Executes claim payout by gathering assets from adapters and distributing to claimant/fees
     * @dev Flow: validates proportions → gathers from adapters → pays claimant first → covers deficit with aTokens/reinsurance → distributes loss
     * @param p PayoutData struct with claimant, amounts, adapters, capital distribution
     */
    function executePayout(Types.PayoutData calldata p)
        external
        returns (uint256 underwriterPaid, uint256 reinsurancePaid, uint256 claimantDeficit);

    /**
     * @notice Charges a loss directly to an intent underwriter by burning their shares
     * @dev Merged from ILossDistributor for simplification
     * @param underwriter The underwriter to charge
     * @param poolId The pool ID
     * @param lossValue The value to charge in underlying asset terms
     * @return coveredValue Actual value covered (may be less if undercapitalized)
     */
    function chargeIntentLoss(address underwriter, uint256 poolId, uint256 lossValue) external returns (uint256 coveredValue);

    /**
     * @notice Executes payment for previously recorded claim debt (best-effort).
     * @param claimant Address owed the debt.
     * @param amount Maximum amount to pay in this call.
     * @return paid Amount actually paid to claimant.
     */
    function executeDebtPayout(address claimant, uint256 amount) external returns (uint256 paid);
}

PayoutData Struct

The executePayout and executePayoutWithBreakdown functions receive a PayoutData struct:

Field	Type	Description
`claimant`	`address`	Address receiving the payout
`feeRecipient`	`address`	Address receiving claim fees
`syndicateAddress`	`address`	Syndicate backing the policy (for private reinsurance hook resolution)
`claimantAmount`	`uint256`	Amount owed to the claimant
`feeAmount`	`uint256`	Fee amount for the claim processor
`catastropheAmount`	`uint256`	Portion attributed to catastrophic loss
`underwriterAmount`	`uint256`	Amount charged to the intent underwriter
`reinsurancePortion`	`uint256`	Pre-calculated amount to draw from private reinsurance
`adapters`	`address[]`	Yield adapters holding underwriter capital
`capitalPerAdapter`	`uint256[]`	Amount to withdraw from each adapter
`totalCapitalFromPoolLPs`	`uint256`	Total capital being used for payout
`poolId`	`uint256`	The pool ID for event emission

Liquidity Waterfall

When a claim is executed, the PayoutManager follows a strict priority order to source liquidity:

Layer	Source	Cap	Notes
1	Yield Adapters	Underwriter's charged amount	Proportional draw across adapters; soft-fails per adapter
1.5	Reinsurance Liquidity Swap	Adapter deficit	Swaps stuck adapter debt for backstop liquidity
2	Private Reinsurance	`reinsurancePortion`	Hook's `payClaimPortion()` — shortfall tracked via SettlementModule
3	CapitalPool Idle	Remaining underwriter cap	Loose USDC in the CapitalPool
4	Backstop Pool	Remaining deficit	Global reinsurance reserve
5	Protocol Treasury	Remaining deficit	Last resort; requires pre-approved allowance

If all five layers are exhausted, the claim is partially paid. The deficit is returned to the RiskManager, which may record it as outstanding claim debt for later fulfillment via executeDebtPayout.

Payout Flow

Loss Distribution

The chargeIntentLoss function handles loss distribution for intent-based policies. It burns the underwriter's shares to cover the loss. If the underwriter's capital is insufficient, the deficit is escalated through the waterfall.

See Claims & Salvage → Multi-Layer Payout Waterfall for the full fallback sequence.

Filing a Claim — End-to-end claim process
Claims & Salvage — How claims affect underwriter capital
3rd Party Reinsurance — Private reinsurance hook system
Backstop Pool — Protocol-wide catastrophic reserve
IReinsuranceSettlementModule — Debt tracking for hook shortfalls
IRiskManager — Validates and initiates payouts
ICapitalPool — Source of payout funds