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
}