AliasedLossPolicyV3

address public immutable pool

address public immutable underlying

address public immutable priceFeedStore

function isLiquidatableWithLoss(
    address creditAccount,
    address caller,
    Params calldata params
) external returns (bool)

ILossPolicy.Params memory params = ILossPolicy.Params({
    twvUSD: 95000e8,      // Current TWV in USD
    totalDebtUSD: 100000e8, // Total debt in USD
    extraData: priceUpdateData // Optional price updates
});

bool canLiquidate = IAliasedLossPolicyV3(policy).isLiquidatableWithLoss(
    creditAccount,
    msg.sender,
    params
);

function getRequiredAliasPriceFeeds(address creditAccount)
    external
    view
    returns (address[] memory priceFeeds)

address[] memory required = IAliasedLossPolicyV3(policy)
    .getRequiredAliasPriceFeeds(creditAccount);

// Ensure all required price feeds are updated
for (uint256 i = 0; i < required.length; i++) {
    // Check or update price feed
}

function serialize() external view returns (bytes memory)

function getTokensWithAlias() external view returns (address[] memory)

address[] memory tokens = IAliasedLossPolicyV3(policy).getTokensWithAlias();
for (uint256 i = 0; i < tokens.length; i++) {
    PriceFeedParams memory params = policy.getAliasPriceFeedParams(tokens[i]);
    // Process alias configuration
}

function getAliasPriceFeedParams(address token)
    external
    view
    returns (PriceFeedParams memory)

AccessMode public accessMode

bool public checksEnabled

function setAccessMode(AccessMode mode) external

// Restrict loss liquidations to authorized liquidators
IAliasedLossPolicyV3(policy).setAccessMode(
    AccessMode.Permissioned
);

function setChecksEnabled(bool enabled) external

// Disable checks temporarily if alias feeds are unavailable
IAliasedLossPolicyV3(policy).setChecksEnabled(false);

function setAliasPriceFeed(address token, address priceFeed) external

// Set redemption rate oracle as alias for staked token
IAliasedLossPolicyV3(policy).setAliasPriceFeed(
    stETH,
    stETHRedemptionRateOracle
);

// Unset alias price feed
IAliasedLossPolicyV3(policy).setAliasPriceFeed(
    stETH,
    address(0)
);

// Prepare price updates
PriceUpdate[] memory updates = new PriceUpdate[](1);
updates[0] = PriceUpdate({
    priceFeed: aliasPriceFeed,
    data: priceUpdateData  // Feed-specific update data
});

bytes memory extraData = abi.encode(updates);

// Check liquidation with updated prices
ILossPolicy.Params memory params = ILossPolicy.Params({
    twvUSD: twv,
    totalDebtUSD: debt,
    extraData: extraData
});

bool canLiquidate = policy.isLiquidatableWithLoss(
    account,
    msg.sender,
    params
);

enum AccessMode {
    Permissionless,  // Anyone can liquidate
    Permissioned,    // Only LOSS_LIQUIDATOR role
    Forbidden        // No loss liquidations
}

struct Params {
    uint256 twvUSD;        // Total weighted value in USD
    uint256 totalDebtUSD;  // Total debt in USD
    bytes extraData;       // Price update data
}

struct PriceUpdate {
    address priceFeed;  // Price feed to update
    bytes data;         // Update data for the feed
}

event SetAliasPriceFeed(
    address indexed token,
    address indexed priceFeed,
    uint32 stalenessPeriod,
    bool skipCheck
)

event UnsetAliasPriceFeed(address indexed token)

event SetAccessMode(AccessMode mode)

event SetChecksEnabled(bool enabled)

// 1. Configure alias price feed for stETH
IAliasedLossPolicyV3 policy = IAliasedLossPolicyV3(policyAddress);
policy.setAliasPriceFeed(stETH, stETHRedemptionOracle);

// 2. Set permissioned mode
policy.setAccessMode(AccessMode.Permissioned);

// 3. When liquidating with loss:
address[] memory requiredFeeds = policy.getRequiredAliasPriceFeeds(
    creditAccount
);

// 4. Prepare price updates for required feeds
PriceUpdate[] memory updates = new PriceUpdate[](requiredFeeds.length);
for (uint256 i = 0; i < requiredFeeds.length; i++) {
    updates[i] = PriceUpdate({
        priceFeed: requiredFeeds[i],
        data: getPriceUpdateData(requiredFeeds[i])
    });
}

// 5. Check if liquidation should proceed
ILossPolicy.Params memory params = ILossPolicy.Params({
    twvUSD: computedTWV,
    totalDebtUSD: totalDebt,
    extraData: abi.encode(updates)
});

bool shouldLiquidate = policy.isLiquidatableWithLoss(
    creditAccount,
    msg.sender,
    params
);

if (shouldLiquidate) {
    // Proceed with loss liquidation
}