# lpETH: Unified Liquidity for (re)staked ETH

Instantly unstake for a tiny fee. Borrow against your stake without depegs. Bribe Liquidity Providers. All staked assets, one pool to support them all. DeFi summer 2.0 is right around the corner.

**🤝 For stakers, by stakers**

LpETH is specifically designed for staked assets, solving key issues that exist for stake in DeFi today, creating better experiences for stakers and liquidity providers alike.

#### **🌊 Unified Liquidity**

LpETH unifies liquidity for swapping and borrowing for all LSTs into a single pool, solving the fragmentation that exists today and creating better opportunities for liquidity providers and stakers.

#### **⚔️ The Stake Wars**

LpETH is **bringing back the Curve wars**! Liquidity providers can be bribed. LSTs protocols giving better bribes can receive lower fees or interest rates for their users versus their competitors. LSTs can tap into available liquidity without bootstrapping their own pools and bribe their way to success.

## Introduction

"lpETH" is a new DeFi primitive unifiying liquidity for liquid (re) staked ETH. It's a single-sided liquidity pool containing just ETH, and acts as a clearinghouse for LSTs. "lpETH" has following important characteristics:

* **Single-Sided Liquidity:** The pool contains ETH provided by liquidity providers.
* **Swap Multiple LSTs/LRTs:** The pool accepts multiple LSTs/LRTs to be swapped for ETH, unifying their liquidity and volume, creating an attractive opportunity for LPs.
* **Instant Swaps:** Users can swap their ETH LSTs/LRTs for ETH instantly for a small fee, bypassing withdrawal queues.
* **Mechanics:** Received LSTs/LRTs from swaps are unstaked by the pool, increasing their respective utilisation until ETH is available for withdrawal.
* **Pricing:** LSTs/LRTs are priced based on their backed ETH. Trading fees are based on the relative utilisation of ETH in the pool by each LST/LRT, and thus their current demand for instant exits.
* **Fee Gauges & Bribes:** Fee gauge is a ratio applied to the fees for a particular LST/LRT that can be adjusted based on token bribes given to LPs.
* **lpETH:** The liquidity pool token, representing the user’s share of liquidity.

<figure><img src="https://276120184-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F29Sq9aVO6bZwCobNudVH%2Fuploads%2FEqbEDRWUXSEAPfHbflsy%2Fimage.png?alt=media&amp;token=cb83952f-dd5c-4cf8-8065-e82efacc9d94" alt="" width="563"><figcaption></figcaption></figure>


# Why lpETH

{% hint style="info" %}
**lpETH is a liquidity protocol specifically designed for staked assets. It solves key issues that currently exist in DeFi with staked assets and provides a more interesting opportunity to liquidity providers.**
{% endhint %}

## DeFi isn't built for staked assets

{% hint style="danger" %}
The current paradigms and strategies used within DeFi aren't really suited for liquid staked ETH derivatives. We've seen unnecessary loss of capital and high friction in capital markets as a result.&#x20;

The existing paradigm treats LSTs and LRTs as a primary asset, using a floating market price to determine their exchange rate for ETH. This exchange rate is subsequently used to trigger liquidations in lending protocols, but **this ignores the underlying backing of ETH**.
{% endhint %}

{% hint style="success" %}
Instead of determining a market price, an LST should be valued based on its underlying backing of ETH. "lpETH" uses this approach, and charges a premium based on the demand for getting instant liquidity for a particular LST.
{% endhint %}

## Fragmented Liquidity

{% hint style="danger" %}
Currently, LSTs and LRTs all have their own isolated liquidity pools that all require individual incentives for sustainable liquidity.  Liquidity providers find themselves split between various pools, despite all these LSTs and LRTs representing ETH underneath (homogenous assets).&#x20;
{% endhint %}

{% hint style="success" %}
"lpETH" allows for the unification of all this liquidity and volume. This creates a much more attractive opportunity for liquidity providers, but also removes the cold start problem for new LSTs coming to market.
{% endhint %}

## Capital Ineffciency

{% hint style="danger" %}
Current liquidity pools, such as those on Uniswap or Curve, necessitate liquidity to be provided in pairs, such as stETH/ETH. This requirement is capital inefficient because the primary goal is to facilitate the exchange of LSTs back into ETH, while the reverse transaction is rarely used except for arbitrage purposes.&#x20;

