def test_token_by_chain_address(self):
token = tokens.token_by_chain_address(
1,
b'\x7d\xd7\xf5\x6d\x69\x7c\xc0\xf2\xb5\x2b\xd5\x5c\x05\x7f\x37\x8f\x1f\xe6\xab\x4b'
)
self.assertEqual(token['symbol'], '$TEAK')
token = tokens.token_by_chain_address(
1,
b'\x59\x41\x6a\x25\x62\x8a\x76\xb4\x73\x0e\xc5\x14\x86\x11\x4c\x32\xe0\xb5\x82\xa1'
)
self.assertEqual(token['symbol'], 'PLASMA')
self.assertEqual(token['decimal'], 6)
token = tokens.token_by_chain_address(
3,
b'\x95\xd7\x32\x1e\xdc\xe5\x19\x41\x9b\xa1\xdb\xc6\x0a\x89\xba\xfb\xf5\x5e\xac\x0d'
)
self.assertEqual(token['symbol'], 'PLASMA')
self.assertEqual(token['decimal'], 6)
token = tokens.token_by_chain_address(
8,
b'\x4b\x48\x99\xa1\x0f\x3e\x50\x7d\xb2\x07\xb0\xee\x24\x26\x02\x9e\xfa\x16\x8a\x67'
)
self.assertEqual(token['symbol'], 'QWARK')
# invalid adress, invalid chain
token = tokens.token_by_chain_address(999, b'\x00\xFF')
self.assertEqual(token, None)
def test_token_by_chain_address(self):
token = tokens.token_by_chain_address(
1,
b'\x7d\xd7\xf5\x6d\x69\x7c\xc0\xf2\xb5\x2b\xd5\x5c\x05\x7f\x37\x8f\x1f\xe6\xab\x4b'
)
self.assertEqual(token[2], '$TEAK')
token = tokens.token_by_chain_address(
1,
b'\x59\x41\x6a\x25\x62\x8a\x76\xb4\x73\x0e\xc5\x14\x86\x11\x4c\x32\xe0\xb5\x82\xa1'
)
self.assertEqual(token[2], 'PLASMA')
self.assertEqual(token[3], 6)
token = tokens.token_by_chain_address(
4,
b'\x0a\x05\x7a\x87\xce\x9c\x56\xd7\xe3\x36\xb4\x17\xc7\x9c\xf3\x0e\x8d\x27\x86\x0b'
)
self.assertEqual(token[2], 'WALL')
self.assertEqual(token[3], 15)
token = tokens.token_by_chain_address(
8,
b'\x4b\x48\x99\xa1\x0f\x3e\x50\x7d\xb2\x07\xb0\xee\x24\x26\x02\x9e\xfa\x16\x8a\x67'
)
self.assertEqual(token[2], 'QWARK')
# invalid adress, invalid chain
token = tokens.token_by_chain_address(999, b'\x00\xFF')
self.assertIs(token, tokens.UNKNOWN_TOKEN)
async def ethereum_sign_tx(ctx, msg):
from trezor.crypto.hashlib import sha3_256
msg = sanitize(msg)
check(msg)
data_total = msg.data_length
# detect ERC - 20 token
token = None
recipient = msg.to
value = int.from_bytes(msg.value, 'big')
if len(msg.to) == 20 and \
len(msg.value) == 0 and \
data_total == 68 and \
len(msg.data_initial_chunk) == 68 and \
msg.data_initial_chunk[:16] == b'\xa9\x05\x9c\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00':
token = tokens.token_by_chain_address(msg.chain_id, msg.to)
recipient = msg.data_initial_chunk[16:36]
value = int.from_bytes(msg.data_initial_chunk[36:68], 'big')
await require_confirm_tx(ctx, recipient, value, msg.chain_id, token)
if token is None and msg.data_length > 0:
await require_confirm_data(ctx, msg.data_initial_chunk, data_total)
await require_confirm_fee(ctx, value, int.from_bytes(msg.gas_price, 'big'),
int.from_bytes(msg.gas_limit, 'big'),
msg.chain_id, token)
data = bytearray()
data += msg.data_initial_chunk
data_left = data_total - len(msg.data_initial_chunk)
total_length = get_total_length(msg, data_total)
sha = HashWriter(sha3_256)
sha.extend(rlp.encode_length(total_length, True)) # total length
for field in [msg.nonce, msg.gas_price, msg.gas_limit, msg.to, msg.value]:
sha.extend(rlp.encode(field))
if data_left == 0:
sha.extend(rlp.encode(data))
else:
sha.extend(rlp.encode_length(data_total, False))
sha.extend(rlp.encode(data, False))
while data_left > 0:
resp = await send_request_chunk(ctx, data_left)
data_left -= len(resp.data_chunk)
sha.extend(resp.data_chunk)
# eip 155 replay protection
if msg.chain_id:
sha.extend(rlp.encode(msg.chain_id))
sha.extend(rlp.encode(0))
sha.extend(rlp.encode(0))
digest = sha.get_digest(True) # True -> use keccak mode
return await send_signature(ctx, msg, digest)
def test_unknown_token(self):
unknown_token = token_by_chain_address(1, b"hello")
text = format_ethereum_amount(1, unknown_token, 1)
self.assertEqual(text, '1 Wei UNKN')
text = format_ethereum_amount(0, unknown_token, 1)
self.assertEqual(text, '0 Wei UNKN')
# unknown token has 0 decimals so is always wei
text = format_ethereum_amount(1000000000000000000, unknown_token, 1)
self.assertEqual(text, '1000000000000000000 Wei UNKN')
def test_tokens(self):
# tokens with low decimal values
# USDC has 6 decimals
usdc_token = token_by_chain_address(
1, unhexlify("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"))
# ICO has 10 decimals
ico_token = token_by_chain_address(
1, unhexlify("a33e729bf4fdeb868b534e1f20523463d9c46bee"))
# when decimals < 10, should never display 'Wei' format
text = format_ethereum_amount(1, usdc_token, 1)
self.assertEqual(text, '0.000001 USDC')
text = format_ethereum_amount(0, usdc_token, 1)
self.assertEqual(text, '0 USDC')
text = format_ethereum_amount(1, ico_token, 1)
self.assertEqual(text, '1 Wei ICO')
text = format_ethereum_amount(9, ico_token, 1)
self.assertEqual(text, '9 Wei ICO')
text = format_ethereum_amount(10, ico_token, 1)
self.assertEqual(text, '0.000000001 ICO')
text = format_ethereum_amount(11, ico_token, 1)
self.assertEqual(text, '0.0000000011 ICO')
def test_format(self):
text = format_ethereum_amount(1, None, 1)
self.assertEqual(text, '1 Wei ETH')
text = format_ethereum_amount(1000, None, 1)
self.assertEqual(text, '1000 Wei ETH')
text = format_ethereum_amount(1000000, None, 1)
self.assertEqual(text, '1000000 Wei ETH')
text = format_ethereum_amount(10000000, None, 1)
self.assertEqual(text, '10000000 Wei ETH')
text = format_ethereum_amount(100000000, None, 1)
self.assertEqual(text, '100000000 Wei ETH')
text = format_ethereum_amount(1000000000, None, 1)
self.assertEqual(text, '0.000000001 ETH')
text = format_ethereum_amount(10000000000, None, 1)
self.assertEqual(text, '0.00000001 ETH')
text = format_ethereum_amount(100000000000, None, 1)
self.assertEqual(text, '0.0000001 ETH')
text = format_ethereum_amount(1000000000000, None, 1)
self.assertEqual(text, '0.000001 ETH')
text = format_ethereum_amount(10000000000000, None, 1)
self.assertEqual(text, '0.00001 ETH')
text = format_ethereum_amount(100000000000000, None, 1)
self.assertEqual(text, '0.0001 ETH')
text = format_ethereum_amount(1000000000000000, None, 1)
self.assertEqual(text, '0.001 ETH')
text = format_ethereum_amount(10000000000000000, None, 1)
self.assertEqual(text, '0.01 ETH')
text = format_ethereum_amount(100000000000000000, None, 1)
self.assertEqual(text, '0.1 ETH')
text = format_ethereum_amount(1000000000000000000, None, 1)
self.assertEqual(text, '1 ETH')
text = format_ethereum_amount(10000000000000000000, None, 1)
self.assertEqual(text, '10 ETH')
text = format_ethereum_amount(100000000000000000000, None, 1)
self.assertEqual(text, '100 ETH')
text = format_ethereum_amount(1000000000000000000000, None, 1)
self.assertEqual(text, '1000 ETH')
text = format_ethereum_amount(1000000000000000000, None, 61)
self.assertEqual(text, '1 ETC')
text = format_ethereum_amount(1000000000000000000, None, 31)
self.assertEqual(text, '1 tRBTC')
text = format_ethereum_amount(1000000000000000001, None, 1)
self.assertEqual(text, '1.000000000000000001 ETH')
text = format_ethereum_amount(10000000000000000001, None, 1)
self.assertEqual(text, '10.000000000000000001 ETH')
text = format_ethereum_amount(10000000000000000001, None, 61)
self.assertEqual(text, '10.000000000000000001 ETC')
text = format_ethereum_amount(1000000000000000001, None, 31)
self.assertEqual(text, '1.000000000000000001 tRBTC')
# unknown chain
text = format_ethereum_amount(1, None, 9999)
self.assertEqual(text, '1 Wei UNKN')
text = format_ethereum_amount(10000000000000000001, None, 9999)
self.assertEqual(text, '10.000000000000000001 UNKN')
# tokens with low decimal values
# USDC has 6 decimals
usdc_token = token_by_chain_address(
1, unhexlify("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"))
# ICO has 10 decimals
ico_token = token_by_chain_address(
1, unhexlify("a33e729bf4fdeb868b534e1f20523463d9c46bee"))
# when decimals < 10, should never display 'Wei' format
text = format_ethereum_amount(1, usdc_token, 1)
self.assertEqual(text, '0.000001 USDC')
text = format_ethereum_amount(0, usdc_token, 1)
self.assertEqual(text, '0 USDC')
text = format_ethereum_amount(1, ico_token, 1)
self.assertEqual(text, '1 Wei ICO')
text = format_ethereum_amount(9, ico_token, 1)
self.assertEqual(text, '9 Wei ICO')
text = format_ethereum_amount(10, ico_token, 1)
self.assertEqual(text, '0.000000001 ICO')
text = format_ethereum_amount(11, ico_token, 1)
self.assertEqual(text, '0.0000000011 ICO')
async def sign_tx(ctx, msg):
msg = sanitize(msg)
check(msg)
data_total = msg.data_length
# detect ERC - 20 token
token = None
recipient = msg.to
value = int.from_bytes(msg.value, "big")
if (len(msg.to) == 20 and len(msg.value) == 0 and data_total == 68
and len(msg.data_initial_chunk) == 68
and msg.data_initial_chunk[:16] ==
b"\xa9\x05\x9c\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
):
token = tokens.token_by_chain_address(msg.chain_id, msg.to)
recipient = msg.data_initial_chunk[16:36]
value = int.from_bytes(msg.data_initial_chunk[36:68], "big")
await require_confirm_tx(ctx, recipient, value, msg.chain_id, token,
msg.tx_type)
if token is None and msg.data_length > 0:
await require_confirm_data(ctx, msg.data_initial_chunk, data_total)
await require_confirm_fee(
ctx,
value,
int.from_bytes(msg.gas_price, "big"),
int.from_bytes(msg.gas_limit, "big"),
msg.chain_id,
token,
msg.tx_type,
)
data = bytearray()
data += msg.data_initial_chunk
data_left = data_total - len(msg.data_initial_chunk)
total_length = get_total_length(msg, data_total)
sha = HashWriter(sha3_256, keccak=True)
sha.extend(rlp.encode_length(total_length, True)) # total length
if msg.tx_type is not None:
sha.extend(rlp.encode(msg.tx_type))
for field in [msg.nonce, msg.gas_price, msg.gas_limit, msg.to, msg.value]:
sha.extend(rlp.encode(field))
if data_left == 0:
sha.extend(rlp.encode(data))
else:
sha.extend(rlp.encode_length(data_total, False))
sha.extend(rlp.encode(data, False))
while data_left > 0:
resp = await send_request_chunk(ctx, data_left)
data_left -= len(resp.data_chunk)
sha.extend(resp.data_chunk)
# eip 155 replay protection
if msg.chain_id:
sha.extend(rlp.encode(msg.chain_id))
sha.extend(rlp.encode(0))
sha.extend(rlp.encode(0))
digest = sha.get_digest()
return await send_signature(ctx, msg, digest)
