def ethereum_manager( ethrpc_port, etherscan, messages_aggregator, ethrpc_endpoint, ethereum_manager_connect_at_start, greenlet_manager, database, ): if ethrpc_endpoint is None: endpoint = f'http://localhost:{ethrpc_port}' else: endpoint = ethrpc_endpoint manager = EthereumManager( ethrpc_endpoint=endpoint, etherscan=etherscan, database=database, msg_aggregator=messages_aggregator, greenlet_manager=greenlet_manager, connect_at_start=ethereum_manager_connect_at_start, ) wait_until_all_nodes_connected( ethereum_manager_connect_at_start=ethereum_manager_connect_at_start, ethereum=manager, ) return manager
def _transform_btc_address( ethereum: EthereumManager, given_address: str, ) -> BTCAddress: """Returns a SegWit/P2PKH/P2SH address (if existing) given an ENS domain. NB: ENS domains for BTC store the scriptpubkey. Check EIP-2304. """ if not given_address.endswith('.eth'): return BTCAddress(given_address) resolved_address = ethereum.ens_lookup( given_address, blockchain=SupportedBlockchain.BITCOIN, ) if resolved_address is None: raise ValidationError( f'Given ENS address {given_address} could not be resolved for Bitcoin', field_name='address', ) from None try: address = scriptpubkey_to_btc_address(bytes.fromhex(resolved_address)) except EncodingError as e: raise ValidationError( f'Given ENS address {given_address} does not contain a valid Bitcoin ' f"scriptpubkey: {resolved_address}. Bitcoin address can't be obtained.", field_name='address', ) from e log.debug(f'Resolved BTC ENS {given_address} to {address}') return address
def ethereum_manager(ethrpc_port, etherscan, messages_aggregator): ethrpc_endpoint = f'http://localhost:{ethrpc_port}' return EthereumManager( ethrpc_endpoint=ethrpc_endpoint, etherscan=etherscan, msg_aggregator=messages_aggregator, attempt_connect=False, )
def __init__(self, data_directory='.'): self.data_directory = Path(data_directory) self.config = yaml.load(open(self.data_directory / 'buchfink.yaml', 'r'), Loader=yaml.SafeLoader) self.reports_directory = self.data_directory / "reports" self.trades_directory = self.data_directory / "trades" self.cache_directory = self.data_directory / "cache" self.reports_directory.mkdir(exist_ok=True) self.trades_directory.mkdir(exist_ok=True) self.cache_directory.mkdir(exist_ok=True) (self.cache_directory / 'cryptocompare').mkdir(exist_ok=True) (self.cache_directory / 'history').mkdir(exist_ok=True) (self.cache_directory / 'inquirer').mkdir(exist_ok=True) self.cryptocompare = Cryptocompare( self.cache_directory / 'cryptocompare', self) self.historian = PriceHistorian(self.cache_directory / 'history', '01/01/2014', self.cryptocompare) self.inquirer = Inquirer(self.cache_directory / 'inquirer', self.cryptocompare) self.msg_aggregator = MessagesAggregator() self.greenlet_manager = GreenletManager( msg_aggregator=self.msg_aggregator) # Initialize blockchain querying modules self.etherscan = Etherscan(database=self, msg_aggregator=self.msg_aggregator) self.all_eth_tokens = AssetResolver().get_all_eth_tokens() self.alethio = Alethio( database=self, msg_aggregator=self.msg_aggregator, all_eth_tokens=self.all_eth_tokens, ) self.ethereum_manager = EthereumManager( ethrpc_endpoint=self.get_eth_rpc_endpoint(), etherscan=self.etherscan, msg_aggregator=self.msg_aggregator, ) #self.chain_manager = ChainManager( # blockchain_accounts=[], # owned_eth_tokens=[], # ethereum_manager=self.ethereum_manager, # msg_aggregator=self.msg_aggregator, # alethio=alethio, # greenlet_manager=self.greenlet_manager, # premium=False, # eth_modules=ethereum_modules, #) self.ethereum_analyzer = EthereumAnalyzer( ethereum_manager=self.ethereum_manager, database=self, )
def _transform_eth_address(ethereum: EthereumManager, given_address: str) -> ChecksumEthAddress: try: address = to_checksum_address(given_address) except ValueError: # Validation will only let .eth names come here. # So let's see if it resolves to anything resolved_address = ethereum.ens_lookup(given_address) if resolved_address is None: raise ValidationError( f'Given ENS address {given_address} could not be resolved', field_name='address', ) else: address = to_checksum_address(resolved_address) log.info(f'Resolved ENS {given_address} to {address}') return address
def ethereum_manager( ethrpc_port, etherscan, messages_aggregator, ethrpc_endpoint, ethereum_manager_connect_at_start, ): if ethrpc_endpoint is None: endpoint = f'http://localhost:{ethrpc_port}' else: endpoint = ethrpc_endpoint return EthereumManager( ethrpc_endpoint=endpoint, etherscan=etherscan, msg_aggregator=messages_aggregator, attempt_connect=ethereum_manager_connect_at_start, )
def _transform_ksm_address( ethereum: EthereumManager, given_address: str, ) -> KusamaAddress: """Returns a KSM address (if exists) given an ENS domain. At this point any given address has been already validated either as an ENS name or as a valid Kusama address (ss58 format). NB: ENS domains for Substrate chains (e.g. KSM, DOT) store the Substrate public key. It requires to encode it with a specific ss58 format for obtaining the specific chain address. Kusama/Polkadot ENS domain accounts: https://guide.kusama.network/docs/en/mirror-ens ENS domain substrate public key encoding: https://github.com/ensdomains/address-encoder/blob/master/src/index.ts """ if not given_address.endswith('.eth'): return KusamaAddress(given_address) resolved_address = ethereum.ens_lookup( given_address, blockchain=SupportedBlockchain.KUSAMA, ) if resolved_address is None: raise ValidationError( f'Given ENS address {given_address} could not be resolved for Kusama', field_name='address', ) from None try: address = get_kusama_address_from_public_key( SubstratePublicKey(resolved_address)) except (TypeError, ValueError) as e: raise ValidationError( f'Given ENS address {given_address} does not contain a valid ' f"Substrate public key: {resolved_address}. Kusama address can't be obtained.", field_name='address', ) from e log.debug(f'Resolved KSM ENS {given_address} to {address}') return address
def init_ethereum(rpc_endpoint: str, use_other_nodes: bool) -> EthereumManager: nodes_to_connect = ETHEREUM_NODES_TO_CONNECT_AT_START if use_other_nodes else ( NodeName.OWN, ) msg_aggregator = MessagesAggregator() etherscan = Etherscan(database=None, msg_aggregator=msg_aggregator) api_key = os.environ.get('ETHERSCAN_API_KEY', None) greenlet_manager = GreenletManager(msg_aggregator=msg_aggregator) etherscan.api_key = api_key ethereum = EthereumManager( ethrpc_endpoint=rpc_endpoint, etherscan=etherscan, msg_aggregator=msg_aggregator, greenlet_manager=greenlet_manager, connect_at_start=nodes_to_connect, ) wait_until_all_nodes_connected( ethereum_manager_connect_at_start=nodes_to_connect, ethereum=ethereum, ) return ethereum
def unlock_user( self, user: str, password: str, create_new: bool, sync_approval: Literal['yes', 'no', 'unknown'], premium_credentials: Optional[PremiumCredentials], initial_settings: Optional[ModifiableDBSettings] = None, ) -> None: """Unlocks an existing user or creates a new one if `create_new` is True May raise: - PremiumAuthenticationError if the password can't unlock the database. - AuthenticationError if premium_credentials are given and are invalid or can't authenticate with the server - DBUpgradeError if the rotki DB version is newer than the software or there is a DB upgrade and there is an error. - SystemPermissionError if the directory or DB file can not be accessed """ log.info( 'Unlocking user', user=user, create_new=create_new, sync_approval=sync_approval, initial_settings=initial_settings, ) # unlock or create the DB self.password = password self.user_directory = self.data.unlock(user, password, create_new, initial_settings) self.data_importer = DataImporter(db=self.data.db) self.last_data_upload_ts = self.data.db.get_last_data_upload_ts() self.premium_sync_manager = PremiumSyncManager(data=self.data, password=password) # set the DB in the external services instances that need it self.cryptocompare.set_database(self.data.db) # Anything that was set above here has to be cleaned in case of failure in the next step # by reset_after_failed_account_creation_or_login() try: self.premium = self.premium_sync_manager.try_premium_at_start( given_premium_credentials=premium_credentials, username=user, create_new=create_new, sync_approval=sync_approval, ) except PremiumAuthenticationError: # Reraise it only if this is during the creation of a new account where # the premium credentials were given by the user if create_new: raise self.msg_aggregator.add_warning( 'Could not authenticate the Rotki premium API keys found in the DB.' ' Has your subscription expired?', ) # else let's just continue. User signed in succesfully, but he just # has unauthenticable/invalid premium credentials remaining in his DB settings = self.get_settings() self.greenlet_manager.spawn_and_track( after_seconds=None, task_name='submit_usage_analytics', exception_is_error=False, method=maybe_submit_usage_analytics, should_submit=settings.submit_usage_analytics, ) self.etherscan = Etherscan(database=self.data.db, msg_aggregator=self.msg_aggregator) self.beaconchain = BeaconChain(database=self.data.db, msg_aggregator=self.msg_aggregator) eth_rpc_endpoint = settings.eth_rpc_endpoint # Initialize the price historian singleton PriceHistorian( data_directory=self.data_dir, cryptocompare=self.cryptocompare, coingecko=self.coingecko, ) PriceHistorian().set_oracles_order(settings.historical_price_oracles) self.accountant = Accountant( db=self.data.db, user_directory=self.user_directory, msg_aggregator=self.msg_aggregator, create_csv=True, ) # Initialize the rotkehlchen logger LoggingSettings(anonymized_logs=settings.anonymized_logs) exchange_credentials = self.data.db.get_exchange_credentials() self.exchange_manager.initialize_exchanges( exchange_credentials=exchange_credentials, database=self.data.db, ) # Initialize blockchain querying modules ethereum_manager = EthereumManager( ethrpc_endpoint=eth_rpc_endpoint, etherscan=self.etherscan, database=self.data.db, msg_aggregator=self.msg_aggregator, greenlet_manager=self.greenlet_manager, connect_at_start=ETHEREUM_NODES_TO_CONNECT_AT_START, ) kusama_manager = SubstrateManager( chain=SubstrateChain.KUSAMA, msg_aggregator=self.msg_aggregator, greenlet_manager=self.greenlet_manager, connect_at_start=KUSAMA_NODES_TO_CONNECT_AT_START, connect_on_startup=self._connect_ksm_manager_on_startup(), own_rpc_endpoint=settings.ksm_rpc_endpoint, ) Inquirer().inject_ethereum(ethereum_manager) Inquirer().set_oracles_order(settings.current_price_oracles) self.chain_manager = ChainManager( blockchain_accounts=self.data.db.get_blockchain_accounts(), ethereum_manager=ethereum_manager, kusama_manager=kusama_manager, msg_aggregator=self.msg_aggregator, database=self.data.db, greenlet_manager=self.greenlet_manager, premium=self.premium, eth_modules=settings.active_modules, data_directory=self.data_dir, beaconchain=self.beaconchain, btc_derivation_gap_limit=settings.btc_derivation_gap_limit, ) self.events_historian = EventsHistorian( user_directory=self.user_directory, db=self.data.db, msg_aggregator=self.msg_aggregator, exchange_manager=self.exchange_manager, chain_manager=self.chain_manager, ) self.task_manager = TaskManager( max_tasks_num=DEFAULT_MAX_TASKS_NUM, greenlet_manager=self.greenlet_manager, api_task_greenlets=self.api_task_greenlets, database=self.data.db, cryptocompare=self.cryptocompare, premium_sync_manager=self.premium_sync_manager, chain_manager=self.chain_manager, exchange_manager=self.exchange_manager, ) self.user_is_logged_in = True log.debug('User unlocking complete')
def unlock_user( self, user: str, password: str, create_new: bool, sync_approval: Literal['yes', 'no', 'unknown'], premium_credentials: Optional[PremiumCredentials], given_ethereum_modules: Optional[List[str]] = None, ) -> None: """Unlocks an existing user or creates a new one if `create_new` is True May raise: - PremiumAuthenticationError if the password can't unlock the database. - AuthenticationError if premium_credentials are given and are invalid or can't authenticate with the server - DBUpgradeError if the rotki DB version is newer than the software or there is a DB upgrade and there is an error. - SystemPermissionError if the directory or DB file can not be accessed """ log.info( 'Unlocking user', user=user, create_new=create_new, sync_approval=sync_approval, ) if given_ethereum_modules is None: ethereum_modules = ['makerdao'] # Default: ALL else: ethereum_modules = given_ethereum_modules # unlock or create the DB self.password = password self.user_directory = self.data.unlock(user, password, create_new) self.data_importer = DataImporter(db=self.data.db) self.last_data_upload_ts = self.data.db.get_last_data_upload_ts() self.premium_sync_manager = PremiumSyncManager(data=self.data, password=password) # set the DB in the external services instances that need it self.cryptocompare.set_database(self.data.db) # Anything that was set above here has to be cleaned in case of failure in the next step # by reset_after_failed_account_creation_or_login() try: self.premium = self.premium_sync_manager.try_premium_at_start( given_premium_credentials=premium_credentials, username=user, create_new=create_new, sync_approval=sync_approval, ) except PremiumAuthenticationError: # Reraise it only if this is during the creation of a new account where # the premium credentials were given by the user if create_new: raise # else let's just continue. User signed in succesfully, but he just # has unauthenticable/invalid premium credentials remaining in his DB settings = self.get_settings() maybe_submit_usage_analytics(settings.submit_usage_analytics) self.etherscan = Etherscan(database=self.data.db, msg_aggregator=self.msg_aggregator) alethio = Alethio( database=self.data.db, msg_aggregator=self.msg_aggregator, all_eth_tokens=self.all_eth_tokens, ) historical_data_start = settings.historical_data_start eth_rpc_endpoint = settings.eth_rpc_endpoint # Initialize the price historian singleton PriceHistorian( data_directory=self.data_dir, history_date_start=historical_data_start, cryptocompare=self.cryptocompare, ) self.accountant = Accountant( db=self.data.db, user_directory=self.user_directory, msg_aggregator=self.msg_aggregator, create_csv=True, ) # Initialize the rotkehlchen logger LoggingSettings(anonymized_logs=settings.anonymized_logs) exchange_credentials = self.data.db.get_exchange_credentials() self.exchange_manager.initialize_exchanges( exchange_credentials=exchange_credentials, database=self.data.db, ) # Initialize blockchain querying modules ethereum_manager = EthereumManager( ethrpc_endpoint=eth_rpc_endpoint, etherscan=self.etherscan, msg_aggregator=self.msg_aggregator, ) self.chain_manager = ChainManager( blockchain_accounts=self.data.db.get_blockchain_accounts(), owned_eth_tokens=self.data.db.get_owned_tokens(), ethereum_manager=ethereum_manager, msg_aggregator=self.msg_aggregator, alethio=alethio, greenlet_manager=self.greenlet_manager, eth_modules=ethereum_modules, ) self.ethereum_analyzer = EthereumAnalyzer( ethereum_manager=ethereum_manager, database=self.data.db, ) self.trades_historian = TradesHistorian( user_directory=self.user_directory, db=self.data.db, msg_aggregator=self.msg_aggregator, exchange_manager=self.exchange_manager, chain_manager=self.chain_manager, ) self.user_is_logged_in = True
def unlock_user( self, user: str, password: str, create_new: bool, sync_approval: Literal['yes', 'no', 'unknown'], premium_credentials: Optional[PremiumCredentials], initial_settings: Optional[ModifiableDBSettings] = None, ) -> None: """Unlocks an existing user or creates a new one if `create_new` is True May raise: - PremiumAuthenticationError if the password can't unlock the database. - AuthenticationError if premium_credentials are given and are invalid or can't authenticate with the server - DBUpgradeError if the rotki DB version is newer than the software or there is a DB upgrade and there is an error. - SystemPermissionError if the directory or DB file can not be accessed """ log.info( 'Unlocking user', user=user, create_new=create_new, sync_approval=sync_approval, initial_settings=initial_settings, ) # unlock or create the DB self.password = password self.user_directory = self.data.unlock(user, password, create_new, initial_settings) self.data_importer = DataImporter(db=self.data.db) self.last_data_upload_ts = self.data.db.get_last_data_upload_ts() self.premium_sync_manager = PremiumSyncManager(data=self.data, password=password) # set the DB in the external services instances that need it self.cryptocompare.set_database(self.data.db) # Anything that was set above here has to be cleaned in case of failure in the next step # by reset_after_failed_account_creation_or_login() try: self.premium = self.premium_sync_manager.try_premium_at_start( given_premium_credentials=premium_credentials, username=user, create_new=create_new, sync_approval=sync_approval, ) except PremiumAuthenticationError: # Reraise it only if this is during the creation of a new account where # the premium credentials were given by the user if create_new: raise self.msg_aggregator.add_error( 'Tried to synchronize the database from remote but the local password ' 'does not match the one the remote DB has. Please change the password ' 'to be the same as the password of the account you want to sync from ', ) # else let's just continue. User signed in succesfully, but he just # has unauthenticable/invalid premium credentials remaining in his DB settings = self.get_settings() self.greenlet_manager.spawn_and_track( after_seconds=None, task_name='submit_usage_analytics', method=maybe_submit_usage_analytics, should_submit=settings.submit_usage_analytics, ) self.etherscan = Etherscan(database=self.data.db, msg_aggregator=self.msg_aggregator) self.beaconchain = BeaconChain(database=self.data.db, msg_aggregator=self.msg_aggregator) historical_data_start = settings.historical_data_start eth_rpc_endpoint = settings.eth_rpc_endpoint # Initialize the price historian singleton PriceHistorian( data_directory=self.data_dir, history_date_start=historical_data_start, cryptocompare=self.cryptocompare, ) self.accountant = Accountant( db=self.data.db, user_directory=self.user_directory, msg_aggregator=self.msg_aggregator, create_csv=True, ) # Initialize the rotkehlchen logger LoggingSettings(anonymized_logs=settings.anonymized_logs) exchange_credentials = self.data.db.get_exchange_credentials() self.exchange_manager.initialize_exchanges( exchange_credentials=exchange_credentials, database=self.data.db, ) # Initialize blockchain querying modules ethereum_manager = EthereumManager( ethrpc_endpoint=eth_rpc_endpoint, etherscan=self.etherscan, database=self.data.db, msg_aggregator=self.msg_aggregator, greenlet_manager=self.greenlet_manager, connect_at_start=ETHEREUM_NODES_TO_CONNECT_AT_START, ) Inquirer().inject_ethereum(ethereum_manager) self.chain_manager = ChainManager( blockchain_accounts=self.data.db.get_blockchain_accounts(), ethereum_manager=ethereum_manager, msg_aggregator=self.msg_aggregator, database=self.data.db, greenlet_manager=self.greenlet_manager, premium=self.premium, eth_modules=settings.active_modules, data_directory=self.data_dir, beaconchain=self.beaconchain, ) self.trades_historian = TradesHistorian( user_directory=self.user_directory, db=self.data.db, msg_aggregator=self.msg_aggregator, exchange_manager=self.exchange_manager, chain_manager=self.chain_manager, ) self.user_is_logged_in = True log.debug('User unlocking complete')
def __init__(self, data_directory='.'): # pylint: disable=super-init-not-called self.data_directory = Path(data_directory) with open(self.data_directory / 'buchfink.yaml', 'r') as cfg: yaml_config = yaml.load(cfg, Loader=yaml.SafeLoader) self.config = config_schema(yaml_config) self.accounts = accounts_from_config(self.config) # type: List[Account] self._active_eth_address = None # type: Optional[ChecksumEthAddress] self.reports_directory = self.data_directory / "reports" self.trades_directory = self.data_directory / "trades" self.cache_directory = self.data_directory / "cache" self.balances_directory = self.data_directory / "balances" self.annotations_directory = self.data_directory / "annotations" self.user_data_dir = self.data_directory / "user" self.reports_directory.mkdir(exist_ok=True) self.trades_directory.mkdir(exist_ok=True) self.balances_directory.mkdir(exist_ok=True) self.cache_directory.mkdir(exist_ok=True) (self.cache_directory / 'cryptocompare').mkdir(exist_ok=True) (self.cache_directory / 'history').mkdir(exist_ok=True) (self.cache_directory / 'inquirer').mkdir(exist_ok=True) (self.cache_directory / 'coingecko').mkdir(exist_ok=True) self.last_write_ts: Optional[Timestamp] = None self._amm_swaps = [] # type: List[AMMSwap] self._eth_tx = [] # type: List[EthereumTransaction] self._eth_receipts_store = pickledb.load(self.cache_directory / 'receipts.db', False) self.cryptocompare = Cryptocompare(self.cache_directory / 'cryptocompare', self) self.coingecko = Coingecko() self.historian = PriceHistorian( self.cache_directory / 'history', self.cryptocompare, self.coingecko ) self.inquirer = Inquirer(self.cache_directory / 'inquirer', self.cryptocompare, self.coingecko ) self.msg_aggregator = MessagesAggregator() self.greenlet_manager = GreenletManager(msg_aggregator=self.msg_aggregator) # Initialize blockchain querying modules self.etherscan = Etherscan(database=self, msg_aggregator=self.msg_aggregator) GlobalDBHandler._GlobalDBHandler__instance = None self.globaldb = GlobalDBHandler(self.cache_directory) self.asset_resolver = AssetResolver() self.assets_updater = AssetsUpdater(self.msg_aggregator) self.ethereum_manager = EthereumManager( database=self, ethrpc_endpoint=self.get_eth_rpc_endpoint(), etherscan=self.etherscan, msg_aggregator=self.msg_aggregator, greenlet_manager=self.greenlet_manager, connect_at_start=[] ) self.inquirer.inject_ethereum(self.ethereum_manager) self.inquirer.set_oracles_order(self.get_settings().current_price_oracles) self.historian.set_oracles_order(self.get_settings().historical_price_oracles) self.beaconchain = BeaconChain(database=self, msg_aggregator=self.msg_aggregator)
def unlock_user( self, user: str, password: str, create_new: bool, sync_approval: Literal['yes', 'no', 'unknown'], premium_credentials: Optional[PremiumCredentials], initial_settings: Optional[ModifiableDBSettings] = None, sync_database: bool = True, ) -> None: """Unlocks an existing user or creates a new one if `create_new` is True May raise: - PremiumAuthenticationError if the password can't unlock the database. - AuthenticationError if premium_credentials are given and are invalid or can't authenticate with the server - DBUpgradeError if the rotki DB version is newer than the software or there is a DB upgrade and there is an error. - SystemPermissionError if the directory or DB file can not be accessed """ log.info( 'Unlocking user', user=user, create_new=create_new, sync_approval=sync_approval, sync_database=sync_database, initial_settings=initial_settings, ) # unlock or create the DB self.password = password self.user_directory = self.data.unlock(user, password, create_new, initial_settings) # Run the DB integrity check due to https://github.com/rotki/rotki/issues/3010 # TODO: Hopefully onece 3010 is handled this can go away self.greenlet_manager.spawn_and_track( after_seconds=None, task_name='user DB data integrity check', exception_is_error=False, method=self.data.db.ensure_data_integrity, ) self.data_importer = DataImporter(db=self.data.db) self.last_data_upload_ts = self.data.db.get_last_data_upload_ts() self.premium_sync_manager = PremiumSyncManager(data=self.data, password=password) # set the DB in the external services instances that need it self.cryptocompare.set_database(self.data.db) # Anything that was set above here has to be cleaned in case of failure in the next step # by reset_after_failed_account_creation_or_login() try: self.premium = self.premium_sync_manager.try_premium_at_start( given_premium_credentials=premium_credentials, username=user, create_new=create_new, sync_approval=sync_approval, sync_database=sync_database, ) except PremiumAuthenticationError: # Reraise it only if this is during the creation of a new account where # the premium credentials were given by the user if create_new: raise self.msg_aggregator.add_warning( 'Could not authenticate the rotki premium API keys found in the DB.' ' Has your subscription expired?', ) # else let's just continue. User signed in succesfully, but he just # has unauthenticable/invalid premium credentials remaining in his DB settings = self.get_settings() self.greenlet_manager.spawn_and_track( after_seconds=None, task_name='submit_usage_analytics', exception_is_error=False, method=maybe_submit_usage_analytics, data_dir=self.data_dir, should_submit=settings.submit_usage_analytics, ) self.etherscan = Etherscan(database=self.data.db, msg_aggregator=self.msg_aggregator) self.beaconchain = BeaconChain(database=self.data.db, msg_aggregator=self.msg_aggregator) eth_rpc_endpoint = settings.eth_rpc_endpoint # Initialize the price historian singleton PriceHistorian( data_directory=self.data_dir, cryptocompare=self.cryptocompare, coingecko=self.coingecko, ) PriceHistorian().set_oracles_order(settings.historical_price_oracles) exchange_credentials = self.data.db.get_exchange_credentials() self.exchange_manager.initialize_exchanges( exchange_credentials=exchange_credentials, database=self.data.db, ) # Initialize blockchain querying modules ethereum_manager = EthereumManager( ethrpc_endpoint=eth_rpc_endpoint, etherscan=self.etherscan, msg_aggregator=self.msg_aggregator, greenlet_manager=self.greenlet_manager, connect_at_start=ETHEREUM_NODES_TO_CONNECT_AT_START, ) kusama_manager = SubstrateManager( chain=SubstrateChain.KUSAMA, msg_aggregator=self.msg_aggregator, greenlet_manager=self.greenlet_manager, connect_at_start=KUSAMA_NODES_TO_CONNECT_AT_START, connect_on_startup=self._connect_ksm_manager_on_startup(), own_rpc_endpoint=settings.ksm_rpc_endpoint, ) polkadot_manager = SubstrateManager( chain=SubstrateChain.POLKADOT, msg_aggregator=self.msg_aggregator, greenlet_manager=self.greenlet_manager, connect_at_start=POLKADOT_NODES_TO_CONNECT_AT_START, connect_on_startup=self._connect_dot_manager_on_startup(), own_rpc_endpoint=settings.dot_rpc_endpoint, ) self.eth_transactions = EthTransactions(ethereum=ethereum_manager, database=self.data.db) self.covalent_avalanche = Covalent( database=self.data.db, msg_aggregator=self.msg_aggregator, chain_id=chains_id['avalanche'], ) avalanche_manager = AvalancheManager( avaxrpc_endpoint="https://api.avax.network/ext/bc/C/rpc", covalent=self.covalent_avalanche, msg_aggregator=self.msg_aggregator, ) Inquirer().inject_ethereum(ethereum_manager) uniswap_v2_oracle = UniswapV2Oracle(ethereum_manager) uniswap_v3_oracle = UniswapV3Oracle(ethereum_manager) saddle_oracle = SaddleOracle(ethereum_manager) Inquirer().add_defi_oracles( uniswap_v2=uniswap_v2_oracle, uniswap_v3=uniswap_v3_oracle, saddle=saddle_oracle, ) Inquirer().set_oracles_order(settings.current_price_oracles) self.chain_manager = ChainManager( blockchain_accounts=self.data.db.get_blockchain_accounts(), ethereum_manager=ethereum_manager, kusama_manager=kusama_manager, polkadot_manager=polkadot_manager, avalanche_manager=avalanche_manager, msg_aggregator=self.msg_aggregator, database=self.data.db, greenlet_manager=self.greenlet_manager, premium=self.premium, eth_modules=settings.active_modules, data_directory=self.data_dir, beaconchain=self.beaconchain, btc_derivation_gap_limit=settings.btc_derivation_gap_limit, ) self.evm_tx_decoder = EVMTransactionDecoder( database=self.data.db, ethereum_manager=ethereum_manager, eth_transactions=self.eth_transactions, msg_aggregator=self.msg_aggregator, ) self.evm_accounting_aggregator = EVMAccountingAggregator( ethereum_manager=ethereum_manager, msg_aggregator=self.msg_aggregator, ) self.accountant = Accountant( db=self.data.db, msg_aggregator=self.msg_aggregator, evm_accounting_aggregator=self.evm_accounting_aggregator, premium=self.premium, ) self.events_historian = EventsHistorian( user_directory=self.user_directory, db=self.data.db, msg_aggregator=self.msg_aggregator, exchange_manager=self.exchange_manager, chain_manager=self.chain_manager, evm_tx_decoder=self.evm_tx_decoder, eth_transactions=self.eth_transactions, ) self.task_manager = TaskManager( max_tasks_num=DEFAULT_MAX_TASKS_NUM, greenlet_manager=self.greenlet_manager, api_task_greenlets=self.api_task_greenlets, database=self.data.db, cryptocompare=self.cryptocompare, premium_sync_manager=self.premium_sync_manager, chain_manager=self.chain_manager, exchange_manager=self.exchange_manager, eth_transactions=self.eth_transactions, evm_tx_decoder=self.evm_tx_decoder, deactivate_premium=self.deactivate_premium_status, query_balances=self.query_balances, ) DataMigrationManager(self).maybe_migrate_data() self.greenlet_manager.spawn_and_track( after_seconds=5, task_name='periodically_query_icons_until_all_cached', exception_is_error=False, method=self.icon_manager.periodically_query_icons_until_all_cached, batch_size=ICONS_BATCH_SIZE, sleep_time_secs=ICONS_QUERY_SLEEP, ) self.user_is_logged_in = True log.debug('User unlocking complete')