erc_4626.vault_protocol.yearn.vault
Documentation for eth_defi.erc_4626.vault_protocol.yearn.vault Python module.
Yearn vault support.
Classes
Yearn V3 vaults. |
- class YearnV3Vault
Bases:
eth_defi.erc_4626.vault.ERC4626VaultYearn V3 vaults.
Yearn v3 vaults are ERC-4626 compliant vaults with multiple strategies, built wit Vyper (not Solidity)
Yearn vault can have multiple strategies, identified by calling get_default_queue().
Withdraw happens in the order of this strategy queue
The queue strategies can be SiloStrategy and other Yearn vault contracts
Fees are internatilised and are built into the share price: The strategies takes profit by minting more shares to the strategies themselves. This is why external fees are set to zero.
More information:
Example Yearn v3 vault (Vyper)
Example SiloStrategy contract
Yearn’s own internal vault metadata JSON endpoint - check for isRetired flag
Use Yearn Powerglove to explore exposure and allocation of Yearn vaults
Max withdrawl:
def _max_withdraw( owner: address, max_loss: uint256, strategies: DynArray[address, MAX_QUEUE] ) -> uint256: ''' @dev Returns the max amount of `asset` an `owner` can withdraw. This will do a full simulation of the withdraw in order to determine how much is currently liquid and if the `max_loss` would allow for the tx to not revert. This will track any expected loss to check if the tx will revert, but not account for it in the amount returned since it is unrealised and therefore will not be accounted for in the conversion rates. i.e. If we have 100 debt and 10 of unrealised loss, the max we can get out is 90, but a user of the vault will need to call withdraw with 100 in order to get the full 90 out. '''Withdrawal:
@internal def _withdraw_from_strategy(strategy: address, assets_to_withdraw: uint256): ''' This takes the amount denominated in asset and performs a {redeem} with the corresponding amount of shares. We use {redeem} to natively take on losses without additional non-4626 standard parameters. ''' # Need to get shares since we use redeem to be able to take on losses. shares_to_redeem: uint256 = min( # Use previewWithdraw since it should round up. IStrategy(strategy).previewWithdraw(assets_to_withdraw), # And check against our actual balance. IStrategy(strategy).balanceOf(self) ) # Redeem the shares. IStrategy(strategy).redeem(shares_to_redeem, self, self)Taking profit:
def _process_report(strategy: address) -> (uint256, uint256): ``` Processing a report means comparing the debt that the strategy has taken with the current amount of funds it is reporting. If the strategy owes less than it currently has, it means it has had a profit, else (assets < debt) it has had a loss. Different strategies might choose different reporting strategies: pessimistic, only realised P&L, ... The best way to report depends on the strategy. The profit will be distributed following a smooth curve over the vaults profit_max_unlock_time seconds. Losses will be taken immediately, first from the profit buffer (avoiding an impact in pps), then will reduce pps. Any applicable fees are charged and distributed during the report as well to the specified recipients. Can update the vaults `totalIdle` to account for any airdropped tokens by passing the vaults address in as the parameter. ```- Parameters
web3 – Connection we bind this instance to
spec – Chain, address tuple
token_cache –
Cache used with
fetch_erc20_details()to avoid multiple calls to the same token.Reduces the number of RPC calls when scanning multiple vaults.
features – Pass vault feature flags along, externally detected.
default_block_identifier –
Override block identifier for on-chain metadata reads.
When
None, useget_safe_cached_latest_block_number()(the default, safe for broken RPCs). Set to"latest"for freshly deployed vaults whose contracts do not exist at the safe-cached block.
- property vault_contract: web3.contract.contract.Contract
Get vault deployment.
- get_management_fee(block_identifier)
Get the current management fee as a percent.
Internal: Use
get_fee_data().
- get_performance_fee(block_identifier)
Get the current performance fee as a percent.
Internal: Use
get_fee_data().
- get_estimated_lock_up()
ERC-4626 vaults do not have a lock up by fault.
Note
Because of so many protocol specific lockups, this must be explicitly set to zero.
- Return type
- get_link(referral=None)
Get a link to the vault dashboard on its native site.
By default, give RouteScan link
- __init__(web3, spec, token_cache=None, features=None, default_block_identifier=None)
- Parameters
web3 (web3.main.Web3) – Connection we bind this instance to
spec (eth_defi.vault.base.VaultSpec) – Chain, address tuple
token_cache (dict | None) –
Cache used with
fetch_erc20_details()to avoid multiple calls to the same token.Reduces the number of RPC calls when scanning multiple vaults.
features (set[eth_defi.erc_4626.core.ERC4626Feature] | None) – Pass vault feature flags along, externally detected.
default_block_identifier (Optional[Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]]) –
Override block identifier for on-chain metadata reads.
When
None, useget_safe_cached_latest_block_number()(the default, safe for broken RPCs). Set to"latest"for freshly deployed vaults whose contracts do not exist at the safe-cached block.
- property address: eth_typing.evm.HexAddress
Get the vault smart contract address.
- property denomination_token: eth_defi.token.TokenDetails | None
Get the token which denominates the vault valuation
Used in deposits and redemptions
Used in NAV calculation
Used in profit benchmarks
Usually USDC
- Returns
Token wrapper instance.
Maybe None for broken vaults like https://arbiscan.io/address/0x9d0fbc852deccb7dcdd6cb224fa7561efda74411#code
- property deposit_manager: eth_defi.vault.deposit_redeem.VaultDepositManager
Deposit manager assocaited with this vault
- property erc_7540: bool
Is this ERC-7540 vault with asynchronous deposits.
For example
previewDeposit()function and other functions will revert
- fetch_denomination_token()
Read denomination token from onchain.
Use
denomination_token()for cached access.- Return type
eth_defi.token.TokenDetails | None
- fetch_denomination_token_address()
Get the address for the denomination token.
Triggers RCP call
- Return type
Fetch the most recent onchain NAV value.
In the case of Lagoon, this is the last value written in the contract with updateNewTotalAssets() and ` settleDeposit()`
TODO: updateNewTotalAssets() there is no way to read pending asset update on chain
- Returns
Vault NAV, denominated in
denomination_token()- Return type
- fetch_portfolio(universe, block_identifier=None, allow_fallback=True)
Read the current token balances of a vault.
SHould be supported by all implementations
- Parameters
universe (eth_defi.vault.base.TradingUniverse) –
block_identifier (Optional[Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]]) –
allow_fallback (bool) –
- Return type
Get the current share price.
Read share token details onchain.
Use
share_token()for cached access.- Return type
Get share token of this vault.
Vault itself (ERC-4626)
share() accessor (ERc-7575)
- fetch_total_assets(block_identifier)
What is the total NAV of the vault.
Example:
assert vault.denomination_token.symbol == "USDC" assert vault.share_token.symbol == "ipUSDCfusion" assert vault.fetch_total_assets(block_identifier=test_block_number) == Decimal("1437072.77357") assert vault.fetch_total_supply(block_identifier=test_block_number) == Decimal("1390401.22652875")
- Parameters
block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) –
Block number to read.
Use web3.eth.block_number for the last block.
- Returns
The vault value in underlyinh token
- Return type
decimal.Decimal | None
- fetch_total_supply(block_identifier)
What is the current outstanding shares.
Example:
- Parameters
block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) –
Block number to read.
Use web3.eth.block_number for the last block.
- Returns
The vault value in underlyinh token
- Return type
- fetch_vault_info()
Get all information we can extract from the vault smart contracts.
- Return type
- property flow_manager: eth_defi.vault.base.VaultFlowManager
Flow manager associated with this vault
- get_deposit_fee(block_identifier)
Deposit fee is set to zero by default as vaults usually do not have deposit fees.
Internal: Use
get_fee_data().
- get_deposit_manager()
Get deposit manager to deposit/redeem from the vault.
- get_fee_data()
Get fee data structure for this vault.
- Raises
ValueError – In the case of broken or unimplemented fee reading methods in the smart contract
- Return type
- get_fee_mode()
Get how this vault accounts its fees.
- Return type
- get_flags()
Get various vault state flags from the smart contract.
Override to add status flags
Also add flags from our manual flag list in
eth_defi.vault.flag
- Returns
Flag set.
Do not modify in place.
- Return type
set[eth_defi.vault.flag.VaultFlag]
- get_flow_manager()
Get flow manager to read indiviaul settle events.
Only supported if
has_block_range_event_support()is True
- Return type
- get_historical_reader(stateful)
Get share price reader to fetch historical returns.
- Parameters
stateful – If True, use a stateful reading strategy.
- Returns
None if unsupported
- Return type
- get_notes()
Get a human readable message if we know somethign special is going on with this vault.
- Return type
str | None
- get_risk()
Get risk profile of this vault.
- Return type
- get_withdraw_fee(block_identifier)
Withdraw fee is set to zero by default as vaults usually do not have withdraw fees.
Internal: Use
get_fee_data().
- has_block_range_event_support()
Does this vault support block range-based event queries for deposits and redemptions.
If not we use chain balance polling-based approach
- has_deposit_distribution_to_all_positions()
Deposits go automatically to all open positions.
Deposits do not land into the vault as cash
Instead, smart contracts automatically increase all open positions
The behaviour of Velvet Capital
- property info: eth_defi.vault.base.VaultInfo
Get info dictionary related to this vault deployment.
Get cached data on the various vault parameters
- Returns
Vault protocol specific information dictionary
- is_valid()
Check if this vault is valid.
Call a known smart contract function to verify the function exists
- Return type
ERC-20 that presents vault shares.
User gets shares on deposit and burns them on redemption
- property underlying_token: eth_defi.token.TokenDetails
Alias for
denomination_token()