Moreover, LSTs can always be minted at a 1:1 ratio for ETH. Consequently, this portion of liquidity is redundant and could be more effectively allocated elsewhere by liquidity providers.
{% endhint %}

{% hint style="success" %}
"lpETH" frees up the LST capital for liquidity providers to deploy elsewhere and provides a much simpler liquidity provision opportunity.
{% endhint %}


# How it works

[White paper](https://docs.tenderize.me/tenderswap/white-paper)


# For Stakers

## Swap

Instantly swap your favorite LST or LRTs back for ETH without having to wait for the withdrawal queue, which can be upward of 3-4 days or longer. Pay a small fee based on the amount of ETH available in the pool and the current demand for liquidity of the LST you want to swap.

## Borrow (coming soon)

Borrow ETH against your LSTs or LRTs without depeg risk while keeping exposure to your staking yield.&#x20;

LSTs provided as collateral are valued based on how much ETH is backing them, rather than a fluctuating market price. This means your position isn't exposed to price risk or oracle manipulation. In fact, as long as the interest rate is equal or lower to the staking yield, you **could never be liquidated**.


# For Liquidity Providers

## Swap

Provide liquidity and earn trading fees from various LSTs or LRTs seeking instant liquidity for their staked ETH. Earn bribes and additional incentives by participating in governance and locking up your lpETH tokens.

## Lend (coming soon)

Lend out your ETH to earn interest from various LST collateral types in a single pool.&#x20;


# For LST/LRT Protocols

## Bribes

The competitiveness of an LST consists of a few parameters, but on-chain liquidity is definitely one of them. By bribing liquidity providers you can receive better fees for your users compared to other LSTs.

## Access Existing Liquidity

Solve the liquidity cold start problem for your LST/LRT by getting whitelisted on lpETH and tap into the existing liquidity in the lpETH pool. Amplify your early competitiveness by giving bribes to lpETH liquidity providers.


# The Stake Wars

Protocols battle over liquidity as a scarce resource

The amount of available liquidity for an LST/LRT is directly correlated to their market size. More liquidity is a significant signal, as there's more immediate exit capacity available, reducing risk. Building up sufficient liquidity as a new LST or LRT, or even maintaining your existing position in the liquidity market, is challenging and costly.

With lpETH, bootstrapping your own pools is a thing of the past. Protocols giving better bribes can receive lower fees or interest rates for their users versus their competitors. New LSTs/LRTs can tap into available liquidity without bootstrapping their own pools and bribe their way to success.

Equally, protocols could acquire their own governance tokens to vote on their fee gauges while remaining long-term aligned with the pool.  Ultimately, the amount of liquidity that can exist to service the LST/LRT market is finite. Protocols will have to find the most optimal ways to most efficiently provide liquidity for their user base, lpETH simplifies that.


# Voting Escrow

Participating in governance and earning bribes and other potential incentives, requires an account to have locked their liquidity pool tokens, lpETH. Users can choose a lockup between 1 week and 52 weeks, with improved rewards and more voting weight for longer lockups. \
\
Voting weight resulting from the locked "lpETH" is represented as "veLpETH". A non-transferrable ERC20 token of which the balance decays over time. VeTokens are both used for voting but also value-accrual, meaning the longer your remaining lockup the higher your voting weight but also the higher your share of any incentive pool.

### Dual Governance

Once the governance token goes live, governance will be subject to dual governance, where both lpETH or the governance token can be used.


# Fee Gauges & Bribes

### Fee Gauges

Governance participants can vote on "fee gauges" for specific LSTs. A lower fee gauge means a particular LST is charged lower fees by the pool compared to other LSTs with a higher fee gauge, for an equal amount of available liquidity. \
\
Fee gauges can be lower or higher for certain LSTs or LRTs if they give more incentives to liquidity providers or if they have a lower/higher perceived risk than others (e.g. some restaked ETH could carry higher risk than regular LSTs).

### Bribes

LSTs/LRTs can offer bribes to the pool to improve their fee gauge, and thus their competitive advantage in the market. Bribes can be offered either through various tokens, such as our own governance token, the LSTs own governance token or other tokens.


# Swap


# Making a Swap

## Step 1 - Connect your wallet

Go to <https://app.lpeth.xyz> and connect your favorite wallet.

<figure><img src="https://276120184-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F29Sq9aVO6bZwCobNudVH%2Fuploads%2F1aaom9x40ErnjxyCAKw2%2Fimage.png?alt=media&amp;token=bbe99c4a-7a41-4095-9f63-57f097b767d5" alt="" width="563"><figcaption></figcaption></figure>

## Step 2 - Select LST

Select the LST or LRT you want to swap.

<figure><img src="https://276120184-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F29Sq9aVO6bZwCobNudVH%2Fuploads%2FsQ5BAG4XbkqATFpeJT41%2Fimage.png?alt=media&amp;token=aa05fb22-7e12-47ae-a629-8dc56dd676b4" alt="" width="563"><figcaption></figcaption></figure>

## Step 3- Approve amount to be swapped

LSTs require approval before they can be swapped, the application will prompt if approval is required. Proceed in your wallet to continue.

<figure><img src="https://276120184-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F29Sq9aVO6bZwCobNudVH%2Fuploads%2FirbFKCxp742ArZ6LtC01%2Fimage.png?alt=media&amp;token=94fccbcf-b5d0-465e-82ca-1c88d840aa2d" alt="" width="563"><figcaption></figcaption></figure>

## Step 4 - Swap your tokens !&#x20;

Swap your tokens and confirm the transaction in your wallet !&#x20;

<figure><img src="https://276120184-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F29Sq9aVO6bZwCobNudVH%2Fuploads%2FJymttEXA8Uqn31wRMubH%2Fimage.png?alt=media&amp;token=60597f4c-0376-4798-bc90-9bf49f76e291" alt="" width="563"><figcaption></figcaption></figure>

<figure><img src="https://276120184-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F29Sq9aVO6bZwCobNudVH%2Fuploads%2FHD0040piljhsLEZYi5Nt%2Fimage.png?alt=media&amp;token=3d15e819-3f97-4d6a-8686-abaac8f1c1f5" alt="" width="563"><figcaption></figcaption></figure>


# Adding Liquidity

## Step 1- Go to the "Liquidity" tab and connect your wallet

<figure><img src="https://276120184-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F29Sq9aVO6bZwCobNudVH%2Fuploads%2FnM45JVDsCWL1mCxNYpHk%2Fimage.png?alt=media&amp;token=32487057-eb9e-4e26-8922-ba9bda43a451" alt="" width="563"><figcaption></figcaption></figure>

## Step 2 - Deposit ETH

Input the amount of ETH you wish to deposit. You'll be able to see the amount of lpETH you'll receive, representing your share of liquidity in the pool. Confirm the transaction in your wallet.

### Rewards

Rewards will automatically accrue to your liquidity position, you can check your current rewards in the "liquidity" tab.

<figure><img src="https://276120184-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F29Sq9aVO6bZwCobNudVH%2Fuploads%2Fan0oUjZ35RDjGZMGbyMV%2Fimage.png?alt=media&amp;token=c155f643-6ea8-4bd4-9050-71c2d1d298b0" alt=""><figcaption></figcaption></figure>


# Removing Liquidity

On the "Liquidity" tab, navigate to the "withdraw" tab inside the widget. Enter the amount of LP tokens you wish to burn to receive back ETH. Confirm the transaction in your wallet.

<figure><img src="https://276120184-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F29Sq9aVO6bZwCobNudVH%2Fuploads%2F504zKTK0eikrcBxVo44D%2Fimage.png?alt=media&amp;token=76be7dc0-1dde-4510-b529-848bbbdce9bf" alt=""><figcaption></figcaption></figure>


# Borrow (coming soon)

Coming Fall 2024 👀


# Overview

The lpETH contracts are deployed on Ethereum mainnet.

\
They consist of largely 3 components:

* &#x20;**LpETH**: the main contract to swap tokens and manage liquidity
* **LpToken:** An ERC-20 token representing liquidity shares of the pool. Minted upon deposit, burnt upon withdrawal.
* **UnsETH:** An ERC-721 NFT representing LSTs/LRTs while in their withdrawal queue.

### Audits

The contracts are audited by Halborn, the latest audits can be found below.

{% file src="/files/gcnEB00ao80Vrs1hBJqt" %}

{% file src="/files/wwd7BV8jw57f08tjWau7" %}


# LpETH docs

This page provides developer documentation for the most important endpoints of the `LpETH` contract. The `LpETH` contract facilitates liquidity pooling of ETH, allowing users to deposit ETH and receive LP tokens, withdraw ETH, swap assets, and participate in the protocol's liquidity mechanisms.

### Table of Contents

* Swap
* Quote
* Deposit
* Withdraw
* Claim Withdraw Request
* Redeem Unlock
* Buy Unlock
* Claim Relayer Rewards
* Events
* Disclaimer

***

### Swap

#### `swap(address asset, uint256 amount, uint256 minOut)`

Swaps a supported asset for ETH.

```solidity
swap(address asset, uint256 amount, uint256 minOut) external nonreentrant returns (uint256 out, uint256 fee)
```

**Parameters:**

* `asset` (`address`): The address of the asset to swap.
* `amount` (`uint256`): The amount of the asset to swap.
* `minOut` (`uint256`): The minimum amount of ETH the user expects to receive.

**Returns:**

* `out` (`uint256`): The amount of ETH received.
* `fee` (`uint256`): The fee charged for the swap.

**Description:**

* Transfers the specified asset from the user to the contract.
* Approves the `UnsETH` contract to handle the asset.
* Requests withdrawal from `UnsETH`, receiving a token ID and expected amount.
* Calculates the ETH output and fee.
* Reverts if the ETH output is less than `minOut` to prevent slippage.
* Transfers the ETH to the user.

**Events:**

* `Swap(address indexed caller, address indexed asset, uint256 amountIn, uint256 fee, uint256 unlockId)`

**Errors:**

* `ErrorInvalidAsset(address asset)`: Thrown if the asset is not supported.
* `ErrorSlippage(uint256 out, uint256 minOut)`: Thrown if the ETH output is less than `minOut`.

***

### Quote

#### `quote(address asset, uint256 amount)`

Provides an estimate of the ETH amount and fee for swapping a given asset.

```solidity
quote(address asset, uint256 amount) external view returns (uint256 out, uint256 fee)
```

**Parameters:**

* `asset` (`address`): The address of the asset to swap.
* `amount` (`uint256`): The amount of the asset to swap.

**Returns:**

* `out` (`uint256`): The estimated amount of ETH the user will receive.
* `fee` (`uint256`): The estimated fee for the swap.

**Description:**

* Calculates the expected ETH output and fee based on the current pool state.
* Useful for users to understand the swap outcome before executing.

**Errors:**

* `ErrorInvalidAsset(address asset)`: Thrown if the asset is not supported.

***

### Deposit

#### `deposit(uint256 minLpShares)`

Allows users to deposit ETH into the pool and receive LP tokens in return.

```solidity
deposit(uint256 minLpShares) external payable returns (uint256 lpShares)
```

**Parameters:**

* `minLpShares` (`uint256`): The minimum amount of LP tokens the user expects to receive to prevent slippage.

**Returns:**

* `lpShares` (`uint256`): The number of LP tokens minted to the user.

**Description:**

* Users send ETH along with this function call.

* Calculates the number of LP tokens to mint based on the pool's current liabilities and total supply.

* Mints LP tokens to the user.

**Events:**

* `Deposit(address indexed from, uint256 amount, uint256 lpSharesMinted)`

**Errors:**

* `ErrorSlippage(uint256 out, uint256 minOut)`: Thrown if the LP shares to mint are less than `minLpShares`.
* `ErrorDepositSharesZero()`: Thrown if the calculated LP shares are zero.

***

### Withdraw

#### `withdraw(uint256 amount, uint256 maxLpSharesBurnt)`

Allows users to withdraw ETH by burning their LP tokens.

```solidity
withdraw(uint256 amount, uint256 maxLpSharesBurnt) external nonreentrant returns (uint256 requestId)
```

**Parameters:**

* `amount` (`uint256`): The amount of ETH the user wants to withdraw.
* `maxLpSharesBurnt` (`uint256`): The maximum number of LP tokens the user is willing to burn to prevent slippage.

**Returns:**

* `requestId` (`uint256`): The ID of the withdrawal request if applicable.

**Description:**

* Calculates the number of LP tokens to burn based on the withdrawal amount.
* Reverts if the LP shares to burn exceed `maxLpSharesBurnt`.
* If there's insufficient liquidity, creates a withdrawal request for the remaining amount.
* Burns the user's LP tokens.
* Transfers available ETH to the user.

**Events:**

* `Withdraw(address indexed to, uint256 amount, uint256 lpSharesBurnt, uint256 requestId)`

**Errors:**

* `DepositedInCurrentTx()`: Thrown if a withdrawal is attempted in the same transaction as a deposit.
* `ErrorSlippage(uint256 out, uint256 maxLpSharesBurnt)`: Thrown if the LP shares to burn exceed `maxLpSharesBurnt`.
* `ErrorDepositSharesZero()`: Thrown if the calculated LP shares are zero.

***

### Claim Withdraw Request

#### `claimWithdrawRequest(uint256 id)`

Allows users to claim their finalized withdrawal requests.

```solidity
claimWithdrawRequest(uint256 id) external returns (uint256 amount)
```

**Parameters:**

* `id` (`uint256`): The ID of the withdrawal request.

**Returns:**

* `amount` (`uint256`): The amount of ETH claimed.

**Description:**

* Finalizes the withdrawal request and transfers the ETH to the requester.
* Updates the pool's liabilities.

**Events:**

* `ClaimWithdrawRequest(uint256 indexed requestId, address indexed to, uint256 amount)`

***

### Redeem Unlock

#### `redeemUnlock()`

Allows relayers to redeem finalized unlocks and claim rewards.

```solidity
redeemUnlock() external nonreentrant
```

**Description:**

* Retrieves the oldest unlock from the queue.
* Checks if the unlock is finalized.
* Claims the withdrawal from the `UnsETH` contract.

**Events:**

* `UnlockRedeemed(address indexed relayer, uint256 tokenId, uint256 amount, uint256 reward, uint256 lpFees)`

**Errors:**

* `ErrorNotFinalized(uint256 tokenId)`: Thrown if the unlock is not finalized.

***

### Buy Unlock

#### `buyUnlock(uint256 expectedTokenId)`

Allows users to purchase unfinalized unlocks at a discounted rate.

```solidity
buyUnlock(uint256 expectedTokenId) external payable nonreentrant returns (uint256 tokenId)
```

**Parameters:**

* `expectedTokenId` (`uint256`): The expected token ID of the unlock to purchase.

**Returns:**

* `tokenId` (`uint256`): The actual token ID of the unlock purchased.

**Description:**

* Retrieves the newest unlock from the queue.
* Checks if the unlock is not finalized and not expired.
* Verifies that the token ID matches `expectedTokenId`.
* Calculates the reward (discount) for purchasing the unlock.
* Transfers the unlock to the buyer.

**Events:**

* `UnlockBought(address indexed caller, uint256 tokenId, uint256 amount, uint256 reward, uint256 lpFees)`

**Errors:**

* `UnexpectedTokenId()`: Thrown if the token ID does not match `expectedTokenId`.
* `ErrorIsFinalized(uint256 tokenId)`: Thrown if the unlock is already finalized.
* `ErrorRecoveryMode()`: Thrown if the pool is in recovery mode.
* `ErrorInsufficientAmount()`: Thrown if the sent ETH is insufficient.

***

### Claim Relayer Rewards

#### `claimRelayerRewards()`

Allows relayers to claim their accumulated rewards.

```solidity
claimRelayerRewards() external returns (uint256 relayerReward)
```

**Returns:**

* `relayerReward` (`uint256`): The amount of rewards claimed.

**Description:**

* Transfers the accumulated rewards to the relayer.
* Resets the relayer's reward balance.
* Emits a `RelayerRewardsClaimed` event.

**Events:**

* `RelayerRewardsClaimed(address indexed relayer, uint256 rewards)`

***

### Events

* `Deposit(address indexed from, uint256 amount, uint256 lpSharesMinted)`
* `Withdraw(address indexed to, uint256 amount, uint256 lpSharesBurnt, uint256 requestId)`
* `ClaimWithdrawRequest(uint256 indexed requestId, address indexed to, uint256 amount)`
* `Swap(address indexed caller, address indexed asset, uint256 amountIn, uint256 fee, uint256 unlockId)`
* `UnlockRedeemed(address indexed relayer, uint256 tokenId, uint256 amount, uint256 reward, uint256 lpFees)`
* `UnlockBought(address indexed caller, uint256 tokenId, uint256 amount, uint256 reward, uint256 lpFees)`
* `RelayerRewardsClaimed(address indexed relayer, uint256 rewards)`

***

### Notes

* **Access Control:** Some functions are restricted using modifiers like `onlyOwner` and `nonreentrant`.
* **Upgradeable Contract:** The contract uses OpenZeppelin's upgradeable pattern via `UUPSUpgradeable`.
* **External Contracts:** Interacts with external contracts like `UnsETH`, `Registry`, and `LPToken`.
* **Mathematical Libraries:** Utilizes libraries like `FixedPointMathLib` and `UD60x18` for precise calculations.
* **ETH Handling:** Functions are marked `payable` where necessary, and ETH transfers are handled carefully to prevent issues.

***

**Disclaimer:** This documentation provides a high-level overview of the most important endpoints of the `LpETH` contract. Developers should refer to the actual contract code and conduct thorough testing before interacting with the contract in a production environment.


# Deployed contracts

| **Category** | **Name**                | **Address**                                                                                                           |
| ------------ | ----------------------- | --------------------------------------------------------------------------------------------------------------------- |
| **Registry** | Registry Implementation | [0x3A7432E481f4cDFfb129dEdA6C4F148d0d53c92F](https://etherscan.io/address/0x3A7432E481f4cDFfb129dEdA6C4F148d0d53c92F) |
|              | Registry Proxy          | [0x809581787Ec6406b43e7Bd33E161D2D02653F8D9](https://etherscan.io/address/0x809581787Ec6406b43e7Bd33E161D2D02653F8D9) |
| **UnsETH**   | UnsETH Implementation   | [0x9ee2Bc58638C4370f20e18CD900124ca1d664618](https://etherscan.io/address/0x9ee2Bc58638C4370f20e18CD900124ca1d664618) |
|              | UnsETH Proxy            | [0x67cf179C3F8aCcaa30386cFe0C0305cF6cF30F6D](https://etherscan.io/address/0x67cf179C3F8aCcaa30386cFe0C0305cF6cF30F6D) |
| **LPETH**    | LPETH Implementation    | [0x6ba966d78e7abb92b199d49b90a662a158456030](https://etherscan.io/address/0x6ba966d78e7abb92b199d49b90a662a158456030) |
|              | LPETH Proxy             | [0xF3a75E087A92770b4150fFF14c6d36FB07796252](https://etherscan.io/address/0xF3a75E087A92770b4150fFF14c6d36FB07796252) |
|              | LP Token                | [0x70D48c92C443322d60327816c3dE04AE2f539E1A](https://etherscan.io/address/0x70D48c92C443322d60327816c3dE04AE2f539E1A) |
| **Adapters** | EETH Adapter            | [0xb8021AeF3f090A1072d42DFeaD9f5f32B59f3b3D](https://etherscan.io/address/0xb8021AeF3f090A1072d42DFeaD9f5f32B59f3b3D) |
|              | ETHx Adapter            | [0xdF4c39b017701F6A3BAa6E37aE682d70d4977074](https://etherscan.io/address/0xdF4c39b017701F6A3BAa6E37aE682d70d4977074) |
|              | METH Adapter            | [0x799547b5D4cE1C4b08d58E823466626c1526d0e9](https://etherscan.io/address/0x799547b5D4cE1C4b08d58E823466626c1526d0e9) |
|              | StETH Adapter           | [0xbB490f85C96EAc51A1FDeFD16adf319E68Bb90Ed](https://etherscan.io/address/0xbB490f85C96EAc51A1FDeFD16adf319E68Bb90Ed) |
|              | SwETH Adapter           | [0x32cD868b7d414aA814fb50ac35043A97b2937248](https://etherscan.io/address/0x32cD868b7d414aA814fb50ac35043A97b2937248) |