Vault

Interfaces

IAlephVault

interface IAlephVault {
    // Vault metadata
    function name() external view returns (string memory);
    function manager() external view returns (address);
    function underlyingToken() external view returns (address);
    function custodian() external view returns (address);
    
    // Batch tracking
    function startTimeStamp() external view returns (uint48);
    function currentBatch() external view returns (uint48);
    
    // Share class/series info
    function shareClasses() external view returns (uint8);
    function shareSeriesId(uint8 _classId) external view returns (uint32);
    function lastConsolidatedSeriesId(uint8 _classId) external view returns (uint32);
    
    // Assets and shares
    function totalAssets() external view returns (uint256);
    function totalAssetsPerClass(uint8 _classId) external view returns (uint256);
    function totalAssetsPerSeries(uint8 _classId, uint32 _seriesId) external view returns (uint256);
    function totalSharesPerSeries(uint8 _classId, uint32 _seriesId) external view returns (uint256);
    
    // User positions
    function assetsOf(uint8 _classId, uint32 _seriesId, address _user) external view returns (uint256);
    function sharesOf(uint8 _classId, uint32 _seriesId, address _user) external view returns (uint256);
    function assetsPerClassOf(uint8 _classId, address _user) external view returns (uint256);
    function redeemableAmount(address _user) external view returns (uint256);
    
    // Pricing
    function pricePerShare(uint8 _classId, uint32 _seriesId) external view returns (uint256);
    function highWaterMark(uint8 _classId, uint32 _seriesId) external view returns (uint256);
    
    // Share class parameters
    function managementFee(uint8 _classId) external view returns (uint32);
    function performanceFee(uint8 _classId) external view returns (uint32);
    function noticePeriod(uint8 _classId) external view returns (uint48);
    function lockInPeriod(uint8 _classId) external view returns (uint48);
    function minDepositAmount(uint8 _classId) external view returns (uint256);
    function minUserBalance(uint8 _classId) external view returns (uint256);
    function maxDepositCap(uint8 _classId) external view returns (uint256);
    function minRedeemAmount(uint8 _classId) external view returns (uint256);
    
    // Request queries
    function depositRequestOf(uint8 _classId, address _user) external view returns (uint256);
    function redeemRequestOf(uint8 _classId, address _user) external view returns (uint256);
    function totalAmountToDeposit(uint8 _classId) external view returns (uint256);
}

IAlephVaultDeposit

interface IAlephVaultDeposit {
    struct RequestDepositParams {
        uint8 classId;
        uint256 amount;
        AuthLibrary.AuthSignature authSignature;
    }
    
    // Async deposit (batched)
    function requestDeposit(RequestDepositParams calldata _params) external returns (uint48 _batchId);
    
    // Sync deposit (instant) - typically called by AVS
    function syncDeposit(RequestDepositParams calldata _params) external returns (uint256 shares);
    
    // Timelock setters
    function queueMinDepositAmount(uint8 _classId, uint256 _amount) external;
    function queueMinUserBalance(uint8 _classId, uint256 _balance) external;
    function queueMaxDepositCap(uint8 _classId, uint256 _cap) external;
    function setMinDepositAmount(uint8 _classId) external;
    function setMinUserBalance(uint8 _classId) external;
    function setMaxDepositCap(uint8 _classId) external;
}

IAlephVaultRedeem

interface IAlephVaultRedeem {
    struct RedeemRequestParams {
        uint8 classId;
        uint256 estAmountToRedeem;
    }
    
    // Async redeem (batched)
    function requestRedeem(RedeemRequestParams calldata _params) external returns (uint48 _batchId);
    
    // Sync redeem (instant) - typically called by AVS
    function syncRedeem(RedeemRequestParams calldata _params) external returns (uint256 amount);
    
    // Withdraw settled amounts
    function withdrawRedeemableAmount() external;
    function withdrawExcessAssets() external;
    
