144 lines
5.3 KiB
Python
144 lines
5.3 KiB
Python
from enum import IntEnum, auto
|
|
from typing import Optional
|
|
from ragger.backend import BackendInterface
|
|
from ragger.utils import RAPDU
|
|
from .command_builder import CommandBuilder
|
|
from .eip712 import EIP712FieldType
|
|
from .tlv import format_tlv
|
|
from pathlib import Path
|
|
import keychain
|
|
import rlp
|
|
|
|
|
|
ROOT_SCREENSHOT_PATH = Path(__file__).parent.parent
|
|
WEI_IN_ETH = 1e+18
|
|
|
|
|
|
class StatusWord(IntEnum):
|
|
OK = 0x9000
|
|
ERROR_NO_INFO = 0x6a00
|
|
INVALID_DATA = 0x6a80
|
|
INSUFFICIENT_MEMORY = 0x6a84
|
|
INVALID_INS = 0x6d00
|
|
INVALID_P1_P2 = 0x6b00
|
|
CONDITION_NOT_SATISFIED = 0x6985
|
|
REF_DATA_NOT_FOUND = 0x6a88
|
|
|
|
class DOMAIN_NAME_TAG(IntEnum):
|
|
STRUCTURE_TYPE = 0x01
|
|
STRUCTURE_VERSION = 0x02
|
|
CHALLENGE = 0x12
|
|
SIGNER_KEY_ID = 0x13
|
|
SIGNER_ALGO = 0x14
|
|
SIGNATURE = 0x15
|
|
DOMAIN_NAME = 0x20
|
|
COIN_TYPE = 0x21
|
|
ADDRESS = 0x22
|
|
|
|
|
|
class EthAppClient:
|
|
def __init__(self, client: BackendInterface):
|
|
self._client = client
|
|
self._cmd_builder = CommandBuilder()
|
|
|
|
def _send(self, payload: bytearray):
|
|
return self._client.exchange_async_raw(payload)
|
|
|
|
def response(self) -> RAPDU:
|
|
return self._client._last_async_response
|
|
|
|
def eip712_send_struct_def_struct_name(self, name: str):
|
|
return self._send(self._cmd_builder.eip712_send_struct_def_struct_name(name))
|
|
|
|
def eip712_send_struct_def_struct_field(self,
|
|
field_type: EIP712FieldType,
|
|
type_name: str,
|
|
type_size: int,
|
|
array_levels: [],
|
|
key_name: str):
|
|
return self._send(self._cmd_builder.eip712_send_struct_def_struct_field(
|
|
field_type,
|
|
type_name,
|
|
type_size,
|
|
array_levels,
|
|
key_name))
|
|
|
|
def eip712_send_struct_impl_root_struct(self, name: str):
|
|
return self._send(self._cmd_builder.eip712_send_struct_impl_root_struct(name))
|
|
|
|
def eip712_send_struct_impl_array(self, size: int):
|
|
return self._send(self._cmd_builder.eip712_send_struct_impl_array(size))
|
|
|
|
def eip712_send_struct_impl_struct_field(self, raw_value: bytes):
|
|
chunks = self._cmd_builder.eip712_send_struct_impl_struct_field(raw_value)
|
|
for chunk in chunks[:-1]:
|
|
with self._send(chunk):
|
|
pass
|
|
return self._send(chunks[-1])
|
|
|
|
def eip712_sign_new(self, bip32_path: str, verbose: bool):
|
|
return self._send(self._cmd_builder.eip712_sign_new(bip32_path))
|
|
|
|
def eip712_sign_legacy(self,
|
|
bip32_path: str,
|
|
domain_hash: bytes,
|
|
message_hash: bytes):
|
|
return self._send(self._cmd_builder.eip712_sign_legacy(bip32_path,
|
|
domain_hash,
|
|
message_hash))
|
|
|
|
def eip712_filtering_activate(self):
|
|
return self._send(self._cmd_builder.eip712_filtering_activate())
|
|
|
|
def eip712_filtering_message_info(self, name: str, filters_count: int, sig: bytes):
|
|
return self._send(self._cmd_builder.eip712_filtering_message_info(name, filters_count, sig))
|
|
|
|
def eip712_filtering_show_field(self, name: str, sig: bytes):
|
|
return self._send(self._cmd_builder.eip712_filtering_show_field(name, sig))
|
|
|
|
def send_fund(self,
|
|
bip32_path: str,
|
|
nonce: int,
|
|
gas_price: int,
|
|
gas_limit: int,
|
|
to: bytes,
|
|
amount: float,
|
|
chain_id: int):
|
|
data = list()
|
|
data.append(nonce)
|
|
data.append(gas_price)
|
|
data.append(gas_limit)
|
|
data.append(to)
|
|
data.append(int(amount * WEI_IN_ETH))
|
|
data.append(bytes())
|
|
data.append(chain_id)
|
|
data.append(bytes())
|
|
data.append(bytes())
|
|
|
|
chunks = self._cmd_builder.sign(bip32_path, rlp.encode(data))
|
|
for chunk in chunks[:-1]:
|
|
with self._send(chunk):
|
|
pass
|
|
return self._send(chunks[-1])
|
|
|
|
def get_challenge(self):
|
|
return self._send(self._cmd_builder.get_challenge())
|
|
|
|
def provide_domain_name(self, challenge: int, name: str, addr: bytes):
|
|
payload = format_tlv(DOMAIN_NAME_TAG.STRUCTURE_TYPE, 3) # TrustedDomainName
|
|
payload += format_tlv(DOMAIN_NAME_TAG.STRUCTURE_VERSION, 1)
|
|
payload += format_tlv(DOMAIN_NAME_TAG.SIGNER_KEY_ID, 0) # test key
|
|
payload += format_tlv(DOMAIN_NAME_TAG.SIGNER_ALGO, 1) # secp256k1
|
|
payload += format_tlv(DOMAIN_NAME_TAG.CHALLENGE, challenge)
|
|
payload += format_tlv(DOMAIN_NAME_TAG.COIN_TYPE, 0x3c) # ETH in slip-44
|
|
payload += format_tlv(DOMAIN_NAME_TAG.DOMAIN_NAME, name)
|
|
payload += format_tlv(DOMAIN_NAME_TAG.ADDRESS, addr)
|
|
payload += format_tlv(DOMAIN_NAME_TAG.SIGNATURE,
|
|
keychain.sign_data(keychain.Key.DOMAIN_NAME, payload))
|
|
|
|
chunks = self._cmd_builder.provide_domain_name(payload)
|
|
for chunk in chunks[:-1]:
|
|
with self._send(chunk):
|
|
pass
|
|
return self._send(chunks[-1])
|