syntax = "proto2"; package hw.trezor.messages.ethereum; // Sugar for easier handling in Java option java_package = "com.satoshilabs.trezor.lib.protobuf"; option java_outer_classname = "TrezorMessageEthereum"; import "messages-common.proto"; import "messages-ethereum-definitions.proto"; /** * Request: Ask device for public key corresponding to address_n path * @start * @next EthereumPublicKey * @next Failure */ message EthereumGetPublicKey { repeated uint32 address_n = 1; // BIP-32 path to derive the key from master node optional bool show_display = 2; // optionally show on display before sending the result } /** * Response: Contains public key derived from device private seed * @end */ message EthereumPublicKey { required hw.trezor.messages.common.HDNodeType node = 1; // BIP32 public node required string xpub = 2; // serialized form of public node } /** * Request: Ask device for Ethereum address corresponding to address_n path * @start * @next EthereumAddress * @next Failure */ message EthereumGetAddress { repeated uint32 address_n = 1; // BIP-32 path to derive the key from master node optional bool show_display = 2; // optionally show on display before sending the result optional bytes encoded_network = 3; // encoded Ethereum network, see ethereum-definitions.md for details optional bool chunkify = 4; // display the address in chunks of 4 characters } /** * Response: Contains an Ethereum address derived from device private seed * @end */ message EthereumAddress { optional bytes _old_address = 1 [deprecated=true]; // trezor <1.8.0, <2.1.0 - raw bytes of Ethereum address optional string address = 2; // Ethereum address as hex-encoded string } /** * Request: Ask device to sign transaction * gas_price, gas_limit and chain_id must be provided and non-zero. * All other fields are optional and default to value `0` if missing. * Note: the first at most 1024 bytes of data MUST be transmitted as part of this message. * @start * @next EthereumTxRequest * @next Failure */ message EthereumSignTx { repeated uint32 address_n = 1; // BIP-32 path to derive the key from master node optional bytes nonce = 2 [default='']; // <=256 bit unsigned big endian required bytes gas_price = 3; // <=256 bit unsigned big endian (in wei) required bytes gas_limit = 4; // <=256 bit unsigned big endian optional string to = 11 [default='']; // recipient address optional bytes value = 6 [default='']; // <=256 bit unsigned big endian (in wei) optional bytes data_initial_chunk = 7 [default='']; // The initial data chunk (<= 1024 bytes) optional uint32 data_length = 8 [default=0]; // Length of transaction payload required uint64 chain_id = 9; // Chain Id for EIP 155 optional uint32 tx_type = 10; // Used for Wanchain optional ethereum_definitions.EthereumDefinitions definitions = 12; // network and/or token definitions for tx optional bool chunkify = 13; // display the address in chunks of 4 characters } /** * Request: Ask device to sign EIP1559 transaction * Note: the first at most 1024 bytes of data MUST be transmitted as part of this message. * @start * @next EthereumTxRequest * @next Failure */ message EthereumSignTxEIP1559 { repeated uint32 address_n = 1; // BIP-32 path to derive the key from master node required bytes nonce = 2; // <=256 bit unsigned big endian required bytes max_gas_fee = 3; // <=256 bit unsigned big endian (in wei) required bytes max_priority_fee = 4; // <=256 bit unsigned big endian (in wei) required bytes gas_limit = 5; // <=256 bit unsigned big endian optional string to = 6 [default='']; // recipient address required bytes value = 7; // <=256 bit unsigned big endian (in wei) optional bytes data_initial_chunk = 8 [default='']; // The initial data chunk (<= 1024 bytes) required uint32 data_length = 9; // Length of transaction payload required uint64 chain_id = 10; // Chain Id for EIP 155 repeated EthereumAccessList access_list = 11; // Access List optional ethereum_definitions.EthereumDefinitions definitions = 12; // network and/or token definitions for tx optional bool chunkify = 13; // display the address in chunks of 4 characters message EthereumAccessList { required string address = 1; repeated bytes storage_keys = 2; } } /** * Response: Device asks for more data from transaction payload, or returns the signature. * If data_length is set, device awaits that many more bytes of payload. * Otherwise, the signature_* fields contain the computed transaction signature. All three fields will be present. * @end * @next EthereumTxAck */ message EthereumTxRequest { optional uint32 data_length = 1; // Number of bytes being requested (<= 1024) optional uint32 signature_v = 2; // Computed signature (recovery parameter, limited to 27 or 28) optional bytes signature_r = 3; // Computed signature R component (256 bit) optional bytes signature_s = 4; // Computed signature S component (256 bit) } /** * Request: Transaction payload data. * @next EthereumTxRequest */ message EthereumTxAck { required bytes data_chunk = 1; // Bytes from transaction payload (<= 1024 bytes) } /** * Request: Ask device to sign message * @start * @next EthereumMessageSignature * @next Failure */ message EthereumSignMessage { repeated uint32 address_n = 1; // BIP-32 path to derive the key from master node required bytes message = 2; // message to be signed optional bytes encoded_network = 3; // encoded Ethereum network, see ethereum-definitions.md for details optional bool chunkify = 4; // display the address in chunks of 4 characters } /** * Response: Signed message * @end */ message EthereumMessageSignature { required bytes signature = 2; // signature of the message required string address = 3; // address used to sign the message } /** * Request: Ask device to verify message * @start * @next Success * @next Failure */ message EthereumVerifyMessage { required bytes signature = 2; // signature to verify required bytes message = 3; // message to verify required string address = 4; // address to verify optional bool chunkify = 5; // display the address in chunks of 4 characters } /** * Request: Ask device to sign hash of typed data * @start * @next EthereumTypedDataSignature * @next Failure */ message EthereumSignTypedHash { repeated uint32 address_n = 1; // BIP-32 path to derive the key from master node required bytes domain_separator_hash = 2; // Hash of domainSeparator of typed data to be signed optional bytes message_hash = 3; // Hash of the data of typed data to be signed (empty if domain-only data) optional bytes encoded_network = 4; // encoded Ethereum network, see ethereum-definitions.md for details } /** * Response: Signed typed data * @end */ message EthereumTypedDataSignature { required bytes signature = 1; // signature of the typed data required string address = 2; // address used to sign the typed data }