    // Timelock setters
    function queueNoticePeriod(uint8 _classId, uint48 _period) external;
    function queueLockInPeriod(uint8 _classId, uint48 _period) external;
    function queueMinRedeemAmount(uint8 _classId, uint256 _amount) external;
    function setNoticePeriod(uint8 _classId) external;
    function setLockInPeriod(uint8 _classId) external;
    function setMinRedeemAmount(uint8 _classId) external;
}

IAlephVaultSettlement

interface IAlephVaultSettlement {
    struct SettlementParams {
        uint8 classId;
        uint48 toBatchId;
        uint256[] newTotalAssets;  // Per-series NAV
        AuthLibrary.AuthSignature authSignature;
    }
    
    // Settle pending requests
    function settleDeposit(SettlementParams calldata _params) external;
    function settleRedeem(SettlementParams calldata _params) external;
    
    // Emergency redemption
    function forceRedeem(address _user) external;
}

IFeeManager

interface IFeeManager {
    // View functions
    function getManagementFeeShares(
        uint32 _managementFee,
        uint48 _batchesElapsed,
        uint256 _newTotalAssets,
        uint256 _totalShares
    ) external view returns (uint256);
    
    function getPerformanceFeeShares(
        uint32 _performanceFee,
        uint256 _newTotalAssets,
        uint256 _totalShares,
        uint256 _highWaterMark
    ) external pure returns (uint256);
    
    // Timelock setters
    function queueManagementFee(uint8 _classId, uint32 _fee) external;
    function queuePerformanceFee(uint8 _classId, uint32 _fee) external;
    function setManagementFee(uint8 _classId) external;
    function setPerformanceFee(uint8 _classId) external;
    
    // Fee operations
    function accumulateFees(
        uint8 _classId,
        uint32 _seriesId,
        uint48 _currentBatchId,
        uint48 _lastFeePaidId,
        uint256 _newTotalAssets,
        uint256 _totalShares
    ) external returns (uint256);
    
    function collectFees() external returns (uint256 mgmtFees, uint256 perfFees);
}

Data Structures

ShareClassParams

struct ShareClassParams {
    uint32 managementFee;    // Basis points per year (e.g., 200 = 2%)
    uint32 performanceFee;   // Basis points on profits (e.g., 2000 = 20%)
    uint48 noticePeriod;     // Batches before redemption effective
    uint48 lockInPeriod;     // Minimum batches before first redemption
    uint256 minDepositAmount; // Minimum per-deposit amount
    uint256 minUserBalance;   // Minimum balance to maintain
    uint256 maxDepositCap;    // Maximum vault capacity
    uint256 minRedeemAmount;  // Minimum per-redemption amount
}

ShareSeries

struct ShareSeries {
    uint256 totalAssets;
    uint256 totalShares;
    uint256 highWaterMark;
    EnumerableSet.AddressSet users;
    mapping(address => uint256) sharesOf;
}

AuthSignature

struct AuthSignature {
    bytes32 r;
    bytes32 s;
    uint8 v;
    uint256 expiry;
    bytes32 nonce;
}

Events

Deposit Events

event DepositRequest(uint8 classId, uint48 batchId, address indexed user, uint256 amount);
event SettleDeposit(
    uint8 classId,
    uint32 seriesId,
    uint48 indexed fromBatchId,
    uint48 indexed toBatchId,
    uint256 amountToSettle,
    uint256 totalAssets,
    uint256 totalShares
);
event DepositRequestSettled(
    uint8 classId,
    uint32 seriesId,
    uint48 indexed toBatchId,
    address indexed user,
    uint256 amount,
    uint256 sharesToMint
);

Redemption Events

event RedeemRequest(uint8 classId, uint48 batchId, address indexed user, uint256 estAmountToRedeem);
event SettleRedeem(uint8 classId, uint48 indexed fromBatchId, uint48 indexed toBatchId);
event RedeemRequestSettled(uint8 classId, uint48 indexed batchId, address indexed user, uint256 amountToRedeem);
event RedeemableAmountWithdrawn(address indexed user, uint256 redeemableAmount);
event ForceRedeem(uint48 indexed batchId, address indexed user, uint256 totalAssetsToSettle);

Series Events

