AVS

Interface

IAlephAVS

interface IAlephAVS is IAVSRegistrar {
    // View functions
    function erc20Factory() external view returns (IERC20Factory);
    function vaultToSlashedStrategy(address vault) external view returns (IStrategy);
    function vaultToOriginalStrategy(address vault) external view returns (IStrategy);
    
    // Vault initialization (owner only)
    function initializeVault(
        uint8 _classId,
        address _vault,
        IStrategy _lstStrategy
    ) external returns (IStrategy slashedStrategy);
    
    // Allocation (operators only)
    function allocate(
        address _alephVault, 
        IAlephVaultDeposit.RequestDepositParams calldata _requestDepositParams
    ) external;
    
    // Unallocation - Step 1: Request (any token holder)
    function requestUnallocate(
        address _alephVault,
        uint256 _tokenAmount
    ) external returns (uint48 batchId, uint256 estAmountToRedeem);
    
    // Unallocation - Step 2: Complete (any token holder)
    function completeUnallocate(
        address _alephVault,
        uint256 _strategyDepositExpiry,
        bytes calldata _strategyDepositSignature
    ) external returns (uint256 amount, uint256 shares);
    
    // View helpers for unallocation
    function calculateUnallocateAmount(
        address _alephVault, 
        uint256 _tokenAmount
    ) external view returns (uint256 estimatedAmount, IStrategy strategy, IERC20 token);
    
    function getPendingUnallocateStatus(
        address _user,
        address _alephVault
    ) external view returns (
        uint256 userPendingAmount,
        uint256 totalPendingAmount,
        uint256 redeemableAmount,
        bool canComplete
    );
    
    function calculateCompleteUnallocateAmount(
        address _user,
        address _alephVault
    ) external view returns (uint256 expectedAmount);
}

Storage Layout (ERC-7201)

/// @custom:storage-location erc7201:aleph.avs.storage
struct AVSStorage {
    // ERC20 factory for creating slashed tokens
    IERC20Factory erc20Factory;
    
    // Vault -> Slashed Strategy mapping
    mapping(address vault => IStrategy slashedStrategy) vaultToSlashedStrategy;
    
    // Vault -> Original Strategy mapping
    mapping(address vault => IStrategy originalStrategy) vaultToOriginalStrategy;
    
    // Vault -> Class ID mapping
    mapping(address vault => uint8 classId) vaultToClassId;
    
    // Operator Set -> Strategy existence tracking
    mapping(uint32 operatorSetId => mapping(address strategy => bool exists)) strategyExists;
    
    // User -> Vault -> Pending unallocation amount
    mapping(address user => mapping(address vault => uint256 estAmountToRedeem)) pendingUnallocate;
    
    // Vault -> Total pending unallocation amount
    mapping(address vault => uint256 totalEstAmount) totalPendingUnallocate;
    
    // Vault -> Withdrawn amount (for proportional distribution)
    mapping(address vault => uint256 withdrawnAmount) vaultWithdrawnAmount;
}

// Storage slot: keccak256("aleph.avs.storage") - 1
bytes32 constant AVS_STORAGE_LOCATION = 0x032f19bc7820640f5c22e33241af744bedc756ef7c75496e1c948383db604100;

Operator Sets

The AVS maintains one operator set for organizing strategies:

Set ID	Name	Purpose
0	LST_STRATEGIES_OPERATOR_SET	Original LST strategies

The operator set is configured as a redistributing operator set, meaning slashed amounts are sent to the AVS contract rather than being burned.

Functions

initializeVault

Initializes a vault by creating its slashed token and strategy.

function initializeVault(
    uint8 _classId,
    address _vault,
    IStrategy _lstStrategy
) external onlyRole(OWNER) returns (IStrategy slashedStrategy)

Parameters:

• _classId: The share class ID for the vault

• _vault: The vault address to initialize

• _lstStrategy: The original LST strategy for the vault's underlying token

Returns:

• slashedStrategy: The created slashed strategy address

Events:

event VaultInitialized(
    address indexed vault,
    uint8 classId,
    address indexed originalToken,
    address indexed slashedToken,
    address slashedStrategy
);

