EnzymeVaultSyncModel#

API documentation for tradeexecutor.ethereum.enzyme.vault.EnzymeVaultSyncModel Python class in Trading Strategy framework.

class EnzymeVaultSyncModel[source]#

Bases: SyncModel

Update Enzyme vault balances.

__init__(web3, vault_address, reorg_mon, only_chain_listener=True, hot_wallet=None, generic_adapter_address=None, vault_payment_forwarder_address=None, scan_chunk_size=10000)[source]#
Parameters:
  • web3 (Web3) – Web3

  • vault_address (str) – The address of the vault

  • reorg_mon (ReorganisationMonitor) – How to deal with block updates

  • only_chain_listerer

    This is the only adapter using reorg_mon.

    Will call process_blocks() as the part sync_treasury().

  • hot_wallet (Optional[HotWallet]) –

    Trade executor’s hot wallet used to create transactions.

    Only needed when doing trades.

  • generic_adapter_address (Optional[str]) –

    The vault specific deployed GenericAdapter smart contract.

    Needed to make trades.

  • scan_chunk_size – Ethereum eth_getLogs JSON-RPC workaround for a horrible blockchain APIs.

  • vault_payment_forwarder_address (Optional[str]) –

Methods

__init__(web3, vault_address, reorg_mon[, ...])

param web3:

check_ownership()

Check that the hot wallet has the correct ownership rights to make trades through the vault.

create_event_reader()

Create event reader for vault deposit/redemption events.

create_transaction_builder()

Creates a transaction builder instance to make trades against this asset management model.

fetch_onchain_balances(assets[, ...])

Read the on-chain asset details.

fetch_vault_reserve_asset()

Read the reserve asset from the vault data.

get_hot_wallet()

Get the vault address we are using.

get_related_position(portfolio, asset)

Map a redemption event asset to an underlying position.

get_token_storage_address()

Get the address where tokens are stored.

get_vault_address()

Get the vault address we are using

is_ready_for_live_trading(state)

Have we run init command on the vault.

process_blocks()

Process the reorgsanisation monitor blocks.

process_deposit(portfolio, event, ...)

Translate Enzyme SharesBought event to our internal deposit storage format.

process_redemption(portfolio, event, ...)

Translate Enzyme SharesBought event to our internal deposit storage format.

reset_deposits(state)

Clear out pending withdrawals/deposits events.

resync_nonce()

Re-read hot wallet nonce before trade execution.

sync_initial(state[, allow_override])

Get the deployment event by scanning the whole chain from the start.

sync_interests(timestamp, state, universe, ...)

Update interest on all tokens that receive interest thru rebase.

sync_reinit(state[, allow_override])

Reinitiliase the vault.

sync_treasury(strategy_cycle_ts, state[, ...])

Apply the balance sync before each strategy cycle.

translate_and_apply_event(state, event, ...)

Translate on-chain event data to our persistent format.

__init__(web3, vault_address, reorg_mon, only_chain_listener=True, hot_wallet=None, generic_adapter_address=None, vault_payment_forwarder_address=None, scan_chunk_size=10000)[source]#
Parameters:
  • web3 (Web3) – Web3

  • vault_address (str) – The address of the vault

  • reorg_mon (ReorganisationMonitor) – How to deal with block updates

  • only_chain_listerer

    This is the only adapter using reorg_mon.

    Will call process_blocks() as the part sync_treasury().

  • hot_wallet (Optional[HotWallet]) –

    Trade executor’s hot wallet used to create transactions.

    Only needed when doing trades.

  • generic_adapter_address (Optional[str]) –

    The vault specific deployed GenericAdapter smart contract.

    Needed to make trades.

  • scan_chunk_size – Ethereum eth_getLogs JSON-RPC workaround for a horrible blockchain APIs.

  • vault_payment_forwarder_address (Optional[str]) –

resync_nonce()[source]#

Re-read hot wallet nonce before trade execution.

Ensures that if the private key is used outside the trade executor, we are not getting wrong nonce error when broadcasting the transaction.

get_vault_address()[source]#

Get the vault address we are using

Return type:

Optional[str]

get_hot_wallet()[source]#

Get the vault address we are using.

Returns:

None if the executor is not using hot wallet (dummy, backtesting, etc.)

Return type:

Optional[HotWallet]

get_token_storage_address()[source]#

Get the address where tokens are stored.

Returns:

Vault address for enzyme, wallet address for hot wallet.

Return None for DummySyncModel e.g. in the case of unit and backtests.

Return type:

Optional[str]

