def test_price_underlying_tokens(inquirer, globaldb):
aave_weight, link_weight, crv_weight = FVal('0.6'), FVal('0.2'), FVal(
'0.2')
address = make_ethereum_address()
token = CustomEthereumToken(
address=address,
decimals=18,
name='Test',
symbol='YAB',
underlying_tokens=[
UnderlyingToken(address=A_AAVE.ethereum_address,
weight=aave_weight),
UnderlyingToken(address=A_LINK.ethereum_address,
weight=link_weight),
UnderlyingToken(address=A_CRV.ethereum_address, weight=crv_weight),
],
)
globaldb.add_asset(
asset_id=ethaddress_to_identifier(address),
asset_type=AssetType.ETHEREUM_TOKEN,
data=token,
)
price = inquirer.find_price(EthereumToken(address), A_USD)
assert price == FVal(67)
def _fetch_underlying_tokens(
address: ChecksumEthAddress,
) -> Optional[List[UnderlyingToken]]:
"""Fetch underlying tokens for a token address if they exist"""
cursor = GlobalDBHandler()._conn.cursor()
query = cursor.execute(
'SELECT address, weight from underlying_tokens_list WHERE parent_token_entry=?;',
(address,),
)
results = query.fetchall()
underlying_tokens = None
if len(results) != 0:
underlying_tokens = [UnderlyingToken.deserialize_from_db(x) for x in results]
return underlying_tokens
def test_adding_custom_tokens(rotkehlchen_api_server):
"""Test that the endpoint for adding a custom ethereum token works"""
response = requests.put(
api_url_for(
rotkehlchen_api_server,
'ethereumassetsresource',
),
json={'token': CUSTOM_TOKEN3.serialize()},
)
result = assert_proper_response_with_result(response)
assert result == {'identifier': ETHEREUM_DIRECTIVE + CUSTOM_TOKEN3.address}
response = requests.get(
api_url_for(
rotkehlchen_api_server,
'ethereumassetsresource',
), )
result = assert_proper_response_with_result(response)
expected_tokens = INITIAL_EXPECTED_TOKENS.copy() + [
CUSTOM_TOKEN3,
CustomEthereumToken(address=underlying_address4),
]
expected_result = [x.serialize() for x in expected_tokens]
assert_token_entry_exists_in_result(result, expected_result)
# test that adding an already existing address is handled properly
response = requests.put(
api_url_for(
rotkehlchen_api_server,
'ethereumassetsresource',
),
json={'token': INITIAL_TOKENS[1].serialize()},
)
expected_msg = (
f'Ethereum token with address {INITIAL_TOKENS[1].address} already '
f'exists in the DB', )
assert_error_response(
response=response,
contained_in_msg=expected_msg,
status_code=HTTPStatus.CONFLICT,
)
# also test that the addition of underlying tokens has created proper asset entires for them
cursor = GlobalDBHandler()._conn.cursor()
result = cursor.execute(
'SELECT COUNT(*) from assets WHERE identifier IN (?, ?, ?, ?)',
[
ETHEREUM_DIRECTIVE + x for x in [
underlying_address1, underlying_address2, underlying_address3,
underlying_address4
]
], # noqa: E501
).fetchone()[0]
assert result == 4
result = cursor.execute(
'SELECT COUNT(*) from ethereum_tokens WHERE address IN (?, ?, ?, ?)',
(underlying_address1, underlying_address2, underlying_address3,
underlying_address4), # noqa: E501
).fetchone()[0]
assert result == 4
# now test that adding a token with underlying tokens adding up to more than 100% is caught
bad_token = CustomEthereumToken(
address=make_ethereum_address(),
decimals=18,
name='foo',
symbol='BBB',
underlying_tokens=[
UnderlyingToken(address=make_ethereum_address(),
weight=FVal('0.5055')),
UnderlyingToken(address=make_ethereum_address(),
weight=FVal('0.7055')),
],
)
response = requests.put(
api_url_for(
rotkehlchen_api_server,
'ethereumassetsresource',
),
json={'token': bad_token.serialize()},
)
expected_msg = (
f'The sum of underlying token weights for {bad_token.address} is '
f'121.1000 and exceeds 100%')
assert_error_response(
response=response,
contained_in_msg=expected_msg,
status_code=HTTPStatus.BAD_REQUEST,
)
# and test that adding a token with underlying tokens adding up to less than 100% is caught
bad_token = CustomEthereumToken(
address=make_ethereum_address(),
decimals=18,
name='foo',
symbol='BBB',
underlying_tokens=[
UnderlyingToken(address=make_ethereum_address(),
weight=FVal('0.1055')),
UnderlyingToken(address=make_ethereum_address(),
weight=FVal('0.2055')),
],
)
response = requests.put(
api_url_for(
rotkehlchen_api_server,
'ethereumassetsresource',
),
json={'token': bad_token.serialize()},
)
expected_msg = (
f'The sum of underlying token weights for {bad_token.address} is '
f'31.1000 and does not add up to 100%')
assert_error_response(
response=response,
contained_in_msg=expected_msg,
status_code=HTTPStatus.BAD_REQUEST,
)
# and test that adding a token with empty list of underlying tokens and not null is an error
bad_token = CustomEthereumToken(
address=make_ethereum_address(),
decimals=18,
name='foo',
symbol='BBB',
underlying_tokens=[],
)
serialized_bad_token = bad_token.serialize()
serialized_bad_token['underlying_tokens'] = []
response = requests.put(
api_url_for(
rotkehlchen_api_server,
'ethereumassetsresource',
),
json={'token': serialized_bad_token},
)
expected_msg = (
f'Gave an empty list for underlying tokens of {bad_token.address}')
assert_error_response(
response=response,
contained_in_msg=expected_msg,
status_code=HTTPStatus.BAD_REQUEST,
)
custom_address1 = make_ethereum_address()
custom_address2 = make_ethereum_address()
INITIAL_TOKENS = [
CustomEthereumToken(
address=custom_address1,
decimals=4,
name='Custom 1',
symbol='CST1',
started=Timestamp(0),
swapped_for=A_MKR,
coingecko='foo',
cryptocompare='boo',
protocol='uniswap',
underlying_tokens=[
UnderlyingToken(address=underlying_address1,
weight=FVal('0.5055')),
UnderlyingToken(address=underlying_address2,
weight=FVal('0.1545')),
UnderlyingToken(address=underlying_address3, weight=FVal('0.34')),
],
),
CustomEthereumToken(
address=custom_address2,
decimals=18,
name='Custom 2',
symbol='CST2',
),
]
INITIAL_EXPECTED_TOKENS = [INITIAL_TOKENS[0]] + [
CustomEthereumToken(underlying_address1),