EnzymeVaultSyncModel#

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[, filter_zero])	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.
`resync_nonce`()	Re-read hot wallet nonce before trade execution.
`sync_initial`(state, **kwargs)	Get the deployment event by scanning the whole chain from the start.
`sync_reinit`(state, **kwargs)	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.

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

get_related_position(portfolio, asset)[source]#

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:

portfolio (Portfolio) –
asset (AssetIdentifier) –

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:

portfolio (Portfolio) –
event (Deposit) –
strategy_cycle_ts (datetime) –

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:

portfolio (Portfolio) –
event (Redemption) –
strategy_cycle_ts (datetime) –

Return type:

List[BalanceUpdate]

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

Translate on-chain event data to our persistent format.

Parameters:

state (State) –
event (EnzymeBalanceEvent) –
strategy_cycle_ts (datetime) –

Return type:

List[BalanceUpdate]

sync_initial(state, **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)[source]#

Read the on-chain asset details.

Mark the block we are reading at the start

Parameters:

filter_zero – Do not return zero balances
assets (List[AssetIdentifier]) –

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)[source]#

Apply the balance sync before each strategy cycle.

Deposits by shareholders
Redemptions

Returns:

List of new treasury balance events

Raises:

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

Parameters:

strategy_cycle_ts (datetime) –
state (State) –
supported_reserves (Optional[List[AssetIdentifier]]) –

Return type:

List[BalanceUpdate]

sync_reinit(state, **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
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