is_ready_for_live_trading(state)[source]#

Have we run init command on the vault.

Parameters:

state (State) –

Return type:

bool

process_blocks()[source]#

Process the reorgsanisation monitor blocks.

Raises:

ChainReorganisationDetected – When any if the block data in our internal buffer does not match those provided by events.

Returns:

Range to scan for the events

Return type:

Tuple[int, int]

fetch_vault_reserve_asset()[source]#

Read the reserve asset from the vault data.

Return type:

AssetIdentifier

Map a redemption event asset to an underlying position.

Raises:

UnknownAsset – If we got a redemption event for an asset that does not belong to any of our positions

Parameters:
Return type:

tradeexecutor.state.reserve.ReservePosition | tradeexecutor.state.position.TradingPosition

process_deposit(portfolio, event, strategy_cycle_ts)[source]#

Translate Enzyme SharesBought event to our internal deposit storage format.

Parameters:
Return type:

BalanceUpdate

process_redemption(portfolio, event, strategy_cycle_ts)[source]#

Translate Enzyme SharesBought event to our internal deposit storage format.

In-kind redemption exchanges user share tokens to underlying assets.

  • User gets whatever strategy reserves there is

  • User gets share of whatever spot positions there are currently open

Parameters:
Return type:

List[BalanceUpdate]

translate_and_apply_event(state, event, strategy_cycle_ts)[source]#

Translate on-chain event data to our persistent format.

Parameters:
Return type:

List[BalanceUpdate]

sync_initial(state, allow_override=False, **kwargs)[source]#

Get the deployment event by scanning the whole chain from the start.

Updates state.sync.deployment structure.

Note

You need to give start_block hint of the scanning will take too long because Ethereum design flaws.

Example:

sync_model.sync_initial(state, start_block=35_123_123)
Parameters:

state (State) –

fetch_onchain_balances(assets, filter_zero=True, block_identifier=None)[source]#

Read the on-chain asset details.

  • Mark the block we are reading at the start

  • Asset list is sorted to be by address to make sure the return order is deterministic

Parameters:
  • filter_zero – Do not return zero balances

  • 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]]) – Cbeck at certain block height.

  • assets (List[AssetIdentifier]) –

Returns:

Iterator for assets by the sort order.

Return type:

Iterable[OnChainBalance]

create_event_reader()[source]#

Create event reader for vault deposit/redemption events.

Set up the reader interface for fetch_deployment_event() extract_timestamp is disabled to speed up the event reading, we handle it separately

Returns:

Tuple (event reader, quick node workarounds).

Return type:

Tuple[Web3EventReader, bool]

sync_treasury(strategy_cycle_ts, state, supported_reserves=None, end_block=None)[source]#

Apply the balance sync before each strategy cycle.

Parameters:
  • strategy_cycle_ts (datetime) –

    The current strategy cycle.

    Resevers are synced before executing the strategy cycle.

  • state (State) – Current state of the execution.

  • supported_reverses

    List of assets the strategy module wants to use as its reserves.

    May be None in testing.

  • end_block (Optional[int]) – Sync until this block.

  • supported_reserves (Optional[List[AssetIdentifier]]) –

Returns:

List of balance updates detected.

  • Deposits

  • Redemptions

Return type:

List[BalanceUpdate]

sync_reinit(state, allow_override=False, **kwargs)[source]#

Reinitiliase the vault.

Fixes broken accounting. Only needs to be used if internal state and blockchain state have somehow managed to get out of sync: internal state has closed positions that are not in blockchain state or vice versa.

  • Makes any token balances in the internal state to match the blockchain state.

  • Assumes all positions are closed (currently artificial limitation).

  • All position history is deleted, because we do not know whether positions closed for profit or loss.

See tradeexexcutor.cli.commands.reinit for details.

Note

Currently quite a test code. Make support all positions, different sync models.

Parameters:
  • state (State) – Empty state

  • allow_override – Allow init twice.

  • kwargs

    Initial sync hints.

    Passed to sync_initial().

create_transaction_builder()[source]#

Creates a transaction builder instance to make trades against this asset management model.

Only needed when trades are being executed.

Returns:

Depending on the asset management mode.

Return type:

EnzymeTransactionBuilder

check_ownership()[source]#

Check that the hot wallet has the correct ownership rights to make trades through the vault.

Hot wallet must be registered either as

  • Vault owner

  • Vault asset manager

Raises:

AssertionError – If the hot wallet cannot perform trades for the vault

reset_deposits(state)[source]#

Clear out pending withdrawals/deposits events.

Parameters:

state (State) –