allocate

Allocates delegated stake to a vault by slashing, depositing, and creating rewards.

function allocate(
    address _alephVault, 
    IAlephVaultDeposit.RequestDepositParams calldata _requestDepositParams
) external nonReentrant onlyOperator validAmount(_requestDepositParams.amount)

Parameters:

• _alephVault: Target vault address

• _requestDepositParams: Deposit parameters including classId, amount, and auth signature

Events:

event SlashExecuted(
    address indexed operator,
    uint32 operatorSetId,
    address indexed strategy,
    address indexed underlyingToken,
    uint256 amount,
    uint256 slashId
);

event AllocatedToAlephVault(
    address indexed operator,
    address indexed alephVault,
    address originalStrategy,
    address slashedStrategy,
    uint256 amount,
    uint256 vaultShares,
    uint8 classId
);

requestUnallocate

First step of the two-step unallocation process. Requests to redeem slashed tokens from a vault.

function requestUnallocate(
    address _alephVault,
    uint256 _tokenAmount
) external nonReentrant validAmount(_tokenAmount) validVault(_alephVault) returns (
    uint48 batchId,
    uint256 estAmountToRedeem
)

Parameters:

• _alephVault: Vault to unallocate from

• _tokenAmount: Amount of slashed strategy tokens to burn

Returns:

• batchId: The batch ID for the redeem request

• estAmountToRedeem: The estimated amount that will be redeemed from the vault

Events:

event UnallocateRequested(
    address indexed tokenHolder,
    address indexed alephVault,
    address slashedStrategy,
    uint256 tokenAmount,
    uint256 estAmountToRedeem,
    uint48 batchId,
    uint8 classId
);

Use Case: This is the first step. After calling this, the user must wait for the vault to process the redemption request before calling completeUnallocate.

completeUnallocate

Second step of the two-step unallocation process. Completes the unallocation by withdrawing redeemable amount and depositing back to strategy.

function completeUnallocate(
    address _alephVault,
    uint256 _strategyDepositExpiry,
    bytes calldata _strategyDepositSignature
) external nonReentrant validVault(_alephVault) returns (uint256 amount, uint256 shares)

Parameters:

• _alephVault: Vault to complete unallocation from

• _strategyDepositExpiry: Signature expiry timestamp

• _strategyDepositSignature: EIP-712 signature for strategy deposit

Returns:

• amount: The amount of tokens redeemed from the vault and deposited to the strategy

• shares: The shares received in the original LST strategy

Events:

event UnallocateCompleted(
    address indexed tokenHolder,
    address indexed alephVault,
    address originalStrategy,
    address slashedStrategy,
    uint256 amount,
    uint256 shares,
    uint8 classId
);

Use Case: Call after requestUnallocate once the vault has redeemable amount available. Use getPendingUnallocateStatus() to check if this can be called.

calculateUnallocateAmount

View function to estimate redemption amounts for the first step.

function calculateUnallocateAmount(
    address _alephVault, 
    uint256 _tokenAmount
) external view validVault(_alephVault) returns (
    uint256 estimatedAmount, 
    IStrategy strategy, 
    IERC20 token
)

Use Case: Call before requestUnallocate to determine the estimated amount that will be redeemed.

getPendingUnallocateStatus

View function to check pending unallocation status.

function getPendingUnallocateStatus(
    address _user,
    address _alephVault
) external view returns (
    uint256 userPendingAmount,
    uint256 totalPendingAmount,
    uint256 redeemableAmount,
    bool canComplete
)

Use Case: Check if completeUnallocate can be called. Returns canComplete = true if the user has pending amount and the vault has redeemable amount.

calculateCompleteUnallocateAmount

View function to calculate the expected amount for completeUnallocate.

function calculateCompleteUnallocateAmount(
    address _user,
    address _alephVault
) external view returns (uint256 expectedAmount)

Use Case: Call before completeUnallocate to get the exact expected amount for signature generation. This ensures the signature matches the amount that will be deposited.

Libraries

AlephSlashing

Handles redistribution calculations and execution.

