1
0
mirror of https://github.com/trezor/trezor-firmware.git synced 2024-12-05 05:58:23 +00:00
trezor-firmware/common/protob/messages-cardano.proto

526 lines
17 KiB
Protocol Buffer
Raw Normal View History

syntax = "proto2";
2018-07-29 14:17:00 +00:00
package hw.trezor.messages.cardano;
// Sugar for easier handling in Java
option java_package = "com.satoshilabs.trezor.lib.protobuf";
option java_outer_classname = "TrezorMessageCardano";
import "messages-common.proto";
enum CardanoDerivationType {
LEDGER = 0;
ICARUS = 1;
ICARUS_TREZOR = 2;
}
2020-07-23 13:54:49 +00:00
/**
* Values correspond to address header values given by the spec.
* Script addresses are only supported in transaction outputs.
2020-07-23 13:54:49 +00:00
*/
enum CardanoAddressType {
BASE = 0;
BASE_SCRIPT_KEY = 1;
BASE_KEY_SCRIPT = 2;
BASE_SCRIPT_SCRIPT = 3;
2020-07-23 13:54:49 +00:00
POINTER = 4;
POINTER_SCRIPT = 5;
2020-07-23 13:54:49 +00:00
ENTERPRISE = 6;
ENTERPRISE_SCRIPT = 7;
2020-07-23 13:54:49 +00:00
BYRON = 8;
REWARD = 14;
REWARD_SCRIPT = 15;
2020-07-23 13:54:49 +00:00
}
enum CardanoNativeScriptType {
PUB_KEY = 0;
ALL = 1;
ANY = 2;
N_OF_K = 3;
INVALID_BEFORE = 4;
INVALID_HEREAFTER = 5;
}
enum CardanoNativeScriptHashDisplayFormat {
HIDE = 0;
BECH32 = 1;
POLICY_ID = 2;
}
2022-06-06 11:32:48 +00:00
enum CardanoTxOutputSerializationFormat {
ARRAY_LEGACY = 0; // legacy_transaction_output in CDDL
MAP_BABBAGE = 1; // post_alonzo_transaction_output in CDDL
}
2020-07-17 07:13:08 +00:00
enum CardanoCertificateType {
STAKE_REGISTRATION = 0;
STAKE_DEREGISTRATION = 1;
STAKE_DELEGATION = 2;
STAKE_POOL_REGISTRATION = 3;
2023-11-10 14:18:57 +00:00
STAKE_REGISTRATION_CONWAY = 7;
STAKE_DEREGISTRATION_CONWAY = 8;
VOTE_DELEGATION = 9;
}
enum CardanoDRepType {
KEY_HASH = 0;
SCRIPT_HASH = 1;
ABSTAIN = 2;
NO_CONFIDENCE = 3;
}
enum CardanoPoolRelayType {
SINGLE_HOST_IP = 0;
SINGLE_HOST_NAME = 1;
MULTIPLE_HOST_NAME = 2;
2020-07-17 07:13:08 +00:00
}
enum CardanoTxAuxiliaryDataSupplementType {
NONE = 0;
CVOTE_REGISTRATION_SIGNATURE = 1;
}
enum CardanoCVoteRegistrationFormat {
CIP15 = 0;
CIP36 = 1;
}
enum CardanoTxSigningMode {
ORDINARY_TRANSACTION = 0;
POOL_REGISTRATION_AS_OWNER = 1;
MULTISIG_TRANSACTION = 2;
PLUTUS_TRANSACTION = 3;
}
enum CardanoTxWitnessType {
BYRON_WITNESS = 0;
SHELLEY_WITNESS = 1;
}
2020-07-23 13:54:49 +00:00
/**
* Structure representing cardano PointerAddress pointer,
* which points to a staking key registration certificate.
* @embed
*/
message CardanoBlockchainPointerType {
required uint32 block_index = 1;
required uint32 tx_index = 2;
required uint32 certificate_index = 3;
2020-07-23 13:54:49 +00:00
}
/*
* @embed
*/
message CardanoNativeScript {
required CardanoNativeScriptType type = 1;
repeated CardanoNativeScript scripts = 2;
optional bytes key_hash = 3;
repeated uint32 key_path = 4;
optional uint32 required_signatures_count = 5;
optional uint64 invalid_before = 6;
optional uint64 invalid_hereafter = 7;
}
/**
* Request: Ask device for Cardano native script hash
* @start
* @next CardanoNativeScriptHash
* @next Failure
*/
message CardanoGetNativeScriptHash {
required CardanoNativeScript script = 1;
required CardanoNativeScriptHashDisplayFormat display_format = 2; // display hash as bech32 or policy id
required CardanoDerivationType derivation_type = 3;
}
/**
* Request: Ask device for Cardano native script hash
* @end
*/
message CardanoNativeScriptHash {
required bytes script_hash = 1;
}
2020-07-23 13:54:49 +00:00
/**
* Structure to represent address parameters so they can be
* reused in CardanoGetAddress and CardanoTxOutputType.
* NetworkId isn't a part of the parameters, because in a transaction
* this will be included separately in the transaction itself, so it
* shouldn't be duplicated here.
* @embed
*/
message CardanoAddressParametersType {
required CardanoAddressType address_type = 1; // one of the CardanoAddressType-s
2020-07-23 13:54:49 +00:00
repeated uint32 address_n = 2; // BIP-32-style path to derive the spending key from master node
repeated uint32 address_n_staking = 3; // BIP-32-style path to derive staking key from master node
optional bytes staking_key_hash = 4; // staking key can be derived from address_n_staking, or
// can be sent directly e.g. if it doesn't belong to
// the same account as address_n
optional CardanoBlockchainPointerType certificate_pointer = 5; // a pointer to the staking key registration certificate
optional bytes script_payment_hash = 6;
optional bytes script_staking_hash = 7;
2020-07-23 13:54:49 +00:00
}
/**
* Request: Ask device for Cardano address
* @start
* @next CardanoAddress
* @next Failure
*/
message CardanoGetAddress {
2020-07-23 13:54:49 +00:00
// repeated uint32 address_n = 1; // moved to address_parameters
optional bool show_display = 2 [default=false]; // optionally prompt for confirmation on trezor display
required uint32 protocol_magic = 3; // network's protocol magic - needed for Byron addresses on testnets
required uint32 network_id = 4; // network id - mainnet or testnet
required CardanoAddressParametersType address_parameters = 5; // parameters used to derive the address
required CardanoDerivationType derivation_type = 6;
optional bool chunkify = 7; // display the address in chunks of 4 characters
}
/**
* Request: Ask device for Cardano address
* @end
*/
message CardanoAddress {
required string address = 1; // Base58 cardano address
}
/**
* Request: Ask device for public key corresponding to address_n path
* @start
* @next CardanoPublicKey
* @next Failure
*/
message CardanoGetPublicKey {
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
required CardanoDerivationType derivation_type = 3;
}
/**
* Response: Contains public key derived from device private seed
* @end
*/
message CardanoPublicKey {
required string xpub = 1; // Xpub key
required hw.trezor.messages.common.HDNodeType node = 2; // BIP-32 public node
}
/**
* Request: Initiate the Cardano transaction signing process on the device
* @start
* @next CardanoTxItemAck
* @next Failure
*/
message CardanoSignTxInit {
required CardanoTxSigningMode signing_mode = 1;
required uint32 protocol_magic = 2; // network's protocol magic
required uint32 network_id = 3; // network id - mainnet or testnet
required uint32 inputs_count = 4;
required uint32 outputs_count = 5;
required uint64 fee = 6; // transaction fee - added in shelley
optional uint64 ttl = 7; // transaction ttl - added in shelley
required uint32 certificates_count = 8;
required uint32 withdrawals_count = 9;
required bool has_auxiliary_data = 10;
optional uint64 validity_interval_start = 11;
required uint32 witness_requests_count = 12;
required uint32 minting_asset_groups_count = 13;
required CardanoDerivationType derivation_type = 14;
optional bool include_network_id = 15 [default=false]; // network id included as tx body item
optional bytes script_data_hash = 16;
required uint32 collateral_inputs_count = 17;
required uint32 required_signers_count = 18;
2022-06-06 11:32:48 +00:00
optional bool has_collateral_return = 19 [default=false];
optional uint64 total_collateral = 20;
optional uint32 reference_inputs_count = 21 [default=0];
optional bool chunkify = 22; // display the address in chunks of 4 characters
2023-12-08 12:48:53 +00:00
optional bool tag_cbor_sets = 23 [default=false]; // use tag 258 for sets in cbor
}
/**
* Request: Transaction input data
* @next CardanoTxItemAck
*/
message CardanoTxInput {
required bytes prev_hash = 1; // hash of previous transaction output to spend by this input
required uint32 prev_index = 2; // index of previous output to spend
}
/**
* Request: Transaction output data
* @next CardanoTxItemAck
*/
message CardanoTxOutput {
2022-06-06 11:32:48 +00:00
optional string address = 1; // target coin address in bech32 or base58
optional CardanoAddressParametersType address_parameters = 2; // parameters used to derive the address
required uint64 amount = 3; // amount to spend
required uint32 asset_groups_count = 4;
optional bytes datum_hash = 5;
2022-06-06 11:32:48 +00:00
optional CardanoTxOutputSerializationFormat format = 6 [default=ARRAY_LEGACY];
optional uint32 inline_datum_size = 7 [default=0]; // 0 means no inline datum
optional uint32 reference_script_size = 8 [default=0]; // 0 means no reference script
}
/**
* Request: Transaction output asset group data
* @next CardanoTxItemAck
*/
message CardanoAssetGroup {
required bytes policy_id = 1; // asset group policy id
required uint32 tokens_count = 2;
}
/**
* Request: Transaction output asset group token data
* @next CardanoTxItemAck
*/
message CardanoToken {
required bytes asset_name_bytes = 1; // asset name as bytestring (may be either ascii string or hash)
optional uint64 amount = 2; // asset amount
optional sint64 mint_amount = 3; // mint amount (can also be negative in which case the tokens are burnt)
}
2022-06-06 11:32:48 +00:00
/**
* Request: Transaction output inline datum chunk
* @next CardanoTxItemAck
*/
message CardanoTxInlineDatumChunk {
required bytes data = 1; // expected maximum chunk size is 1024 bytes
}
/**
* Request: Transaction output reference script chunk
* @next CardanoTxItemAck
*/
message CardanoTxReferenceScriptChunk {
required bytes data = 1; // expected maximum chunk size is 1024 bytes
}
/**
* Request: Stake pool owner parameters
* @next CardanoTxItemAck
*/
message CardanoPoolOwner {
repeated uint32 staking_key_path = 1; // BIP-32-style path to derive staking key of the owner
optional bytes staking_key_hash = 2; // owner's staking key if it is an external owner
}
/**
* Request: Stake pool relay parameters
* @next CardanoTxItemAck
*/
message CardanoPoolRelayParameters {
required CardanoPoolRelayType type = 1; // pool relay type
optional bytes ipv4_address = 2; // ipv4 address of the relay given as 4 bytes
optional bytes ipv6_address = 3; // ipv6 address of the relay given as 16 bytes
optional string host_name = 4; // relay host name given as URL, at most 64 characters
optional uint32 port = 5; // relay port number in the range 0-65535
}
/**
* Stake pool metadata parameters
* @embed
*/
message CardanoPoolMetadataType {
required string url = 1; // stake pool url hosting metadata, at most 64 characters
required bytes hash = 2; // stake pool metadata hash
}
/**
* Stake pool parameters
* @embed
*/
message CardanoPoolParametersType {
2022-04-16 09:34:47 +00:00
required bytes pool_id = 1; // stake pool cold public key hash (28 bytes)
required bytes vrf_key_hash = 2; // VRF key hash (32 bytes)
required uint64 pledge = 3; // pledge amount in lovelace
required uint64 cost = 4; // cost in lovelace
required uint64 margin_numerator = 5; // pool margin numerator
required uint64 margin_denominator = 6; // pool margin denominator
required string reward_account = 7; // bech32 reward address where the pool receives rewards
// repeated CardanoPoolOwner owners = 8; // legacy pool owners list - support for pre-tx-streaming firmwares dropped
// repeated CardanoPoolRelayParameters relays = 9; // legacy pool relays list - support for pre-tx-streaming firmwares dropped
optional CardanoPoolMetadataType metadata = 10; // pool metadata
required uint32 owners_count = 11; // number of pool owners
required uint32 relays_count = 12; // number of pool relays
}
2023-11-10 14:18:57 +00:00
/**
* DRep delegation parameters
* @embed
*/
message CardanoDRep {
required CardanoDRepType type = 1; // drep type
optional bytes key_hash = 2; // drep key hash
optional bytes script_hash = 3; // drep script hash
}
/**
* Request: Transaction certificate data
* @next CardanoTxItemAck
*/
message CardanoTxCertificate {
required CardanoCertificateType type = 1; // certificate type
repeated uint32 path = 2; // stake credential key path
optional bytes pool = 3; // pool hash
optional CardanoPoolParametersType pool_parameters = 4; // used for stake pool registration certificate
optional bytes script_hash = 5; // stake credential script hash
optional bytes key_hash = 6; // stake credential key hash
2023-11-10 14:18:57 +00:00
optional uint64 deposit = 7; // used for stake key registration certificate
optional CardanoDRep drep = 8; // used for vote delegation certificate
}
/**
* Request: Transaction withdrawal data
* @next CardanoTxItemAck
*/
message CardanoTxWithdrawal {
repeated uint32 path = 1; // stake credential key path
required uint64 amount = 2;
optional bytes script_hash = 3; // stake credential script hash
optional bytes key_hash = 4; // stake credential key hash
}
/**
* @embed
*/
message CardanoCVoteRegistrationDelegation {
required bytes vote_public_key = 1;
required uint32 weight = 2;
}
/**
* @embed
*/
message CardanoCVoteRegistrationParametersType {
optional bytes vote_public_key = 1; // mutually exclusive with delegations
repeated uint32 staking_path = 2;
optional CardanoAddressParametersType payment_address_parameters = 3; // mutually exclusive with payment_address
required uint64 nonce = 4;
optional CardanoCVoteRegistrationFormat format = 5 [default=CIP15];
repeated CardanoCVoteRegistrationDelegation delegations = 6; // mutually exclusive with vote_public_key; max 32 delegations
optional uint64 voting_purpose = 7;
optional string payment_address = 8; // mutually exclusive with payment_address_parameters
}
/**
* Request: Transaction auxiliary data
* @next CardanoTxItemAck
* @next CardanoTxAuxiliaryDataSupplement
*/
message CardanoTxAuxiliaryData {
optional CardanoCVoteRegistrationParametersType cvote_registration_parameters = 1;
optional bytes hash = 2;
}
/**
* Request: Transaction mint
* @next CardanoTxItemAck
*/
message CardanoTxMint {
required uint32 asset_groups_count = 1;
}
/**
* Request: Transaction collateral input data
* @next CardanoTxItemAck
*/
message CardanoTxCollateralInput {
required bytes prev_hash = 1;
required uint32 prev_index = 2;
}
/**
* Request: Transaction required signer
* @next CardanoTxItemAck
*/
message CardanoTxRequiredSigner {
optional bytes key_hash = 1;
repeated uint32 key_path = 2;
}
2022-06-06 11:32:48 +00:00
/**
* Request: Transaction reference input data
* @next CardanoTxItemAck
*/
message CardanoTxReferenceInput {
required bytes prev_hash = 1;
required uint32 prev_index = 2;
}
/**
* Response: Acknowledgement of the last transaction item received
* @next CardanoTxInput
* @next CardanoTxOutput
* @next CardanoAssetGroup
* @next CardanoToken
2022-06-06 11:32:48 +00:00
* @next CardanoTxInlineDatumChunk
* @next CardanoTxReferenceScriptChunk
* @next CardanoTxCertificate
* @next CardanoPoolOwner
* @next CardanoPoolRelayParameters
* @next CardanoTxWithdrawal
* @next CardanoTxAuxiliaryData
* @next CardanoTxWitnessRequest
* @next CardanoTxMint
* @next CardanoTxCollateralInput
* @next CardanoTxRequiredSigner
2022-06-06 11:32:48 +00:00
* @next CardanoTxReferenceInput
*/
message CardanoTxItemAck {
}
/**
* Response: Device-generated supplement for the auxiliary data
* @next CardanoTxWitnessRequest
*/
message CardanoTxAuxiliaryDataSupplement {
required CardanoTxAuxiliaryDataSupplementType type = 1;
optional bytes auxiliary_data_hash = 2;
optional bytes cvote_registration_signature = 3;
}
/**
* Request: Ask the device to sign a witness path
* @next CardanoTxWitnessResponse
*/
message CardanoTxWitnessRequest {
repeated uint32 path = 1;
}
/**
* Response: Signature corresponding to the requested witness path
* @next CardanoTxWitnessRequest
* @next CardanoTxHostAck
*/
message CardanoTxWitnessResponse {
required CardanoTxWitnessType type = 1;
required bytes pub_key = 2;
required bytes signature = 3;
optional bytes chain_code = 4;
}
/**
* Request: Acknowledgement of the last response received
* @next CardanoTxBodyHash
* @next CardanoSignTxFinished
*/
message CardanoTxHostAck {
}
/**
* Response: Hash of the serialized transaction body
* @next CardanoTxHostAck
*/
message CardanoTxBodyHash {
required bytes tx_hash = 1;
}
/**
* Response: Confirm the successful completion of the signing process
* @end
*/
message CardanoSignTxFinished {
}