event NewSeriesCreated(uint8 classId, uint32 seriesId, uint48 toBatchId);
event SeriesConsolidated(
    uint8 classId,
    uint32 seriesId,
    uint48 toBatchId,
    uint256 amountToTransfer,
    uint256 sharesToTransfer
);
event AllSeriesConsolidated(
    uint8 classId,
    uint32 fromSeriesId,
    uint32 toSeriesId,
    uint48 toBatchId,
    uint256 totalAmountToTransfer,
    uint256 totalSharesToTransfer
);

Fee Events

event FeesAccumulated(
    uint8 classId,
    uint32 seriesId,
    uint48 lastFeePaidId,
    uint48 currentBatchId,
    uint256 newTotalAssets,
    uint256 newTotalShares,
    FeesAccumulatedParams feesAccumulatedParams
);
event NewHighWaterMarkSet(uint8 classId, uint32 seriesId, uint48 toBatchId, uint256 highWaterMark);
event FeesCollected(uint48 currentBatchId, uint256 managementFeesCollected, uint256 performanceFeesCollected);

Error Codes

Deposit Errors

Error	Description
InsufficientDeposit	Amount below minimum
DepositLessThanMinDepositAmount	Below class minimum
DepositLessThanMinUserBalance	Would leave balance below minimum
DepositExceedsMaxDepositCap	Exceeds vault capacity
OnlyOneRequestPerBatchAllowedForDeposit	Already requested this batch

Redemption Errors

Error	Description
RedeemLessThanMinRedeemAmount	Amount below minimum
InsufficientAssetsToRedeem	Not enough shares
RedeemFallBelowMinUserBalance	Would violate minimum balance
OnlyOneRequestPerBatchAllowedForRedeem	Already requested this batch
InsufficientVaultBalance	Vault lacks liquidity

Settlement Errors

Error	Description
InvalidNewTotalAssets	Bad NAV data
InvalidToBatchId	Invalid settlement range
NoDepositsToSettle	Nothing to settle
NoRedeemsToSettle	Nothing to settle
InsufficientAssetsToSettle	Vault underfunded

Integration Example

Checking User Position

function getUserTotalPosition(
    address vault,
    address user
) external view returns (uint256 totalAssets, uint256 pendingDeposits, uint256 redeemable) {
    IAlephVault v = IAlephVault(vault);
    uint8 numClasses = v.shareClasses();
    
    for (uint8 classId = 0; classId < numClasses; classId++) {
        // Settled assets
        totalAssets += v.assetsPerClassOf(classId, user);
        
        // Pending deposits
        pendingDeposits += v.depositRequestOf(classId, user);
    }
    
    // Redeemable amount
    redeemable = v.redeemableAmount(user);
}

Deposit

function deposit(
    address vault,
    uint8 classId,
    uint256 amount,
    AuthLibrary.AuthSignature calldata sig
) external returns (uint48 batchId) {
    IERC20 token = IERC20(IAlephVault(vault).underlyingToken());
    
    // Approve vault to pull tokens
    token.approve(vault, amount);
    
    // Request deposit
    batchId = IAlephVaultDeposit(vault).requestDeposit(
        IAlephVaultDeposit.RequestDepositParams({
            classId: classId,
            amount: amount,
            authSignature: sig
        })
    );
}

Redeem

function redeem(
    address vault,
    uint8 classId,
    uint256 estimatedAmount
) external returns (uint48 batchId) {
    // Request redemption
    batchId = IAlephVaultRedeem(vault).requestRedeem(
        IAlephVaultRedeem.RedeemRequestParams({
            classId: classId,
            estAmountToRedeem: estimatedAmount
        })
    );
}

function claimRedemption(address vault) external {
    IAlephVaultRedeem(vault).withdrawRedeemableAmount();
}

Constants

// Precision for share calculations
uint256 constant TOTAL_SHARE_UNITS = 1e18;

// Basis point denominator
uint256 constant BPS_DENOMINATOR = 10_000;

// Seconds per year (for fee calculations)
uint256 constant SECONDS_PER_YEAR = 365.25 days;