def unlock_user(
self,
user: str,
password: str,
create_new: bool,
sync_approval: bool,
api_key: ApiKey,
api_secret: ApiSecret,
) -> None:
"""Unlocks an existing user or creates a new one if `create_new` is True"""
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.last_data_upload_ts = self.data.db.get_last_data_upload_ts()
self.premium_sync_manager = PremiumSyncManager(data=self.data,
password=password)
try:
self.premium = self.premium_sync_manager.try_premium_at_start(
api_key=api_key,
api_secret=api_secret,
username=user,
create_new=create_new,
sync_approval=sync_approval,
)
except AuthenticationError:
# It means that our credentials were not accepted by the server
# or some other error happened
pass
exchange_credentials = self.data.db.get_exchange_credentials()
settings = self.data.db.get_settings()
historical_data_start = settings['historical_data_start']
eth_rpc_endpoint = settings['eth_rpc_endpoint']
self.trades_historian = TradesHistorian(
user_directory=self.user_directory,
db=self.data.db,
eth_accounts=self.data.get_eth_accounts(),
msg_aggregator=self.msg_aggregator,
)
# Initialize the price historian singleton
PriceHistorian(
data_directory=self.data_dir,
history_date_start=historical_data_start,
cryptocompare=Cryptocompare(data_directory=self.data_dir),
)
db_settings = self.data.db.get_settings()
self.accountant = Accountant(
profit_currency=self.data.main_currency(),
user_directory=self.user_directory,
msg_aggregator=self.msg_aggregator,
create_csv=True,
ignored_assets=self.data.db.get_ignored_assets(),
include_crypto2crypto=db_settings['include_crypto2crypto'],
taxfree_after_period=db_settings['taxfree_after_period'],
include_gas_costs=db_settings['include_gas_costs'],
)
# Initialize the rotkehlchen logger
LoggingSettings(anonymized_logs=db_settings['anonymized_logs'])
self.initialize_exchanges(exchange_credentials)
ethchain = Ethchain(eth_rpc_endpoint)
self.blockchain = Blockchain(
blockchain_accounts=self.data.db.get_blockchain_accounts(),
owned_eth_tokens=self.data.db.get_owned_tokens(),
ethchain=ethchain,
msg_aggregator=self.msg_aggregator,
)
self.user_is_logged_in = True
def main():
arg_parser = aggregator_args()
args = arg_parser.parse_args()
our_data = AssetResolver().assets
paprika = CoinPaprika()
cmc = None
cmc_list = None
root_path = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
data_directory = f'{Path.home()}/.rotkehlchen'
if args.cmc_api_key:
cmc = Coinmarketcap(
data_directory=data_directory,
api_key=args.cmc_api_key,
)
cmc_list = cmc.get_cryptocyrrency_map()
cryptocompare = Cryptocompare(data_directory=data_directory)
paprika_coins_list = paprika.get_coins_list()
cryptocompare_coins_map = cryptocompare.all_coins()
with open(
os.path.join(root_path, 'rotkehlchen', 'data', 'eth_tokens.json'),
'r') as f:
token_data = rlk_jsonloads(f.read())
if args.input_file:
if not os.path.isfile(args.input_file):
print(f'Given input file {args.input_file} is not a file')
sys.exit(1)
with open(args.input_file, 'r') as f:
input_data = rlk_jsonloads(f.read())
given_symbols = set(input_data.keys())
current_symbols = set(our_data.keys())
if not given_symbols.isdisjoint(current_symbols):
print(
f'The following given input symbols already exist in the '
f'all_assets.json file {given_symbols.intersection(current_symbols)}',
)
sys.exit(1)
# If an input file is given, iterate only its assets and perform checks
for asset_symbol in input_data.keys():
input_data = process_asset(
our_data=input_data,
asset_symbol=asset_symbol,
paprika_coins_list=paprika_coins_list,
paprika=paprika,
cmc_list=cmc_list,
cryptocompare_coins_map=cryptocompare_coins_map,
always_keep_our_time=args.always_keep_our_time,
)
# and now combine the two dictionaries to get the final one. Note that no
# checks are perfomed for what was in all_assets.json before the script
# ran in this case
our_data = {**our_data, **input_data}
elif args.process_eth_tokens:
start = 1240
stop_after = start + 6
input_data = {}
for index, entry in enumerate(token_data[start:], start):
token_symbol = entry['symbol']
# at least for now skip all already known tokens
if ETH_TOKENS_JSON_TO_WORLD.get(token_symbol,
token_symbol) in our_data:
print(
f"Skipping ETH token {token_symbol} since it's already known"
)
else:
input_data = process_asset(
our_data=input_data,
asset_symbol=token_symbol,
paprika_coins_list=paprika_coins_list,
paprika=paprika,
cmc_list=cmc_list,
cryptocompare_coins_map=cryptocompare_coins_map,
always_keep_our_time=args.always_keep_our_time,
token_entry=entry,
)
if index >= stop_after:
break
# and now combine the two dictionaries to get the final one. Note that no
# checks are perfomed for what was in all_assets.json before the script
# ran in this case
our_data = {**our_data, **input_data}
else:
# Iterate all of the assets of the all_assets.json file and perform checks
for asset_symbol in our_data.keys():
our_data = process_asset(
our_data=our_data,
asset_symbol=asset_symbol,
paprika_coins_list=paprika_coins_list,
paprika=paprika,
cmc_list=cmc_list,
cryptocompare_coins_map=cryptocompare_coins_map,
always_keep_our_time=args.always_keep_our_time,
)
# Make sure that our data have the ethereum address and decimals from eth_tokens.json
asset_type = our_data[asset_symbol]['type']
if 'ethereum token' not in asset_type:
continue
eth_token_symbol = WORLD_TO_ETH_TOKENS_JSON.get(
asset_symbol, asset_symbol)
data = find_token_data(token_data, eth_token_symbol)
if not data:
print(f'Missing token data for {asset_symbol} ... sadness :(')
sys.exit(1)
our_data[asset_symbol]['ethereum_address'] = data['address']
our_data[asset_symbol]['ethereum_token_decimals'] = data['decimal']
# Finally overwrite the all_assets.json with the modified assets
with open(
os.path.join(root_path, 'rotkehlchen', 'data', 'all_assets.json'),
'w') as f:
f.write(json.dumps(
our_data,
sort_keys=True,
indent=4,
), )