diff --git a/common/protob/messages-cardano.proto b/common/protob/messages-cardano.proto index c5a0dc04f..9aa5c60b5 100644 --- a/common/protob/messages-cardano.proto +++ b/common/protob/messages-cardano.proto @@ -38,6 +38,21 @@ enum CardanoPoolRelayType { MULTIPLE_HOST_NAME = 2; } +enum CardanoTxAuxiliaryDataSupplementType { + NONE = 0; + CATALYST_REGISTRATION_SIGNATURE = 1; +} + +enum CardanoTxSigningMode { + ORDINARY_TRANSACTION = 0; + POOL_REGISTRATION_AS_OWNER = 1; +} + +enum CardanoTxWitnessType { + BYRON_WITNESS = 0; + SHELLEY_WITNESS = 1; +} + /** * Structure representing cardano PointerAddress pointer, * which points to a staking key registration certificate. @@ -109,6 +124,223 @@ message CardanoPublicKey { 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; +} + +/** + * 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 { + 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; +} + +/** + * 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) + required uint64 amount = 2; // asset amount +} + +/** + * 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 { + 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 [deprecated = true]; // pool owners list + repeated CardanoPoolRelayParameters relays = 9 [deprecated = true]; // pool relays list + optional CardanoPoolMetadataType metadata = 10; // pool metadata + required uint32 owners_count = 11; // number of pool owners + required uint32 relays_count = 12; // number of pool relays +} + +/** + * Request: Transaction certificate data + * @next CardanoTxItemAck + */ + message CardanoTxCertificate { + required CardanoCertificateType type = 1; // certificate type + repeated uint32 path = 2; // BIP-32 path to derive (staking) key + optional bytes pool = 3; // pool hash + optional CardanoPoolParametersType pool_parameters = 4; // used for stake pool registration certificate +} + +/** + * Request: Transaction withdrawal data + * @next CardanoTxItemAck + */ +message CardanoTxWithdrawal { + repeated uint32 path = 1; + required uint64 amount = 2; +} + +/** + * @embed + */ +message CardanoCatalystRegistrationParametersType { + required bytes voting_public_key = 1; + repeated uint32 staking_path = 2; + required CardanoAddressParametersType reward_address_parameters = 3; + required uint64 nonce = 4; +} + +/** + * Request: Transaction auxiliary data + * @next CardanoTxItemAck + * @next CardanoTxAuxiliaryDataSupplement + */ +message CardanoTxAuxiliaryData { + optional CardanoCatalystRegistrationParametersType catalyst_registration_parameters = 1; + optional bytes hash = 2; +} + +/** + * Response: Acknowledgement of the last transaction item received + * @next CardanoTxInput + * @next CardanoTxOutput + * @next CardanoAssetGroup + * @next CardanoToken + * @next CardanoTxCertificate + * @next CardanoPoolOwner + * @next CardanoPoolRelayParameters + * @next CardanoTxWithdrawal + * @next CardanoTxAuxiliaryData + * @next CardanoTxWitnessRequest + */ +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 catalyst_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 { +} + /** * Request: Ask device to sign Cardano transaction * @start @@ -116,6 +348,8 @@ message CardanoPublicKey { * @next Failure */ message CardanoSignTx { + option deprecated = true; + repeated CardanoTxInputType inputs = 1; // inputs to be used in transaction repeated CardanoTxOutputType outputs = 2; // outputs to be used in transaction // optional uint32 transactions_count = 3; // left as a comment so we know to skip the id 3 in the future @@ -146,7 +380,7 @@ message CardanoSignTx { message CardanoTxOutputType { optional string address = 1; // target coin address in bech32 or base58 // repeated uint32 address_n = 2; // moved to address_parameters - required uint64 amount = 3; // amount to spend + required uint64 amount = 3; // amount in Lovelace optional CardanoAddressParametersType address_parameters = 4; // parameters used to derive the address repeated CardanoAssetGroupType token_bundle = 5; // custom assets - added in mary } @@ -180,30 +414,6 @@ message CardanoSignTx { optional uint32 port = 5; // relay port number in the range 0-65535 } - /** - * Stake pool metadata parameters - */ - 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 - */ - message CardanoPoolParametersType { - 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 CardanoPoolOwnerType owners = 8; // pool owners list - repeated CardanoPoolRelayParametersType relays = 9; // pool relays list - optional CardanoPoolMetadataType metadata = 10; // pool metadata - } - /** * Structure representing cardano transaction certificate */ @@ -221,13 +431,6 @@ message CardanoSignTx { required uint64 amount = 2; } - message CardanoCatalystRegistrationParametersType { - required bytes voting_public_key = 1; - repeated uint32 staking_path = 2; - required CardanoAddressParametersType reward_address_parameters = 3; - required uint64 nonce = 4; - } - message CardanoTxAuxiliaryDataType { optional bytes blob = 1; optional CardanoCatalystRegistrationParametersType catalyst_registration_parameters = 2; @@ -239,6 +442,8 @@ message CardanoSignTx { * @next CardanoSignedTxChunkAck */ message CardanoSignedTxChunk { + option deprecated = true; + required bytes signed_tx_chunk = 1; // serialised, signed transaction chunk } @@ -248,6 +453,7 @@ message CardanoSignedTxChunk { * @next CardanoSignedTx */ message CardanoSignedTxChunkAck { + option deprecated = true; } /** @@ -255,6 +461,8 @@ message CardanoSignedTxChunkAck { * @end */ message CardanoSignedTx { + option deprecated = true; + required bytes tx_hash = 1; // hash of the transaction body optional bytes serialized_tx = 2; // deprecated since transaction is sent in chunks now - kept for backwards compatibility } diff --git a/common/protob/messages.proto b/common/protob/messages.proto index a5514b516..995e4c17d 100644 --- a/common/protob/messages.proto +++ b/common/protob/messages.proto @@ -241,6 +241,24 @@ enum MessageType { MessageType_CardanoSignedTx = 310 [(wire_out) = true]; MessageType_CardanoSignedTxChunk = 311 [(wire_out) = true]; MessageType_CardanoSignedTxChunkAck = 312 [(wire_in) = true]; + MessageType_CardanoTxItemAck = 313 [(wire_out) = true]; + MessageType_CardanoTxAuxiliaryDataSupplement = 314 [(wire_out) = true]; + MessageType_CardanoTxWitnessRequest = 315 [(wire_in) = true]; + MessageType_CardanoTxWitnessResponse = 316 [(wire_out) = true]; + MessageType_CardanoTxHostAck = 317 [(wire_in) = true]; + MessageType_CardanoTxBodyHash = 318 [(wire_out) = true]; + MessageType_CardanoSignTxFinished = 319 [(wire_out) = true]; + MessageType_CardanoSignTxInit = 320 [(wire_in) = true]; + MessageType_CardanoTxInput = 321 [(wire_in) = true]; + MessageType_CardanoTxOutput = 322 [(wire_in) = true]; + MessageType_CardanoAssetGroup = 323 [(wire_in) = true]; + MessageType_CardanoToken = 324 [(wire_in) = true]; + MessageType_CardanoTxCertificate = 325 [(wire_in) = true]; + MessageType_CardanoTxWithdrawal = 326 [(wire_in) = true]; + MessageType_CardanoTxAuxiliaryData = 327 [(wire_in) = true]; + MessageType_CardanoPoolOwner = 328 [(wire_in) = true]; + MessageType_CardanoPoolRelayParameters = 329 [(wire_in) = true]; + // Ripple MessageType_RippleGetAddress = 400 [(wire_in) = true]; diff --git a/core/src/all_modules.py b/core/src/all_modules.py index cf1290cf2..2ea5f6978 100644 --- a/core/src/all_modules.py +++ b/core/src/all_modules.py @@ -394,6 +394,12 @@ if utils.BITCOIN_ONLY: import trezor.enums.CardanoCertificateType trezor.enums.CardanoPoolRelayType import trezor.enums.CardanoPoolRelayType + trezor.enums.CardanoTxAuxiliaryDataSupplementType + import trezor.enums.CardanoTxAuxiliaryDataSupplementType + trezor.enums.CardanoTxSigningMode + import trezor.enums.CardanoTxSigningMode + trezor.enums.CardanoTxWitnessType + import trezor.enums.CardanoTxWitnessType trezor.enums.NEMImportanceTransferMode import trezor.enums.NEMImportanceTransferMode trezor.enums.NEMModificationType diff --git a/core/src/trezor/enums/CardanoTxAuxiliaryDataSupplementType.py b/core/src/trezor/enums/CardanoTxAuxiliaryDataSupplementType.py new file mode 100644 index 000000000..8baae8ff0 --- /dev/null +++ b/core/src/trezor/enums/CardanoTxAuxiliaryDataSupplementType.py @@ -0,0 +1,6 @@ +# Automatically generated by pb2py +# fmt: off +# isort:skip_file + +NONE = 0 +CATALYST_REGISTRATION_SIGNATURE = 1 diff --git a/core/src/trezor/enums/CardanoTxSigningMode.py b/core/src/trezor/enums/CardanoTxSigningMode.py new file mode 100644 index 000000000..64dd65898 --- /dev/null +++ b/core/src/trezor/enums/CardanoTxSigningMode.py @@ -0,0 +1,6 @@ +# Automatically generated by pb2py +# fmt: off +# isort:skip_file + +ORDINARY_TRANSACTION = 0 +POOL_REGISTRATION_AS_OWNER = 1 diff --git a/core/src/trezor/enums/CardanoTxWitnessType.py b/core/src/trezor/enums/CardanoTxWitnessType.py new file mode 100644 index 000000000..fb5a73604 --- /dev/null +++ b/core/src/trezor/enums/CardanoTxWitnessType.py @@ -0,0 +1,6 @@ +# Automatically generated by pb2py +# fmt: off +# isort:skip_file + +BYRON_WITNESS = 0 +SHELLEY_WITNESS = 1 diff --git a/core/src/trezor/enums/MessageType.py b/core/src/trezor/enums/MessageType.py index 1e59576f5..fbe67c573 100644 --- a/core/src/trezor/enums/MessageType.py +++ b/core/src/trezor/enums/MessageType.py @@ -133,6 +133,23 @@ if not utils.BITCOIN_ONLY: CardanoSignedTx = 310 CardanoSignedTxChunk = 311 CardanoSignedTxChunkAck = 312 + CardanoTxItemAck = 313 + CardanoTxAuxiliaryDataSupplement = 314 + CardanoTxWitnessRequest = 315 + CardanoTxWitnessResponse = 316 + CardanoTxHostAck = 317 + CardanoTxBodyHash = 318 + CardanoSignTxFinished = 319 + CardanoSignTxInit = 320 + CardanoTxInput = 321 + CardanoTxOutput = 322 + CardanoAssetGroup = 323 + CardanoToken = 324 + CardanoTxCertificate = 325 + CardanoTxWithdrawal = 326 + CardanoTxAuxiliaryData = 327 + CardanoPoolOwner = 328 + CardanoPoolRelayParameters = 329 RippleGetAddress = 400 RippleAddress = 401 RippleSignTx = 402 diff --git a/core/src/trezor/enums/__init__.py b/core/src/trezor/enums/__init__.py index 522b18c22..2f5b42ab0 100644 --- a/core/src/trezor/enums/__init__.py +++ b/core/src/trezor/enums/__init__.py @@ -138,6 +138,23 @@ if TYPE_CHECKING: CardanoSignedTx = 310 CardanoSignedTxChunk = 311 CardanoSignedTxChunkAck = 312 + CardanoTxItemAck = 313 + CardanoTxAuxiliaryDataSupplement = 314 + CardanoTxWitnessRequest = 315 + CardanoTxWitnessResponse = 316 + CardanoTxHostAck = 317 + CardanoTxBodyHash = 318 + CardanoSignTxFinished = 319 + CardanoSignTxInit = 320 + CardanoTxInput = 321 + CardanoTxOutput = 322 + CardanoAssetGroup = 323 + CardanoToken = 324 + CardanoTxCertificate = 325 + CardanoTxWithdrawal = 326 + CardanoTxAuxiliaryData = 327 + CardanoPoolOwner = 328 + CardanoPoolRelayParameters = 329 RippleGetAddress = 400 RippleAddress = 401 RippleSignTx = 402 @@ -322,6 +339,18 @@ if TYPE_CHECKING: SINGLE_HOST_NAME = 1 MULTIPLE_HOST_NAME = 2 + class CardanoTxAuxiliaryDataSupplementType(IntEnum): + NONE = 0 + CATALYST_REGISTRATION_SIGNATURE = 1 + + class CardanoTxSigningMode(IntEnum): + ORDINARY_TRANSACTION = 0 + POOL_REGISTRATION_AS_OWNER = 1 + + class CardanoTxWitnessType(IntEnum): + BYRON_WITNESS = 0 + SHELLEY_WITNESS = 1 + class BackupType(IntEnum): Bip39 = 0 Slip39_Basic = 1 diff --git a/core/src/trezor/messages.py b/core/src/trezor/messages.py index c21da4a62..7d0fc5014 100644 --- a/core/src/trezor/messages.py +++ b/core/src/trezor/messages.py @@ -28,6 +28,9 @@ if TYPE_CHECKING: from trezor.enums import CardanoAddressType # noqa: F401 from trezor.enums import CardanoCertificateType # noqa: F401 from trezor.enums import CardanoPoolRelayType # noqa: F401 + from trezor.enums import CardanoTxAuxiliaryDataSupplementType # noqa: F401 + from trezor.enums import CardanoTxSigningMode # noqa: F401 + from trezor.enums import CardanoTxWitnessType # noqa: F401 from trezor.enums import DebugSwipeDirection # noqa: F401 from trezor.enums import DecredStakingSpendType # noqa: F401 from trezor.enums import FailureType # noqa: F401 @@ -1141,76 +1144,43 @@ if TYPE_CHECKING: def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPublicKey"]: return isinstance(msg, cls) - class CardanoSignTx(protobuf.MessageType): - inputs: "list[CardanoTxInputType]" - outputs: "list[CardanoTxOutputType]" + class CardanoSignTxInit(protobuf.MessageType): + signing_mode: "CardanoTxSigningMode" protocol_magic: "int" + network_id: "int" + inputs_count: "int" + outputs_count: "int" fee: "int" ttl: "int | None" - network_id: "int" - certificates: "list[CardanoTxCertificateType]" - withdrawals: "list[CardanoTxWithdrawalType]" + certificates_count: "int" + withdrawals_count: "int" + has_auxiliary_data: "bool" validity_interval_start: "int | None" - auxiliary_data: "CardanoTxAuxiliaryDataType | None" + witness_requests_count: "int" def __init__( self, *, + signing_mode: "CardanoTxSigningMode", protocol_magic: "int", - fee: "int", network_id: "int", - inputs: "list[CardanoTxInputType] | None" = None, - outputs: "list[CardanoTxOutputType] | None" = None, - certificates: "list[CardanoTxCertificateType] | None" = None, - withdrawals: "list[CardanoTxWithdrawalType] | None" = None, + inputs_count: "int", + outputs_count: "int", + fee: "int", + certificates_count: "int", + withdrawals_count: "int", + has_auxiliary_data: "bool", + witness_requests_count: "int", ttl: "int | None" = None, validity_interval_start: "int | None" = None, - auxiliary_data: "CardanoTxAuxiliaryDataType | None" = None, - ) -> None: - pass - - @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoSignTx"]: - return isinstance(msg, cls) - - class CardanoSignedTxChunk(protobuf.MessageType): - signed_tx_chunk: "bytes" - - def __init__( - self, - *, - signed_tx_chunk: "bytes", ) -> None: pass @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoSignedTxChunk"]: + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoSignTxInit"]: return isinstance(msg, cls) - class CardanoSignedTxChunkAck(protobuf.MessageType): - - @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoSignedTxChunkAck"]: - return isinstance(msg, cls) - - class CardanoSignedTx(protobuf.MessageType): - tx_hash: "bytes" - serialized_tx: "bytes | None" - - def __init__( - self, - *, - tx_hash: "bytes", - serialized_tx: "bytes | None" = None, - ) -> None: - pass - - @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoSignedTx"]: - return isinstance(msg, cls) - - class CardanoTxInputType(protobuf.MessageType): - address_n: "list[int]" + class CardanoTxInput(protobuf.MessageType): prev_hash: "bytes" prev_index: "int" @@ -1219,51 +1189,50 @@ if TYPE_CHECKING: *, prev_hash: "bytes", prev_index: "int", - address_n: "list[int] | None" = None, ) -> None: pass @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxInputType"]: + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxInput"]: return isinstance(msg, cls) - class CardanoTxOutputType(protobuf.MessageType): + class CardanoTxOutput(protobuf.MessageType): address: "str | None" - amount: "int" address_parameters: "CardanoAddressParametersType | None" - token_bundle: "list[CardanoAssetGroupType]" + amount: "int" + asset_groups_count: "int" def __init__( self, *, amount: "int", - token_bundle: "list[CardanoAssetGroupType] | None" = None, + asset_groups_count: "int", address: "str | None" = None, address_parameters: "CardanoAddressParametersType | None" = None, ) -> None: pass @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxOutputType"]: + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxOutput"]: return isinstance(msg, cls) - class CardanoAssetGroupType(protobuf.MessageType): + class CardanoAssetGroup(protobuf.MessageType): policy_id: "bytes" - tokens: "list[CardanoTokenType]" + tokens_count: "int" def __init__( self, *, policy_id: "bytes", - tokens: "list[CardanoTokenType] | None" = None, + tokens_count: "int", ) -> None: pass @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoAssetGroupType"]: + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoAssetGroup"]: return isinstance(msg, cls) - class CardanoTokenType(protobuf.MessageType): + class CardanoToken(protobuf.MessageType): asset_name_bytes: "bytes" amount: "int" @@ -1276,10 +1245,10 @@ if TYPE_CHECKING: pass @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTokenType"]: + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoToken"]: return isinstance(msg, cls) - class CardanoPoolOwnerType(protobuf.MessageType): + class CardanoPoolOwner(protobuf.MessageType): staking_key_path: "list[int]" staking_key_hash: "bytes | None" @@ -1292,10 +1261,10 @@ if TYPE_CHECKING: pass @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPoolOwnerType"]: + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPoolOwner"]: return isinstance(msg, cls) - class CardanoPoolRelayParametersType(protobuf.MessageType): + class CardanoPoolRelayParameters(protobuf.MessageType): type: "CardanoPoolRelayType" ipv4_address: "bytes | None" ipv6_address: "bytes | None" @@ -1314,7 +1283,7 @@ if TYPE_CHECKING: pass @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPoolRelayParametersType"]: + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPoolRelayParameters"]: return isinstance(msg, cls) class CardanoPoolMetadataType(protobuf.MessageType): @@ -1341,9 +1310,9 @@ if TYPE_CHECKING: margin_numerator: "int" margin_denominator: "int" reward_account: "str" - owners: "list[CardanoPoolOwnerType]" - relays: "list[CardanoPoolRelayParametersType]" metadata: "CardanoPoolMetadataType | None" + owners_count: "int" + relays_count: "int" def __init__( self, @@ -1355,8 +1324,8 @@ if TYPE_CHECKING: margin_numerator: "int", margin_denominator: "int", reward_account: "str", - owners: "list[CardanoPoolOwnerType] | None" = None, - relays: "list[CardanoPoolRelayParametersType] | None" = None, + owners_count: "int", + relays_count: "int", metadata: "CardanoPoolMetadataType | None" = None, ) -> None: pass @@ -1365,7 +1334,7 @@ if TYPE_CHECKING: def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPoolParametersType"]: return isinstance(msg, cls) - class CardanoTxCertificateType(protobuf.MessageType): + class CardanoTxCertificate(protobuf.MessageType): type: "CardanoCertificateType" path: "list[int]" pool: "bytes | None" @@ -1382,10 +1351,10 @@ if TYPE_CHECKING: pass @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxCertificateType"]: + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxCertificate"]: return isinstance(msg, cls) - class CardanoTxWithdrawalType(protobuf.MessageType): + class CardanoTxWithdrawal(protobuf.MessageType): path: "list[int]" amount: "int" @@ -1398,7 +1367,7 @@ if TYPE_CHECKING: pass @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxWithdrawalType"]: + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxWithdrawal"]: return isinstance(msg, cls) class CardanoCatalystRegistrationParametersType(protobuf.MessageType): @@ -1421,20 +1390,104 @@ if TYPE_CHECKING: def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoCatalystRegistrationParametersType"]: return isinstance(msg, cls) - class CardanoTxAuxiliaryDataType(protobuf.MessageType): - blob: "bytes | None" + class CardanoTxAuxiliaryData(protobuf.MessageType): catalyst_registration_parameters: "CardanoCatalystRegistrationParametersType | None" + hash: "bytes | None" def __init__( self, *, - blob: "bytes | None" = None, catalyst_registration_parameters: "CardanoCatalystRegistrationParametersType | None" = None, + hash: "bytes | None" = None, + ) -> None: + pass + + @classmethod + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxAuxiliaryData"]: + return isinstance(msg, cls) + + class CardanoTxItemAck(protobuf.MessageType): + + @classmethod + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxItemAck"]: + return isinstance(msg, cls) + + class CardanoTxAuxiliaryDataSupplement(protobuf.MessageType): + type: "CardanoTxAuxiliaryDataSupplementType" + auxiliary_data_hash: "bytes | None" + catalyst_signature: "bytes | None" + + def __init__( + self, + *, + type: "CardanoTxAuxiliaryDataSupplementType", + auxiliary_data_hash: "bytes | None" = None, + catalyst_signature: "bytes | None" = None, + ) -> None: + pass + + @classmethod + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxAuxiliaryDataSupplement"]: + return isinstance(msg, cls) + + class CardanoTxWitnessRequest(protobuf.MessageType): + path: "list[int]" + + def __init__( + self, + *, + path: "list[int] | None" = None, ) -> None: pass @classmethod - def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxAuxiliaryDataType"]: + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxWitnessRequest"]: + return isinstance(msg, cls) + + class CardanoTxWitnessResponse(protobuf.MessageType): + type: "CardanoTxWitnessType" + pub_key: "bytes" + signature: "bytes" + chain_code: "bytes | None" + + def __init__( + self, + *, + type: "CardanoTxWitnessType", + pub_key: "bytes", + signature: "bytes", + chain_code: "bytes | None" = None, + ) -> None: + pass + + @classmethod + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxWitnessResponse"]: + return isinstance(msg, cls) + + class CardanoTxHostAck(protobuf.MessageType): + + @classmethod + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxHostAck"]: + return isinstance(msg, cls) + + class CardanoTxBodyHash(protobuf.MessageType): + tx_hash: "bytes" + + def __init__( + self, + *, + tx_hash: "bytes", + ) -> None: + pass + + @classmethod + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxBodyHash"]: + return isinstance(msg, cls) + + class CardanoSignTxFinished(protobuf.MessageType): + + @classmethod + def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoSignTxFinished"]: return isinstance(msg, cls) class CipherKeyValue(protobuf.MessageType): diff --git a/python/src/trezorlib/messages.py b/python/src/trezorlib/messages.py index ef2e58b09..2307885b9 100644 --- a/python/src/trezorlib/messages.py +++ b/python/src/trezorlib/messages.py @@ -159,6 +159,23 @@ class MessageType(IntEnum): CardanoSignedTx = 310 CardanoSignedTxChunk = 311 CardanoSignedTxChunkAck = 312 + CardanoTxItemAck = 313 + CardanoTxAuxiliaryDataSupplement = 314 + CardanoTxWitnessRequest = 315 + CardanoTxWitnessResponse = 316 + CardanoTxHostAck = 317 + CardanoTxBodyHash = 318 + CardanoSignTxFinished = 319 + CardanoSignTxInit = 320 + CardanoTxInput = 321 + CardanoTxOutput = 322 + CardanoAssetGroup = 323 + CardanoToken = 324 + CardanoTxCertificate = 325 + CardanoTxWithdrawal = 326 + CardanoTxAuxiliaryData = 327 + CardanoPoolOwner = 328 + CardanoPoolRelayParameters = 329 RippleGetAddress = 400 RippleAddress = 401 RippleSignTx = 402 @@ -338,6 +355,21 @@ class CardanoPoolRelayType(IntEnum): MULTIPLE_HOST_NAME = 2 +class CardanoTxAuxiliaryDataSupplementType(IntEnum): + NONE = 0 + CATALYST_REGISTRATION_SIGNATURE = 1 + + +class CardanoTxSigningMode(IntEnum): + ORDINARY_TRANSACTION = 0 + POOL_REGISTRATION_AS_OWNER = 1 + + +class CardanoTxWitnessType(IntEnum): + BYRON_WITNESS = 0 + SHELLEY_WITNESS = 1 + + class BackupType(IntEnum): Bip39 = 0 Slip39_Basic = 1 @@ -1919,6 +1951,397 @@ class CardanoPublicKey(protobuf.MessageType): self.node = node +class CardanoSignTxInit(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 320 + FIELDS = { + 1: protobuf.Field("signing_mode", "CardanoTxSigningMode", repeated=False, required=True), + 2: protobuf.Field("protocol_magic", "uint32", repeated=False, required=True), + 3: protobuf.Field("network_id", "uint32", repeated=False, required=True), + 4: protobuf.Field("inputs_count", "uint32", repeated=False, required=True), + 5: protobuf.Field("outputs_count", "uint32", repeated=False, required=True), + 6: protobuf.Field("fee", "uint64", repeated=False, required=True), + 7: protobuf.Field("ttl", "uint64", repeated=False, required=False), + 8: protobuf.Field("certificates_count", "uint32", repeated=False, required=True), + 9: protobuf.Field("withdrawals_count", "uint32", repeated=False, required=True), + 10: protobuf.Field("has_auxiliary_data", "bool", repeated=False, required=True), + 11: protobuf.Field("validity_interval_start", "uint64", repeated=False, required=False), + 12: protobuf.Field("witness_requests_count", "uint32", repeated=False, required=True), + } + + def __init__( + self, + *, + signing_mode: "CardanoTxSigningMode", + protocol_magic: "int", + network_id: "int", + inputs_count: "int", + outputs_count: "int", + fee: "int", + certificates_count: "int", + withdrawals_count: "int", + has_auxiliary_data: "bool", + witness_requests_count: "int", + ttl: Optional["int"] = None, + validity_interval_start: Optional["int"] = None, + ) -> None: + self.signing_mode = signing_mode + self.protocol_magic = protocol_magic + self.network_id = network_id + self.inputs_count = inputs_count + self.outputs_count = outputs_count + self.fee = fee + self.certificates_count = certificates_count + self.withdrawals_count = withdrawals_count + self.has_auxiliary_data = has_auxiliary_data + self.witness_requests_count = witness_requests_count + self.ttl = ttl + self.validity_interval_start = validity_interval_start + + +class CardanoTxInput(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 321 + FIELDS = { + 1: protobuf.Field("prev_hash", "bytes", repeated=False, required=True), + 2: protobuf.Field("prev_index", "uint32", repeated=False, required=True), + } + + def __init__( + self, + *, + prev_hash: "bytes", + prev_index: "int", + ) -> None: + self.prev_hash = prev_hash + self.prev_index = prev_index + + +class CardanoTxOutput(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 322 + FIELDS = { + 1: protobuf.Field("address", "string", repeated=False, required=False), + 2: protobuf.Field("address_parameters", "CardanoAddressParametersType", repeated=False, required=False), + 3: protobuf.Field("amount", "uint64", repeated=False, required=True), + 4: protobuf.Field("asset_groups_count", "uint32", repeated=False, required=True), + } + + def __init__( + self, + *, + amount: "int", + asset_groups_count: "int", + address: Optional["str"] = None, + address_parameters: Optional["CardanoAddressParametersType"] = None, + ) -> None: + self.amount = amount + self.asset_groups_count = asset_groups_count + self.address = address + self.address_parameters = address_parameters + + +class CardanoAssetGroup(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 323 + FIELDS = { + 1: protobuf.Field("policy_id", "bytes", repeated=False, required=True), + 2: protobuf.Field("tokens_count", "uint32", repeated=False, required=True), + } + + def __init__( + self, + *, + policy_id: "bytes", + tokens_count: "int", + ) -> None: + self.policy_id = policy_id + self.tokens_count = tokens_count + + +class CardanoToken(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 324 + FIELDS = { + 1: protobuf.Field("asset_name_bytes", "bytes", repeated=False, required=True), + 2: protobuf.Field("amount", "uint64", repeated=False, required=True), + } + + def __init__( + self, + *, + asset_name_bytes: "bytes", + amount: "int", + ) -> None: + self.asset_name_bytes = asset_name_bytes + self.amount = amount + + +class CardanoPoolOwner(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 328 + FIELDS = { + 1: protobuf.Field("staking_key_path", "uint32", repeated=True, required=False), + 2: protobuf.Field("staking_key_hash", "bytes", repeated=False, required=False), + } + + def __init__( + self, + *, + staking_key_path: Optional[List["int"]] = None, + staking_key_hash: Optional["bytes"] = None, + ) -> None: + self.staking_key_path = staking_key_path if staking_key_path is not None else [] + self.staking_key_hash = staking_key_hash + + +class CardanoPoolRelayParameters(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 329 + FIELDS = { + 1: protobuf.Field("type", "CardanoPoolRelayType", repeated=False, required=True), + 2: protobuf.Field("ipv4_address", "bytes", repeated=False, required=False), + 3: protobuf.Field("ipv6_address", "bytes", repeated=False, required=False), + 4: protobuf.Field("host_name", "string", repeated=False, required=False), + 5: protobuf.Field("port", "uint32", repeated=False, required=False), + } + + def __init__( + self, + *, + type: "CardanoPoolRelayType", + ipv4_address: Optional["bytes"] = None, + ipv6_address: Optional["bytes"] = None, + host_name: Optional["str"] = None, + port: Optional["int"] = None, + ) -> None: + self.type = type + self.ipv4_address = ipv4_address + self.ipv6_address = ipv6_address + self.host_name = host_name + self.port = port + + +class CardanoPoolMetadataType(protobuf.MessageType): + MESSAGE_WIRE_TYPE = None + FIELDS = { + 1: protobuf.Field("url", "string", repeated=False, required=True), + 2: protobuf.Field("hash", "bytes", repeated=False, required=True), + } + + def __init__( + self, + *, + url: "str", + hash: "bytes", + ) -> None: + self.url = url + self.hash = hash + + +class CardanoPoolParametersType(protobuf.MessageType): + MESSAGE_WIRE_TYPE = None + FIELDS = { + 1: protobuf.Field("pool_id", "bytes", repeated=False, required=True), + 2: protobuf.Field("vrf_key_hash", "bytes", repeated=False, required=True), + 3: protobuf.Field("pledge", "uint64", repeated=False, required=True), + 4: protobuf.Field("cost", "uint64", repeated=False, required=True), + 5: protobuf.Field("margin_numerator", "uint64", repeated=False, required=True), + 6: protobuf.Field("margin_denominator", "uint64", repeated=False, required=True), + 7: protobuf.Field("reward_account", "string", repeated=False, required=True), + 8: protobuf.Field("owners", "CardanoPoolOwner", repeated=True, required=False), + 9: protobuf.Field("relays", "CardanoPoolRelayParameters", repeated=True, required=False), + 10: protobuf.Field("metadata", "CardanoPoolMetadataType", repeated=False, required=False), + 11: protobuf.Field("owners_count", "uint32", repeated=False, required=True), + 12: protobuf.Field("relays_count", "uint32", repeated=False, required=True), + } + + def __init__( + self, + *, + pool_id: "bytes", + vrf_key_hash: "bytes", + pledge: "int", + cost: "int", + margin_numerator: "int", + margin_denominator: "int", + reward_account: "str", + owners_count: "int", + relays_count: "int", + owners: Optional[List["CardanoPoolOwner"]] = None, + relays: Optional[List["CardanoPoolRelayParameters"]] = None, + metadata: Optional["CardanoPoolMetadataType"] = None, + ) -> None: + self.owners = owners if owners is not None else [] + self.relays = relays if relays is not None else [] + self.pool_id = pool_id + self.vrf_key_hash = vrf_key_hash + self.pledge = pledge + self.cost = cost + self.margin_numerator = margin_numerator + self.margin_denominator = margin_denominator + self.reward_account = reward_account + self.owners_count = owners_count + self.relays_count = relays_count + self.metadata = metadata + + +class CardanoTxCertificate(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 325 + FIELDS = { + 1: protobuf.Field("type", "CardanoCertificateType", repeated=False, required=True), + 2: protobuf.Field("path", "uint32", repeated=True, required=False), + 3: protobuf.Field("pool", "bytes", repeated=False, required=False), + 4: protobuf.Field("pool_parameters", "CardanoPoolParametersType", repeated=False, required=False), + } + + def __init__( + self, + *, + type: "CardanoCertificateType", + path: Optional[List["int"]] = None, + pool: Optional["bytes"] = None, + pool_parameters: Optional["CardanoPoolParametersType"] = None, + ) -> None: + self.path = path if path is not None else [] + self.type = type + self.pool = pool + self.pool_parameters = pool_parameters + + +class CardanoTxWithdrawal(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 326 + FIELDS = { + 1: protobuf.Field("path", "uint32", repeated=True, required=False), + 2: protobuf.Field("amount", "uint64", repeated=False, required=True), + } + + def __init__( + self, + *, + amount: "int", + path: Optional[List["int"]] = None, + ) -> None: + self.path = path if path is not None else [] + self.amount = amount + + +class CardanoCatalystRegistrationParametersType(protobuf.MessageType): + MESSAGE_WIRE_TYPE = None + FIELDS = { + 1: protobuf.Field("voting_public_key", "bytes", repeated=False, required=True), + 2: protobuf.Field("staking_path", "uint32", repeated=True, required=False), + 3: protobuf.Field("reward_address_parameters", "CardanoAddressParametersType", repeated=False, required=True), + 4: protobuf.Field("nonce", "uint64", repeated=False, required=True), + } + + def __init__( + self, + *, + voting_public_key: "bytes", + reward_address_parameters: "CardanoAddressParametersType", + nonce: "int", + staking_path: Optional[List["int"]] = None, + ) -> None: + self.staking_path = staking_path if staking_path is not None else [] + self.voting_public_key = voting_public_key + self.reward_address_parameters = reward_address_parameters + self.nonce = nonce + + +class CardanoTxAuxiliaryData(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 327 + FIELDS = { + 1: protobuf.Field("catalyst_registration_parameters", "CardanoCatalystRegistrationParametersType", repeated=False, required=False), + 2: protobuf.Field("hash", "bytes", repeated=False, required=False), + } + + def __init__( + self, + *, + catalyst_registration_parameters: Optional["CardanoCatalystRegistrationParametersType"] = None, + hash: Optional["bytes"] = None, + ) -> None: + self.catalyst_registration_parameters = catalyst_registration_parameters + self.hash = hash + + +class CardanoTxItemAck(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 313 + + +class CardanoTxAuxiliaryDataSupplement(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 314 + FIELDS = { + 1: protobuf.Field("type", "CardanoTxAuxiliaryDataSupplementType", repeated=False, required=True), + 2: protobuf.Field("auxiliary_data_hash", "bytes", repeated=False, required=False), + 3: protobuf.Field("catalyst_signature", "bytes", repeated=False, required=False), + } + + def __init__( + self, + *, + type: "CardanoTxAuxiliaryDataSupplementType", + auxiliary_data_hash: Optional["bytes"] = None, + catalyst_signature: Optional["bytes"] = None, + ) -> None: + self.type = type + self.auxiliary_data_hash = auxiliary_data_hash + self.catalyst_signature = catalyst_signature + + +class CardanoTxWitnessRequest(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 315 + FIELDS = { + 1: protobuf.Field("path", "uint32", repeated=True, required=False), + } + + def __init__( + self, + *, + path: Optional[List["int"]] = None, + ) -> None: + self.path = path if path is not None else [] + + +class CardanoTxWitnessResponse(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 316 + FIELDS = { + 1: protobuf.Field("type", "CardanoTxWitnessType", repeated=False, required=True), + 2: protobuf.Field("pub_key", "bytes", repeated=False, required=True), + 3: protobuf.Field("signature", "bytes", repeated=False, required=True), + 4: protobuf.Field("chain_code", "bytes", repeated=False, required=False), + } + + def __init__( + self, + *, + type: "CardanoTxWitnessType", + pub_key: "bytes", + signature: "bytes", + chain_code: Optional["bytes"] = None, + ) -> None: + self.type = type + self.pub_key = pub_key + self.signature = signature + self.chain_code = chain_code + + +class CardanoTxHostAck(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 317 + + +class CardanoTxBodyHash(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 318 + FIELDS = { + 1: protobuf.Field("tx_hash", "bytes", repeated=False, required=True), + } + + def __init__( + self, + *, + tx_hash: "bytes", + ) -> None: + self.tx_hash = tx_hash + + +class CardanoSignTxFinished(protobuf.MessageType): + MESSAGE_WIRE_TYPE = 319 + + class CardanoSignTx(protobuf.MessageType): MESSAGE_WIRE_TYPE = 303 FIELDS = { @@ -2115,64 +2538,6 @@ class CardanoPoolRelayParametersType(protobuf.MessageType): self.port = port -class CardanoPoolMetadataType(protobuf.MessageType): - MESSAGE_WIRE_TYPE = None - FIELDS = { - 1: protobuf.Field("url", "string", repeated=False, required=True), - 2: protobuf.Field("hash", "bytes", repeated=False, required=True), - } - - def __init__( - self, - *, - url: "str", - hash: "bytes", - ) -> None: - self.url = url - self.hash = hash - - -class CardanoPoolParametersType(protobuf.MessageType): - MESSAGE_WIRE_TYPE = None - FIELDS = { - 1: protobuf.Field("pool_id", "bytes", repeated=False, required=True), - 2: protobuf.Field("vrf_key_hash", "bytes", repeated=False, required=True), - 3: protobuf.Field("pledge", "uint64", repeated=False, required=True), - 4: protobuf.Field("cost", "uint64", repeated=False, required=True), - 5: protobuf.Field("margin_numerator", "uint64", repeated=False, required=True), - 6: protobuf.Field("margin_denominator", "uint64", repeated=False, required=True), - 7: protobuf.Field("reward_account", "string", repeated=False, required=True), - 8: protobuf.Field("owners", "CardanoPoolOwnerType", repeated=True, required=False), - 9: protobuf.Field("relays", "CardanoPoolRelayParametersType", repeated=True, required=False), - 10: protobuf.Field("metadata", "CardanoPoolMetadataType", repeated=False, required=False), - } - - def __init__( - self, - *, - pool_id: "bytes", - vrf_key_hash: "bytes", - pledge: "int", - cost: "int", - margin_numerator: "int", - margin_denominator: "int", - reward_account: "str", - owners: Optional[List["CardanoPoolOwnerType"]] = None, - relays: Optional[List["CardanoPoolRelayParametersType"]] = None, - metadata: Optional["CardanoPoolMetadataType"] = None, - ) -> None: - self.owners = owners if owners is not None else [] - self.relays = relays if relays is not None else [] - self.pool_id = pool_id - self.vrf_key_hash = vrf_key_hash - self.pledge = pledge - self.cost = cost - self.margin_numerator = margin_numerator - self.margin_denominator = margin_denominator - self.reward_account = reward_account - self.metadata = metadata - - class CardanoTxCertificateType(protobuf.MessageType): MESSAGE_WIRE_TYPE = None FIELDS = { @@ -2213,29 +2578,6 @@ class CardanoTxWithdrawalType(protobuf.MessageType): self.amount = amount -class CardanoCatalystRegistrationParametersType(protobuf.MessageType): - MESSAGE_WIRE_TYPE = None - FIELDS = { - 1: protobuf.Field("voting_public_key", "bytes", repeated=False, required=True), - 2: protobuf.Field("staking_path", "uint32", repeated=True, required=False), - 3: protobuf.Field("reward_address_parameters", "CardanoAddressParametersType", repeated=False, required=True), - 4: protobuf.Field("nonce", "uint64", repeated=False, required=True), - } - - def __init__( - self, - *, - voting_public_key: "bytes", - reward_address_parameters: "CardanoAddressParametersType", - nonce: "int", - staking_path: Optional[List["int"]] = None, - ) -> None: - self.staking_path = staking_path if staking_path is not None else [] - self.voting_public_key = voting_public_key - self.reward_address_parameters = reward_address_parameters - self.nonce = nonce - - class CardanoTxAuxiliaryDataType(protobuf.MessageType): MESSAGE_WIRE_TYPE = None FIELDS = {