LidoAdapterLib

Git Source

Title: LidoAdapterLib

Authors: David Dada <daveproxy80@gmail.com> (https://github.com/dadadave80), Modified from Lido (https://github.com/lidofinance/core)

Logic for a Lido staking strategy under the buffer model. The asset is WETH; on deploy idle WETH is unwrapped to ETH, staked via Lido.submit, and the resulting stETH wrapped into wstETH (held). The synchronous IStrategy.withdraw is served only from the idle WETH buffer and is shortfall-honest. The slow Lido-queue exit runs out-of-band via requestWithdrawal (wstETH → stETH → enqueue) and claimWithdrawal (finalized request → ETH → re-wrap into the buffer). Reentrancy-gated, pause/emergency-aware.

Functions

lidoAdapterStorage

function lidoAdapterStorage() internal pure returns (LidoAdapterStorage storage $);

Returns

__LidoAdapter_init

function __LidoAdapter_init(
        address weth_,
        address lido_,
        address wstETH_,
        address withdrawalQueue_,
        address vault_,
        address recipient_
    ) internal;

Parameters

registerInterface

function registerInterface() internal;

asset

function asset() internal view returns (address);

Returns

weth

function weth() internal view returns (address);

Returns

lido

function lido() internal view returns (address);

Returns

wstETH

function wstETH() internal view returns (address);

Returns

withdrawalQueue

function withdrawalQueue() internal view returns (address);

Returns

vault

function vault() internal view returns (address);

Returns

rewardRecipient

function rewardRecipient() internal view returns (address);

Returns

operator

function operator() internal view returns (address);

Returns

_wethUnwrapper

function _wethUnwrapper() private returns (address unwrapper_);

Returns

_checkOperator

function _checkOperator() private view;

bufferBalance

function bufferBalance() internal view returns (uint256);

Returns

stakedWstETH

function stakedWstETH() internal view returns (uint256);

Returns

pendingWithdrawalAssets

function pendingWithdrawalAssets() internal view returns (uint256);

Returns

pendingRequestCount

function pendingRequestCount() internal view returns (uint256);

Returns

pendingRequestAt

function pendingRequestAt(uint256 index) internal view returns (uint256);

Parameters

Returns

minHealthFactor

function minHealthFactor() internal pure returns (uint256);

Returns

healthFactor

function healthFactor() internal pure returns (uint256);

Returns

isPaused

function isPaused() internal view returns (bool);

Returns

totalAssetsManaged

NAV in WETH/ETH units = idle WETH buffer + wstETH valued in stETH + pending in-queue stETH.

KNOWN LIMITATION — stETH/ETH de-peg (not corrected here; this NAV is intentionally market-price-blind). During a stress event stETH can trade at a discount to ETH while this function still values the staked + queued legs at par. Consequence: a holder who redeems against the synchronous WETH buffer is paid at the (inflated) par NAV, while the staked leg must exit slowly through the Lido queue at the eventual realized (discounted) value — the difference is socialized onto the remaining shareholders. This is a valuation-vs-realizable mismatch, not an on-chain-manipulable bug (the redemption rate is monotone and not attacker- controlled). MITIGATION until corrected: bound exposure by capping this strategy's vault allocation target. A standing WETH buffer is not a lever: rebalance() calls deploy() and re-stakes the whole buffer each time (#221), after first recalling from it when the strategy is over target. A synchronous recall therefore pays out only what a claimed queue exit put into the buffer before that rebalance; otherwise it is a partial recall until a claim lands. FUTURE FIX: apply a haircut to stakedValue + _pendingAssets from a Chainlink stETH/ETH feed (via the existing ChainlinkAdapter) whenever stETH is below peg.

function totalAssetsManaged() internal view returns (uint256);

Returns

setRewardRecipient

function setRewardRecipient(address recipient) internal;

Parameters

setOperator

Sets the authorized operator for deploy/withdraw/harvest (admin-only). Rejects address(0) so the trio cannot be opened to an unauthenticated default.

function setOperator(address operator_) internal;

Parameters

deploy

Sweeps the idle WETH buffer into Lido: WETH → ETH → stETH (submit) → wstETH (wrap).

function deploy() internal returns (uint256 deployed);

Returns

withdraw

Synchronous IStrategy.withdraw — served only from the idle WETH buffer.

function withdraw(uint256 amount, address to) internal returns (uint256 withdrawn);

Parameters

Returns

requestWithdrawal

Unwraps wstAmount wstETH to stETH and enqueues it in the Lido withdrawal queue (admin/keeper). Records the request id + stETH amount as pending so NAV is unchanged by the move (staked value falls, pending rises by the same stETH amount).

function requestWithdrawal(uint256 wstAmount) internal returns (uint256 requestId);

Parameters

Returns

claimWithdrawal

Claims a finalized withdrawal request (permissionless/keeper): pulls the owed ETH from the queue (a full-gas payout that lands via the diamond's Receive facet), wraps it 1:1 into the WETH buffer, and clears the request from pending.

function claimWithdrawal(uint256 requestId) internal returns (uint256 ethReceived);

Parameters

Returns

harvest

No-op: Lido yield accrues in the wstETH→stETH exchange rate (reflected in NAV), NOT a claimable reward token, so there is nothing to claim or forward on the standard IProtocolAdapter.harvest() path. Kept as a graceful no-op (for an authorized operator) so a keeper sweep never reverts. Use harvestToken to forward a specific stray (airdropped) token. Operator-gated for parity with the other adapters' trio.

function harvest() internal view;

harvestToken

Forwards the adapter's entire balance of a stray token raw to the reward recipient (admin/keeper). The three core tokens (WETH buffer, stETH hop, wstETH stake) are rejected so a sweep can never drain the position or the buffer.

function harvestToken(address token) internal;

Parameters

emergencyWithdraw

Emergency exit (admin, runs even when stopped): sends the entire WETH buffer to the vault now AND enqueues the full wstETH stake in the Lido withdrawal queue.

function emergencyWithdraw() internal returns (uint256 recovered);

Returns

_enqueue

function _enqueue(LidoAdapterStorage storage $, uint256 wstAmount) private returns (uint256 requestId);

Parameters

Returns