def blockchain( blockchain_backend, # pylint: disable=unused-argument ethereum_manager, blockchain_accounts, inquirer, # pylint: disable=unused-argument messages_aggregator, greenlet_manager, ethereum_modules, start_with_valid_premium, rotki_premium_credentials, database, data_dir, beaconchain, ): premium = None if start_with_valid_premium: premium = Premium(rotki_premium_credentials) chain_manager = ChainManager( blockchain_accounts=blockchain_accounts, ethereum_manager=ethereum_manager, msg_aggregator=messages_aggregator, database=database, greenlet_manager=greenlet_manager, premium=premium, eth_modules=ethereum_modules, data_directory=data_dir, beaconchain=beaconchain, ) return chain_manager
def blockchain( blockchain_backend, # pylint: disable=unused-argument ethereum_manager, blockchain_accounts, inquirer, # pylint: disable=unused-argument messages_aggregator, greenlet_manager, ethereum_modules, start_with_valid_premium, rotki_premium_credentials, database, ): premium = None if start_with_valid_premium: premium = Premium(rotki_premium_credentials) with create_zerion_patch(): chain_manager = ChainManager( blockchain_accounts=blockchain_accounts, ethereum_manager=ethereum_manager, msg_aggregator=messages_aggregator, database=database, greenlet_manager=greenlet_manager, premium=premium, eth_modules=ethereum_modules, ) wait_until_zerion_is_initialized(chain_manager) return chain_manager
def blockchain( blockchain_backend, # pylint: disable=unused-argument ethereum_manager, blockchain_accounts, inquirer, # pylint: disable=unused-argument messages_aggregator, greenlet_manager, owned_eth_tokens, ethereum_modules, alethio, start_with_valid_premium, rotki_premium_credentials, ): premium = None if start_with_valid_premium: premium = Premium(rotki_premium_credentials) return ChainManager( blockchain_accounts=blockchain_accounts, owned_eth_tokens=owned_eth_tokens, ethereum_manager=ethereum_manager, msg_aggregator=messages_aggregator, alethio=alethio, greenlet_manager=greenlet_manager, premium=premium, eth_modules=ethereum_modules, )
def blockchain( blockchain_backend, # pylint: disable=unused-argument ethchain_client, blockchain_accounts, inquirer, # pylint: disable=unused-argument messages_aggregator, greenlet_manager, owned_eth_tokens, ethereum_modules, database, ): modules = {} for given_module in ethereum_modules: if given_module == 'makerdao': modules['makerdao'] = MakerDAO( ethchain=ethchain_client, database=database, msg_aggregator=messages_aggregator, ) else: raise AssertionError( f'Unrecognized ethereum module {given_module} in test setup') return ChainManager( blockchain_accounts=blockchain_accounts, owned_eth_tokens=owned_eth_tokens, ethchain=ethchain_client, msg_aggregator=messages_aggregator, greenlet_manager=greenlet_manager, eth_modules=modules, )
def get_chain_manager(self, account: Account) -> ChainManager: if account.account_type == "ethereum": accounts = BlockchainAccounts(eth=[account.address], btc=[], ksm=[]) elif account.account_type == "bitcoin": accounts = BlockchainAccounts(eth=[], btc=[account.address], ksm=[]) else: raise ValueError('Unable to create chain manager for account') # Eventually we should allow premium credentials in config file premium = False eth_modules = self.get_settings().active_modules if not premium: eth_modules = [mod for mod in eth_modules if mod not in PREMIUM_ONLY_ETH_MODULES] logger.debug('Creating ChainManager with modules: %s', eth_modules) manager = ChainManager( database=self, blockchain_accounts=accounts, beaconchain=self.beaconchain, data_directory=self.data_directory, ethereum_manager=self.ethereum_manager, kusama_manager=None, msg_aggregator=self.msg_aggregator, btc_derivation_gap_limit=self.get_settings().btc_derivation_gap_limit, greenlet_manager=self.greenlet_manager, premium=premium, eth_modules=eth_modules ) # Monkey-patch function that uses singleton manager.queried_addresses_for_module = lambda self, module = None: [account] return manager
def get_chain_manager(self, account: Any) -> ChainManager: if 'ethereum' in account: accounts = BlockchainAccounts(eth=[account['ethereum']], btc=[]) elif 'bitcoin' in account: accounts = BlockchainAccounts(eth=[], btc=[account['bitcoin']]) else: raise ValueError('Invalid account') return ChainManager( blockchain_accounts=accounts, owned_eth_tokens=[], ethereum_manager=self.ethereum_manager, msg_aggregator=self.msg_aggregator, alethio=self.alethio, greenlet_manager=self.greenlet_manager, premium=False, eth_modules=[], )
def blockchain( ethereum_manager, kusama_manager, polkadot_manager, avalanche_manager, blockchain_accounts, inquirer, # pylint: disable=unused-argument messages_aggregator, greenlet_manager, ethereum_modules, start_with_valid_premium, rotki_premium_credentials, database, data_dir, beaconchain, btc_derivation_gap_limit, ): premium = None if start_with_valid_premium: premium = Premium(rotki_premium_credentials) chain_manager = ChainManager( blockchain_accounts=blockchain_accounts, ethereum_manager=ethereum_manager, kusama_manager=kusama_manager, polkadot_manager=polkadot_manager, avalanche_manager=avalanche_manager, msg_aggregator=messages_aggregator, database=database, greenlet_manager=greenlet_manager, premium=premium, eth_modules=ethereum_modules, data_directory=data_dir, beaconchain=beaconchain, btc_derivation_gap_limit=btc_derivation_gap_limit, ) return chain_manager
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: str, premium_credentials: Optional[PremiumCredentials], ) -> 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. """ log.info( 'Unlocking user', user=user, create_new=create_new, sync_approval=sync_approval, ) # 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 ethchain = Ethchain( ethrpc_endpoint=eth_rpc_endpoint, etherscan=self.etherscan, msg_aggregator=self.msg_aggregator, ) makerdao = MakerDAO( ethchain=ethchain, database=self.data.db, 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(), ethchain=ethchain, msg_aggregator=self.msg_aggregator, alethio=alethio, greenlet_manager=self.greenlet_manager, eth_modules={'makerdao': makerdao}, ) self.ethereum_analyzer = EthereumAnalyzer( ethchain=ethchain, 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 # 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( 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) 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, greenlet_manager=self.greenlet_manager, connect_at_start=ETHEREUM_NODES_TO_CONNECT_AT_START, ) 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, ) 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 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], 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')