library AlephSlashing {
    // Calculate magnitude from token amount
    function calculateMagnitudeFromAmount(
        IAllocationManager _allocationManager,
        address _operator,
        OperatorSet memory _operatorSet,
        uint256 _amount,
        IStrategy _strategy
    ) internal view returns (uint64 magnitudeToSlash);
    
    // Execute slash and return slash ID
    function executeSlashAndGetId(
        IAllocationManager _allocationManager,
        address _avsAddress,
        address _operator,
        uint32 _operatorSetId,
        uint64 _magnitudeToSlash,
        IStrategy _strategy,
        string memory _slashDescription
    ) internal returns (uint256 slashId);
    
    // Clear redistributable shares to receive tokens
    function clearRedistributableShares(
        IStrategyManager _strategyManager,
        address _avsAddress,
        uint32 _operatorSetId,
        uint256 _slashId,
        IStrategy _strategy
    ) internal returns (uint256 tokenAmount);
}

AlephVaultManagement

Handles vault interactions.

library AlephVaultManagement {
    // Get vault token and strategy
    function getVaultTokenAndStrategy(
        IAlephVaultFactory _vaultFactory,
        IStrategyFactory _strategyFactory,
        address _vault
    ) internal view returns (IERC20 vaultToken, IStrategy strategy);
    
    // Create slashed strategy for vault
    function createSlashedStrategyForVault(
        IStrategyFactory _strategyFactory,
        address _vault,
        IERC20 _originalToken,
        mapping(address => IStrategy) storage _vaultToSlashedStrategy,
        IERC20Factory _erc20Factory,
        address _minter
    ) internal returns (IERC20 slashedToken, IStrategy slashedStrategy);
    
    // Deposit to vault
    function depositToAlephVault(
        address _vault,
        IAlephVaultDeposit.RequestDepositParams calldata _requestDepositParams,
        uint256 _tokenAmount
    ) internal returns (uint256 shares);
    
    // Redeem from vault
    function redeemFromVault(
        address _vault,
        uint256 _shares,
        uint8 _classId
    ) internal returns (uint256 amount);
}

RewardsManagement

Handles reward submissions.

library RewardsManagement {
    // Validate operator split is 0
    function validateOperatorSplit(
        IRewardsCoordinator _rewardsCoordinator, 
        address _operator, 
        address _avsAddress
    ) internal view;
    
    // Submit operator-directed rewards
    function submitOperatorDirectedRewards(
        IRewardsCoordinator _rewardsCoordinator,
        address _avsAddress,
        address _operator,
        IStrategy _stakerStrategy,
        IERC20Eigen _rewardToken,
        uint256 _rewardAmount,
        string memory _rewardsDescription
    ) internal;
    
    // Calculate retroactive rewards window
    function calculateRetroactiveRewardsWindow(
        IRewardsCoordinator _rewardsCoordinator
    ) internal view returns (uint32 startTimestamp, uint32 duration);
}

Events Reference

event OperatorRegistered(address indexed operator, uint32[] operatorSetIds);
event OperatorDeregistered(address indexed operator, uint32[] operatorSetIds);
event SlashExecuted(
    address indexed operator,
    uint32 operatorSetId,
    address indexed strategy,
    address indexed underlyingToken,
    uint256 amount,
    uint256 slashId
);
event AllocatedToAlephVault(
    address indexed operator,
    address indexed alephVault,
    address originalStrategy,
    address slashedStrategy,
    uint256 amount,
    uint256 vaultShares,
    uint8 classId
);
event UnallocateCompleted(
    address indexed tokenHolder,
    address indexed alephVault,
    address originalStrategy,
    address slashedStrategy,
    uint256 amount,
    uint256 shares,
    uint8 classId
);
event VaultInitialized(
    address indexed vault,
    uint8 classId,
    address indexed originalToken,
    address indexed slashedToken,
    address slashedStrategy
);
event UnallocateRequested(
    address indexed tokenHolder,
    address indexed alephVault,
    address slashedStrategy,
    uint256 tokenAmount,
    uint256 estAmountToRedeem,
    uint48 batchId,
    uint8 classId
);