// This file is generated by rust-protobuf 3.3.0. Do not edit // .proto file is parsed by protoc 3.19.6 // @generated // https://github.com/rust-lang/rust-clippy/issues/702 #![allow(unknown_lints)] #![allow(clippy::all)] #![allow(unused_attributes)] #![cfg_attr(rustfmt, rustfmt::skip)] #![allow(box_pointers)] #![allow(dead_code)] #![allow(missing_docs)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(non_upper_case_globals)] #![allow(trivial_casts)] #![allow(unused_results)] #![allow(unused_mut)] //! Generated file from `messages-nem.proto` /// Generated files are compatible only with the same version /// of protobuf runtime. const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_3_0; // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMGetAddress) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMGetAddress { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMGetAddress.address_n) pub address_n: ::std::vec::Vec, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMGetAddress.network) pub network: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMGetAddress.show_display) pub show_display: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMGetAddress.chunkify) pub chunkify: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMGetAddress.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMGetAddress { fn default() -> &'a NEMGetAddress { ::default_instance() } } impl NEMGetAddress { pub fn new() -> NEMGetAddress { ::std::default::Default::default() } // optional uint32 network = 2; pub fn network(&self) -> u32 { self.network.unwrap_or(104u32) } pub fn clear_network(&mut self) { self.network = ::std::option::Option::None; } pub fn has_network(&self) -> bool { self.network.is_some() } // Param is passed by value, moved pub fn set_network(&mut self, v: u32) { self.network = ::std::option::Option::Some(v); } // optional bool show_display = 3; pub fn show_display(&self) -> bool { self.show_display.unwrap_or(false) } pub fn clear_show_display(&mut self) { self.show_display = ::std::option::Option::None; } pub fn has_show_display(&self) -> bool { self.show_display.is_some() } // Param is passed by value, moved pub fn set_show_display(&mut self, v: bool) { self.show_display = ::std::option::Option::Some(v); } // optional bool chunkify = 4; pub fn chunkify(&self) -> bool { self.chunkify.unwrap_or(false) } pub fn clear_chunkify(&mut self) { self.chunkify = ::std::option::Option::None; } pub fn has_chunkify(&self) -> bool { self.chunkify.is_some() } // Param is passed by value, moved pub fn set_chunkify(&mut self, v: bool) { self.chunkify = ::std::option::Option::Some(v); } fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(4); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "address_n", |m: &NEMGetAddress| { &m.address_n }, |m: &mut NEMGetAddress| { &mut m.address_n }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "network", |m: &NEMGetAddress| { &m.network }, |m: &mut NEMGetAddress| { &mut m.network }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "show_display", |m: &NEMGetAddress| { &m.show_display }, |m: &mut NEMGetAddress| { &mut m.show_display }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "chunkify", |m: &NEMGetAddress| { &m.chunkify }, |m: &mut NEMGetAddress| { &mut m.chunkify }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMGetAddress", fields, oneofs, ) } } impl ::protobuf::Message for NEMGetAddress { const NAME: &'static str = "NEMGetAddress"; fn is_initialized(&self) -> bool { true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { is.read_repeated_packed_uint32_into(&mut self.address_n)?; }, 8 => { self.address_n.push(is.read_uint32()?); }, 16 => { self.network = ::std::option::Option::Some(is.read_uint32()?); }, 24 => { self.show_display = ::std::option::Option::Some(is.read_bool()?); }, 32 => { self.chunkify = ::std::option::Option::Some(is.read_bool()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; for value in &self.address_n { my_size += ::protobuf::rt::uint32_size(1, *value); }; if let Some(v) = self.network { my_size += ::protobuf::rt::uint32_size(2, v); } if let Some(v) = self.show_display { my_size += 1 + 1; } if let Some(v) = self.chunkify { my_size += 1 + 1; } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { for v in &self.address_n { os.write_uint32(1, *v)?; }; if let Some(v) = self.network { os.write_uint32(2, v)?; } if let Some(v) = self.show_display { os.write_bool(3, v)?; } if let Some(v) = self.chunkify { os.write_bool(4, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMGetAddress { NEMGetAddress::new() } fn clear(&mut self) { self.address_n.clear(); self.network = ::std::option::Option::None; self.show_display = ::std::option::Option::None; self.chunkify = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMGetAddress { static instance: NEMGetAddress = NEMGetAddress { address_n: ::std::vec::Vec::new(), network: ::std::option::Option::None, show_display: ::std::option::Option::None, chunkify: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMGetAddress { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("NEMGetAddress").unwrap()).clone() } } impl ::std::fmt::Display for NEMGetAddress { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMGetAddress { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMAddress) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMAddress { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMAddress.address) pub address: ::std::option::Option<::std::string::String>, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMAddress.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMAddress { fn default() -> &'a NEMAddress { ::default_instance() } } impl NEMAddress { pub fn new() -> NEMAddress { ::std::default::Default::default() } // required string address = 1; pub fn address(&self) -> &str { match self.address.as_ref() { Some(v) => v, None => "", } } pub fn clear_address(&mut self) { self.address = ::std::option::Option::None; } pub fn has_address(&self) -> bool { self.address.is_some() } // Param is passed by value, moved pub fn set_address(&mut self, v: ::std::string::String) { self.address = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_address(&mut self) -> &mut ::std::string::String { if self.address.is_none() { self.address = ::std::option::Option::Some(::std::string::String::new()); } self.address.as_mut().unwrap() } // Take field pub fn take_address(&mut self) -> ::std::string::String { self.address.take().unwrap_or_else(|| ::std::string::String::new()) } fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(1); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "address", |m: &NEMAddress| { &m.address }, |m: &mut NEMAddress| { &mut m.address }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMAddress", fields, oneofs, ) } } impl ::protobuf::Message for NEMAddress { const NAME: &'static str = "NEMAddress"; fn is_initialized(&self) -> bool { if self.address.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.address = ::std::option::Option::Some(is.read_string()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.address.as_ref() { my_size += ::protobuf::rt::string_size(1, &v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.address.as_ref() { os.write_string(1, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMAddress { NEMAddress::new() } fn clear(&mut self) { self.address = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMAddress { static instance: NEMAddress = NEMAddress { address: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMAddress { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("NEMAddress").unwrap()).clone() } } impl ::std::fmt::Display for NEMAddress { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMAddress { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMSignTx { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.transaction) pub transaction: ::protobuf::MessageField, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.multisig) pub multisig: ::protobuf::MessageField, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.transfer) pub transfer: ::protobuf::MessageField, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.cosigning) pub cosigning: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.provision_namespace) pub provision_namespace: ::protobuf::MessageField, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.mosaic_creation) pub mosaic_creation: ::protobuf::MessageField, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.supply_change) pub supply_change: ::protobuf::MessageField, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.aggregate_modification) pub aggregate_modification: ::protobuf::MessageField, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.importance_transfer) pub importance_transfer: ::protobuf::MessageField, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.chunkify) pub chunkify: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMSignTx { fn default() -> &'a NEMSignTx { ::default_instance() } } impl NEMSignTx { pub fn new() -> NEMSignTx { ::std::default::Default::default() } // optional bool cosigning = 4; pub fn cosigning(&self) -> bool { self.cosigning.unwrap_or(false) } pub fn clear_cosigning(&mut self) { self.cosigning = ::std::option::Option::None; } pub fn has_cosigning(&self) -> bool { self.cosigning.is_some() } // Param is passed by value, moved pub fn set_cosigning(&mut self, v: bool) { self.cosigning = ::std::option::Option::Some(v); } // optional bool chunkify = 10; pub fn chunkify(&self) -> bool { self.chunkify.unwrap_or(false) } pub fn clear_chunkify(&mut self) { self.chunkify = ::std::option::Option::None; } pub fn has_chunkify(&self) -> bool { self.chunkify.is_some() } // Param is passed by value, moved pub fn set_chunkify(&mut self, v: bool) { self.chunkify = ::std::option::Option::Some(v); } fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(10); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, nemsign_tx::NEMTransactionCommon>( "transaction", |m: &NEMSignTx| { &m.transaction }, |m: &mut NEMSignTx| { &mut m.transaction }, )); fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, nemsign_tx::NEMTransactionCommon>( "multisig", |m: &NEMSignTx| { &m.multisig }, |m: &mut NEMSignTx| { &mut m.multisig }, )); fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, nemsign_tx::NEMTransfer>( "transfer", |m: &NEMSignTx| { &m.transfer }, |m: &mut NEMSignTx| { &mut m.transfer }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "cosigning", |m: &NEMSignTx| { &m.cosigning }, |m: &mut NEMSignTx| { &mut m.cosigning }, )); fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, nemsign_tx::NEMProvisionNamespace>( "provision_namespace", |m: &NEMSignTx| { &m.provision_namespace }, |m: &mut NEMSignTx| { &mut m.provision_namespace }, )); fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, nemsign_tx::NEMMosaicCreation>( "mosaic_creation", |m: &NEMSignTx| { &m.mosaic_creation }, |m: &mut NEMSignTx| { &mut m.mosaic_creation }, )); fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, nemsign_tx::NEMMosaicSupplyChange>( "supply_change", |m: &NEMSignTx| { &m.supply_change }, |m: &mut NEMSignTx| { &mut m.supply_change }, )); fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, nemsign_tx::NEMAggregateModification>( "aggregate_modification", |m: &NEMSignTx| { &m.aggregate_modification }, |m: &mut NEMSignTx| { &mut m.aggregate_modification }, )); fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, nemsign_tx::NEMImportanceTransfer>( "importance_transfer", |m: &NEMSignTx| { &m.importance_transfer }, |m: &mut NEMSignTx| { &mut m.importance_transfer }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "chunkify", |m: &NEMSignTx| { &m.chunkify }, |m: &mut NEMSignTx| { &mut m.chunkify }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx", fields, oneofs, ) } } impl ::protobuf::Message for NEMSignTx { const NAME: &'static str = "NEMSignTx"; fn is_initialized(&self) -> bool { if self.transaction.is_none() { return false; } for v in &self.transaction { if !v.is_initialized() { return false; } }; for v in &self.multisig { if !v.is_initialized() { return false; } }; for v in &self.transfer { if !v.is_initialized() { return false; } }; for v in &self.provision_namespace { if !v.is_initialized() { return false; } }; for v in &self.mosaic_creation { if !v.is_initialized() { return false; } }; for v in &self.supply_change { if !v.is_initialized() { return false; } }; for v in &self.aggregate_modification { if !v.is_initialized() { return false; } }; for v in &self.importance_transfer { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { ::protobuf::rt::read_singular_message_into_field(is, &mut self.transaction)?; }, 18 => { ::protobuf::rt::read_singular_message_into_field(is, &mut self.multisig)?; }, 26 => { ::protobuf::rt::read_singular_message_into_field(is, &mut self.transfer)?; }, 32 => { self.cosigning = ::std::option::Option::Some(is.read_bool()?); }, 42 => { ::protobuf::rt::read_singular_message_into_field(is, &mut self.provision_namespace)?; }, 50 => { ::protobuf::rt::read_singular_message_into_field(is, &mut self.mosaic_creation)?; }, 58 => { ::protobuf::rt::read_singular_message_into_field(is, &mut self.supply_change)?; }, 66 => { ::protobuf::rt::read_singular_message_into_field(is, &mut self.aggregate_modification)?; }, 74 => { ::protobuf::rt::read_singular_message_into_field(is, &mut self.importance_transfer)?; }, 80 => { self.chunkify = ::std::option::Option::Some(is.read_bool()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.transaction.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.multisig.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.transfer.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.cosigning { my_size += 1 + 1; } if let Some(v) = self.provision_namespace.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.mosaic_creation.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.supply_change.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.aggregate_modification.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.importance_transfer.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.chunkify { my_size += 1 + 1; } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.transaction.as_ref() { ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?; } if let Some(v) = self.multisig.as_ref() { ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?; } if let Some(v) = self.transfer.as_ref() { ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?; } if let Some(v) = self.cosigning { os.write_bool(4, v)?; } if let Some(v) = self.provision_namespace.as_ref() { ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?; } if let Some(v) = self.mosaic_creation.as_ref() { ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?; } if let Some(v) = self.supply_change.as_ref() { ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?; } if let Some(v) = self.aggregate_modification.as_ref() { ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?; } if let Some(v) = self.importance_transfer.as_ref() { ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?; } if let Some(v) = self.chunkify { os.write_bool(10, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMSignTx { NEMSignTx::new() } fn clear(&mut self) { self.transaction.clear(); self.multisig.clear(); self.transfer.clear(); self.cosigning = ::std::option::Option::None; self.provision_namespace.clear(); self.mosaic_creation.clear(); self.supply_change.clear(); self.aggregate_modification.clear(); self.importance_transfer.clear(); self.chunkify = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMSignTx { static instance: NEMSignTx = NEMSignTx { transaction: ::protobuf::MessageField::none(), multisig: ::protobuf::MessageField::none(), transfer: ::protobuf::MessageField::none(), cosigning: ::std::option::Option::None, provision_namespace: ::protobuf::MessageField::none(), mosaic_creation: ::protobuf::MessageField::none(), supply_change: ::protobuf::MessageField::none(), aggregate_modification: ::protobuf::MessageField::none(), importance_transfer: ::protobuf::MessageField::none(), chunkify: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMSignTx { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("NEMSignTx").unwrap()).clone() } } impl ::std::fmt::Display for NEMSignTx { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMSignTx { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `NEMSignTx` pub mod nemsign_tx { // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx.NEMTransactionCommon) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMTransactionCommon { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransactionCommon.address_n) pub address_n: ::std::vec::Vec, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransactionCommon.network) pub network: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransactionCommon.timestamp) pub timestamp: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransactionCommon.fee) pub fee: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransactionCommon.deadline) pub deadline: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransactionCommon.signer) pub signer: ::std::option::Option<::std::vec::Vec>, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.NEMTransactionCommon.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMTransactionCommon { fn default() -> &'a NEMTransactionCommon { ::default_instance() } } impl NEMTransactionCommon { pub fn new() -> NEMTransactionCommon { ::std::default::Default::default() } // optional uint32 network = 2; pub fn network(&self) -> u32 { self.network.unwrap_or(104u32) } pub fn clear_network(&mut self) { self.network = ::std::option::Option::None; } pub fn has_network(&self) -> bool { self.network.is_some() } // Param is passed by value, moved pub fn set_network(&mut self, v: u32) { self.network = ::std::option::Option::Some(v); } // required uint32 timestamp = 3; pub fn timestamp(&self) -> u32 { self.timestamp.unwrap_or(0) } pub fn clear_timestamp(&mut self) { self.timestamp = ::std::option::Option::None; } pub fn has_timestamp(&self) -> bool { self.timestamp.is_some() } // Param is passed by value, moved pub fn set_timestamp(&mut self, v: u32) { self.timestamp = ::std::option::Option::Some(v); } // required uint64 fee = 4; pub fn fee(&self) -> u64 { self.fee.unwrap_or(0) } pub fn clear_fee(&mut self) { self.fee = ::std::option::Option::None; } pub fn has_fee(&self) -> bool { self.fee.is_some() } // Param is passed by value, moved pub fn set_fee(&mut self, v: u64) { self.fee = ::std::option::Option::Some(v); } // required uint32 deadline = 5; pub fn deadline(&self) -> u32 { self.deadline.unwrap_or(0) } pub fn clear_deadline(&mut self) { self.deadline = ::std::option::Option::None; } pub fn has_deadline(&self) -> bool { self.deadline.is_some() } // Param is passed by value, moved pub fn set_deadline(&mut self, v: u32) { self.deadline = ::std::option::Option::Some(v); } // optional bytes signer = 6; pub fn signer(&self) -> &[u8] { match self.signer.as_ref() { Some(v) => v, None => &[], } } pub fn clear_signer(&mut self) { self.signer = ::std::option::Option::None; } pub fn has_signer(&self) -> bool { self.signer.is_some() } // Param is passed by value, moved pub fn set_signer(&mut self, v: ::std::vec::Vec) { self.signer = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_signer(&mut self) -> &mut ::std::vec::Vec { if self.signer.is_none() { self.signer = ::std::option::Option::Some(::std::vec::Vec::new()); } self.signer.as_mut().unwrap() } // Take field pub fn take_signer(&mut self) -> ::std::vec::Vec { self.signer.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(6); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "address_n", |m: &NEMTransactionCommon| { &m.address_n }, |m: &mut NEMTransactionCommon| { &mut m.address_n }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "network", |m: &NEMTransactionCommon| { &m.network }, |m: &mut NEMTransactionCommon| { &mut m.network }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "timestamp", |m: &NEMTransactionCommon| { &m.timestamp }, |m: &mut NEMTransactionCommon| { &mut m.timestamp }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "fee", |m: &NEMTransactionCommon| { &m.fee }, |m: &mut NEMTransactionCommon| { &mut m.fee }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "deadline", |m: &NEMTransactionCommon| { &m.deadline }, |m: &mut NEMTransactionCommon| { &mut m.deadline }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "signer", |m: &NEMTransactionCommon| { &m.signer }, |m: &mut NEMTransactionCommon| { &mut m.signer }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx.NEMTransactionCommon", fields, oneofs, ) } } impl ::protobuf::Message for NEMTransactionCommon { const NAME: &'static str = "NEMTransactionCommon"; fn is_initialized(&self) -> bool { if self.timestamp.is_none() { return false; } if self.fee.is_none() { return false; } if self.deadline.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { is.read_repeated_packed_uint32_into(&mut self.address_n)?; }, 8 => { self.address_n.push(is.read_uint32()?); }, 16 => { self.network = ::std::option::Option::Some(is.read_uint32()?); }, 24 => { self.timestamp = ::std::option::Option::Some(is.read_uint32()?); }, 32 => { self.fee = ::std::option::Option::Some(is.read_uint64()?); }, 40 => { self.deadline = ::std::option::Option::Some(is.read_uint32()?); }, 50 => { self.signer = ::std::option::Option::Some(is.read_bytes()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; for value in &self.address_n { my_size += ::protobuf::rt::uint32_size(1, *value); }; if let Some(v) = self.network { my_size += ::protobuf::rt::uint32_size(2, v); } if let Some(v) = self.timestamp { my_size += ::protobuf::rt::uint32_size(3, v); } if let Some(v) = self.fee { my_size += ::protobuf::rt::uint64_size(4, v); } if let Some(v) = self.deadline { my_size += ::protobuf::rt::uint32_size(5, v); } if let Some(v) = self.signer.as_ref() { my_size += ::protobuf::rt::bytes_size(6, &v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { for v in &self.address_n { os.write_uint32(1, *v)?; }; if let Some(v) = self.network { os.write_uint32(2, v)?; } if let Some(v) = self.timestamp { os.write_uint32(3, v)?; } if let Some(v) = self.fee { os.write_uint64(4, v)?; } if let Some(v) = self.deadline { os.write_uint32(5, v)?; } if let Some(v) = self.signer.as_ref() { os.write_bytes(6, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMTransactionCommon { NEMTransactionCommon::new() } fn clear(&mut self) { self.address_n.clear(); self.network = ::std::option::Option::None; self.timestamp = ::std::option::Option::None; self.fee = ::std::option::Option::None; self.deadline = ::std::option::Option::None; self.signer = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMTransactionCommon { static instance: NEMTransactionCommon = NEMTransactionCommon { address_n: ::std::vec::Vec::new(), network: ::std::option::Option::None, timestamp: ::std::option::Option::None, fee: ::std::option::Option::None, deadline: ::std::option::Option::None, signer: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMTransactionCommon { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("NEMSignTx.NEMTransactionCommon").unwrap()).clone() } } impl ::std::fmt::Display for NEMTransactionCommon { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMTransactionCommon { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx.NEMTransfer) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMTransfer { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.recipient) pub recipient: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.amount) pub amount: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.payload) pub payload: ::std::option::Option<::std::vec::Vec>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.public_key) pub public_key: ::std::option::Option<::std::vec::Vec>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.mosaics) pub mosaics: ::std::vec::Vec, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMTransfer { fn default() -> &'a NEMTransfer { ::default_instance() } } impl NEMTransfer { pub fn new() -> NEMTransfer { ::std::default::Default::default() } // required string recipient = 1; pub fn recipient(&self) -> &str { match self.recipient.as_ref() { Some(v) => v, None => "", } } pub fn clear_recipient(&mut self) { self.recipient = ::std::option::Option::None; } pub fn has_recipient(&self) -> bool { self.recipient.is_some() } // Param is passed by value, moved pub fn set_recipient(&mut self, v: ::std::string::String) { self.recipient = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_recipient(&mut self) -> &mut ::std::string::String { if self.recipient.is_none() { self.recipient = ::std::option::Option::Some(::std::string::String::new()); } self.recipient.as_mut().unwrap() } // Take field pub fn take_recipient(&mut self) -> ::std::string::String { self.recipient.take().unwrap_or_else(|| ::std::string::String::new()) } // required uint64 amount = 2; pub fn amount(&self) -> u64 { self.amount.unwrap_or(0) } pub fn clear_amount(&mut self) { self.amount = ::std::option::Option::None; } pub fn has_amount(&self) -> bool { self.amount.is_some() } // Param is passed by value, moved pub fn set_amount(&mut self, v: u64) { self.amount = ::std::option::Option::Some(v); } // optional bytes payload = 3; pub fn payload(&self) -> &[u8] { match self.payload.as_ref() { Some(v) => v, None => &[], } } pub fn clear_payload(&mut self) { self.payload = ::std::option::Option::None; } pub fn has_payload(&self) -> bool { self.payload.is_some() } // Param is passed by value, moved pub fn set_payload(&mut self, v: ::std::vec::Vec) { self.payload = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec { if self.payload.is_none() { self.payload = ::std::option::Option::Some(::std::vec::Vec::new()); } self.payload.as_mut().unwrap() } // Take field pub fn take_payload(&mut self) -> ::std::vec::Vec { self.payload.take().unwrap_or_else(|| ::std::vec::Vec::new()) } // optional bytes public_key = 4; pub fn public_key(&self) -> &[u8] { match self.public_key.as_ref() { Some(v) => v, None => &[], } } pub fn clear_public_key(&mut self) { self.public_key = ::std::option::Option::None; } pub fn has_public_key(&self) -> bool { self.public_key.is_some() } // Param is passed by value, moved pub fn set_public_key(&mut self, v: ::std::vec::Vec) { self.public_key = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec { if self.public_key.is_none() { self.public_key = ::std::option::Option::Some(::std::vec::Vec::new()); } self.public_key.as_mut().unwrap() } // Take field pub fn take_public_key(&mut self) -> ::std::vec::Vec { self.public_key.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(5); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "recipient", |m: &NEMTransfer| { &m.recipient }, |m: &mut NEMTransfer| { &mut m.recipient }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "amount", |m: &NEMTransfer| { &m.amount }, |m: &mut NEMTransfer| { &mut m.amount }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "payload", |m: &NEMTransfer| { &m.payload }, |m: &mut NEMTransfer| { &mut m.payload }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "public_key", |m: &NEMTransfer| { &m.public_key }, |m: &mut NEMTransfer| { &mut m.public_key }, )); fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "mosaics", |m: &NEMTransfer| { &m.mosaics }, |m: &mut NEMTransfer| { &mut m.mosaics }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx.NEMTransfer", fields, oneofs, ) } } impl ::protobuf::Message for NEMTransfer { const NAME: &'static str = "NEMTransfer"; fn is_initialized(&self) -> bool { if self.recipient.is_none() { return false; } if self.amount.is_none() { return false; } for v in &self.mosaics { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.recipient = ::std::option::Option::Some(is.read_string()?); }, 16 => { self.amount = ::std::option::Option::Some(is.read_uint64()?); }, 26 => { self.payload = ::std::option::Option::Some(is.read_bytes()?); }, 34 => { self.public_key = ::std::option::Option::Some(is.read_bytes()?); }, 42 => { self.mosaics.push(is.read_message()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.recipient.as_ref() { my_size += ::protobuf::rt::string_size(1, &v); } if let Some(v) = self.amount { my_size += ::protobuf::rt::uint64_size(2, v); } if let Some(v) = self.payload.as_ref() { my_size += ::protobuf::rt::bytes_size(3, &v); } if let Some(v) = self.public_key.as_ref() { my_size += ::protobuf::rt::bytes_size(4, &v); } for value in &self.mosaics { let len = value.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; }; my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.recipient.as_ref() { os.write_string(1, v)?; } if let Some(v) = self.amount { os.write_uint64(2, v)?; } if let Some(v) = self.payload.as_ref() { os.write_bytes(3, v)?; } if let Some(v) = self.public_key.as_ref() { os.write_bytes(4, v)?; } for v in &self.mosaics { ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?; }; os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMTransfer { NEMTransfer::new() } fn clear(&mut self) { self.recipient = ::std::option::Option::None; self.amount = ::std::option::Option::None; self.payload = ::std::option::Option::None; self.public_key = ::std::option::Option::None; self.mosaics.clear(); self.special_fields.clear(); } fn default_instance() -> &'static NEMTransfer { static instance: NEMTransfer = NEMTransfer { recipient: ::std::option::Option::None, amount: ::std::option::Option::None, payload: ::std::option::Option::None, public_key: ::std::option::Option::None, mosaics: ::std::vec::Vec::new(), special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMTransfer { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("NEMSignTx.NEMTransfer").unwrap()).clone() } } impl ::std::fmt::Display for NEMTransfer { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMTransfer { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `NEMTransfer` pub mod nemtransfer { // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.NEMMosaic) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMMosaic { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.NEMMosaic.namespace) pub namespace: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.NEMMosaic.mosaic) pub mosaic: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.NEMMosaic.quantity) pub quantity: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.NEMTransfer.NEMMosaic.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMMosaic { fn default() -> &'a NEMMosaic { ::default_instance() } } impl NEMMosaic { pub fn new() -> NEMMosaic { ::std::default::Default::default() } // required string namespace = 1; pub fn namespace(&self) -> &str { match self.namespace.as_ref() { Some(v) => v, None => "", } } pub fn clear_namespace(&mut self) { self.namespace = ::std::option::Option::None; } pub fn has_namespace(&self) -> bool { self.namespace.is_some() } // Param is passed by value, moved pub fn set_namespace(&mut self, v: ::std::string::String) { self.namespace = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_namespace(&mut self) -> &mut ::std::string::String { if self.namespace.is_none() { self.namespace = ::std::option::Option::Some(::std::string::String::new()); } self.namespace.as_mut().unwrap() } // Take field pub fn take_namespace(&mut self) -> ::std::string::String { self.namespace.take().unwrap_or_else(|| ::std::string::String::new()) } // required string mosaic = 2; pub fn mosaic(&self) -> &str { match self.mosaic.as_ref() { Some(v) => v, None => "", } } pub fn clear_mosaic(&mut self) { self.mosaic = ::std::option::Option::None; } pub fn has_mosaic(&self) -> bool { self.mosaic.is_some() } // Param is passed by value, moved pub fn set_mosaic(&mut self, v: ::std::string::String) { self.mosaic = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_mosaic(&mut self) -> &mut ::std::string::String { if self.mosaic.is_none() { self.mosaic = ::std::option::Option::Some(::std::string::String::new()); } self.mosaic.as_mut().unwrap() } // Take field pub fn take_mosaic(&mut self) -> ::std::string::String { self.mosaic.take().unwrap_or_else(|| ::std::string::String::new()) } // required uint64 quantity = 3; pub fn quantity(&self) -> u64 { self.quantity.unwrap_or(0) } pub fn clear_quantity(&mut self) { self.quantity = ::std::option::Option::None; } pub fn has_quantity(&self) -> bool { self.quantity.is_some() } // Param is passed by value, moved pub fn set_quantity(&mut self, v: u64) { self.quantity = ::std::option::Option::Some(v); } pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(3); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "namespace", |m: &NEMMosaic| { &m.namespace }, |m: &mut NEMMosaic| { &mut m.namespace }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "mosaic", |m: &NEMMosaic| { &m.mosaic }, |m: &mut NEMMosaic| { &mut m.mosaic }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "quantity", |m: &NEMMosaic| { &m.quantity }, |m: &mut NEMMosaic| { &mut m.quantity }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx.NEMTransfer.NEMMosaic", fields, oneofs, ) } } impl ::protobuf::Message for NEMMosaic { const NAME: &'static str = "NEMMosaic"; fn is_initialized(&self) -> bool { if self.namespace.is_none() { return false; } if self.mosaic.is_none() { return false; } if self.quantity.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.namespace = ::std::option::Option::Some(is.read_string()?); }, 18 => { self.mosaic = ::std::option::Option::Some(is.read_string()?); }, 24 => { self.quantity = ::std::option::Option::Some(is.read_uint64()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.namespace.as_ref() { my_size += ::protobuf::rt::string_size(1, &v); } if let Some(v) = self.mosaic.as_ref() { my_size += ::protobuf::rt::string_size(2, &v); } if let Some(v) = self.quantity { my_size += ::protobuf::rt::uint64_size(3, v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.namespace.as_ref() { os.write_string(1, v)?; } if let Some(v) = self.mosaic.as_ref() { os.write_string(2, v)?; } if let Some(v) = self.quantity { os.write_uint64(3, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMMosaic { NEMMosaic::new() } fn clear(&mut self) { self.namespace = ::std::option::Option::None; self.mosaic = ::std::option::Option::None; self.quantity = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMMosaic { static instance: NEMMosaic = NEMMosaic { namespace: ::std::option::Option::None, mosaic: ::std::option::Option::None, quantity: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMMosaic { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("NEMSignTx.NEMTransfer.NEMMosaic").unwrap()).clone() } } impl ::std::fmt::Display for NEMMosaic { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMMosaic { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx.NEMProvisionNamespace) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMProvisionNamespace { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMProvisionNamespace.namespace) pub namespace: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMProvisionNamespace.parent) pub parent: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMProvisionNamespace.sink) pub sink: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMProvisionNamespace.fee) pub fee: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.NEMProvisionNamespace.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMProvisionNamespace { fn default() -> &'a NEMProvisionNamespace { ::default_instance() } } impl NEMProvisionNamespace { pub fn new() -> NEMProvisionNamespace { ::std::default::Default::default() } // required string namespace = 1; pub fn namespace(&self) -> &str { match self.namespace.as_ref() { Some(v) => v, None => "", } } pub fn clear_namespace(&mut self) { self.namespace = ::std::option::Option::None; } pub fn has_namespace(&self) -> bool { self.namespace.is_some() } // Param is passed by value, moved pub fn set_namespace(&mut self, v: ::std::string::String) { self.namespace = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_namespace(&mut self) -> &mut ::std::string::String { if self.namespace.is_none() { self.namespace = ::std::option::Option::Some(::std::string::String::new()); } self.namespace.as_mut().unwrap() } // Take field pub fn take_namespace(&mut self) -> ::std::string::String { self.namespace.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string parent = 2; pub fn parent(&self) -> &str { match self.parent.as_ref() { Some(v) => v, None => "", } } pub fn clear_parent(&mut self) { self.parent = ::std::option::Option::None; } pub fn has_parent(&self) -> bool { self.parent.is_some() } // Param is passed by value, moved pub fn set_parent(&mut self, v: ::std::string::String) { self.parent = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_parent(&mut self) -> &mut ::std::string::String { if self.parent.is_none() { self.parent = ::std::option::Option::Some(::std::string::String::new()); } self.parent.as_mut().unwrap() } // Take field pub fn take_parent(&mut self) -> ::std::string::String { self.parent.take().unwrap_or_else(|| ::std::string::String::new()) } // required string sink = 3; pub fn sink(&self) -> &str { match self.sink.as_ref() { Some(v) => v, None => "", } } pub fn clear_sink(&mut self) { self.sink = ::std::option::Option::None; } pub fn has_sink(&self) -> bool { self.sink.is_some() } // Param is passed by value, moved pub fn set_sink(&mut self, v: ::std::string::String) { self.sink = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_sink(&mut self) -> &mut ::std::string::String { if self.sink.is_none() { self.sink = ::std::option::Option::Some(::std::string::String::new()); } self.sink.as_mut().unwrap() } // Take field pub fn take_sink(&mut self) -> ::std::string::String { self.sink.take().unwrap_or_else(|| ::std::string::String::new()) } // required uint64 fee = 4; pub fn fee(&self) -> u64 { self.fee.unwrap_or(0) } pub fn clear_fee(&mut self) { self.fee = ::std::option::Option::None; } pub fn has_fee(&self) -> bool { self.fee.is_some() } // Param is passed by value, moved pub fn set_fee(&mut self, v: u64) { self.fee = ::std::option::Option::Some(v); } pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(4); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "namespace", |m: &NEMProvisionNamespace| { &m.namespace }, |m: &mut NEMProvisionNamespace| { &mut m.namespace }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "parent", |m: &NEMProvisionNamespace| { &m.parent }, |m: &mut NEMProvisionNamespace| { &mut m.parent }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "sink", |m: &NEMProvisionNamespace| { &m.sink }, |m: &mut NEMProvisionNamespace| { &mut m.sink }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "fee", |m: &NEMProvisionNamespace| { &m.fee }, |m: &mut NEMProvisionNamespace| { &mut m.fee }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx.NEMProvisionNamespace", fields, oneofs, ) } } impl ::protobuf::Message for NEMProvisionNamespace { const NAME: &'static str = "NEMProvisionNamespace"; fn is_initialized(&self) -> bool { if self.namespace.is_none() { return false; } if self.sink.is_none() { return false; } if self.fee.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.namespace = ::std::option::Option::Some(is.read_string()?); }, 18 => { self.parent = ::std::option::Option::Some(is.read_string()?); }, 26 => { self.sink = ::std::option::Option::Some(is.read_string()?); }, 32 => { self.fee = ::std::option::Option::Some(is.read_uint64()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.namespace.as_ref() { my_size += ::protobuf::rt::string_size(1, &v); } if let Some(v) = self.parent.as_ref() { my_size += ::protobuf::rt::string_size(2, &v); } if let Some(v) = self.sink.as_ref() { my_size += ::protobuf::rt::string_size(3, &v); } if let Some(v) = self.fee { my_size += ::protobuf::rt::uint64_size(4, v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.namespace.as_ref() { os.write_string(1, v)?; } if let Some(v) = self.parent.as_ref() { os.write_string(2, v)?; } if let Some(v) = self.sink.as_ref() { os.write_string(3, v)?; } if let Some(v) = self.fee { os.write_uint64(4, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMProvisionNamespace { NEMProvisionNamespace::new() } fn clear(&mut self) { self.namespace = ::std::option::Option::None; self.parent = ::std::option::Option::None; self.sink = ::std::option::Option::None; self.fee = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMProvisionNamespace { static instance: NEMProvisionNamespace = NEMProvisionNamespace { namespace: ::std::option::Option::None, parent: ::std::option::Option::None, sink: ::std::option::Option::None, fee: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMProvisionNamespace { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("NEMSignTx.NEMProvisionNamespace").unwrap()).clone() } } impl ::std::fmt::Display for NEMProvisionNamespace { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMProvisionNamespace { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMMosaicCreation { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.definition) pub definition: ::protobuf::MessageField, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.sink) pub sink: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.fee) pub fee: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMMosaicCreation { fn default() -> &'a NEMMosaicCreation { ::default_instance() } } impl NEMMosaicCreation { pub fn new() -> NEMMosaicCreation { ::std::default::Default::default() } // required string sink = 2; pub fn sink(&self) -> &str { match self.sink.as_ref() { Some(v) => v, None => "", } } pub fn clear_sink(&mut self) { self.sink = ::std::option::Option::None; } pub fn has_sink(&self) -> bool { self.sink.is_some() } // Param is passed by value, moved pub fn set_sink(&mut self, v: ::std::string::String) { self.sink = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_sink(&mut self) -> &mut ::std::string::String { if self.sink.is_none() { self.sink = ::std::option::Option::Some(::std::string::String::new()); } self.sink.as_mut().unwrap() } // Take field pub fn take_sink(&mut self) -> ::std::string::String { self.sink.take().unwrap_or_else(|| ::std::string::String::new()) } // required uint64 fee = 3; pub fn fee(&self) -> u64 { self.fee.unwrap_or(0) } pub fn clear_fee(&mut self) { self.fee = ::std::option::Option::None; } pub fn has_fee(&self) -> bool { self.fee.is_some() } // Param is passed by value, moved pub fn set_fee(&mut self, v: u64) { self.fee = ::std::option::Option::Some(v); } pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(3); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, nemmosaic_creation::NEMMosaicDefinition>( "definition", |m: &NEMMosaicCreation| { &m.definition }, |m: &mut NEMMosaicCreation| { &mut m.definition }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "sink", |m: &NEMMosaicCreation| { &m.sink }, |m: &mut NEMMosaicCreation| { &mut m.sink }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "fee", |m: &NEMMosaicCreation| { &m.fee }, |m: &mut NEMMosaicCreation| { &mut m.fee }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx.NEMMosaicCreation", fields, oneofs, ) } } impl ::protobuf::Message for NEMMosaicCreation { const NAME: &'static str = "NEMMosaicCreation"; fn is_initialized(&self) -> bool { if self.definition.is_none() { return false; } if self.sink.is_none() { return false; } if self.fee.is_none() { return false; } for v in &self.definition { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { ::protobuf::rt::read_singular_message_into_field(is, &mut self.definition)?; }, 18 => { self.sink = ::std::option::Option::Some(is.read_string()?); }, 24 => { self.fee = ::std::option::Option::Some(is.read_uint64()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.definition.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.sink.as_ref() { my_size += ::protobuf::rt::string_size(2, &v); } if let Some(v) = self.fee { my_size += ::protobuf::rt::uint64_size(3, v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.definition.as_ref() { ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?; } if let Some(v) = self.sink.as_ref() { os.write_string(2, v)?; } if let Some(v) = self.fee { os.write_uint64(3, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMMosaicCreation { NEMMosaicCreation::new() } fn clear(&mut self) { self.definition.clear(); self.sink = ::std::option::Option::None; self.fee = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMMosaicCreation { static instance: NEMMosaicCreation = NEMMosaicCreation { definition: ::protobuf::MessageField::none(), sink: ::std::option::Option::None, fee: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMMosaicCreation { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("NEMSignTx.NEMMosaicCreation").unwrap()).clone() } } impl ::std::fmt::Display for NEMMosaicCreation { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMMosaicCreation { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `NEMMosaicCreation` pub mod nemmosaic_creation { // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMMosaicDefinition { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.name) pub name: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.ticker) pub ticker: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.namespace) pub namespace: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.mosaic) pub mosaic: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.divisibility) pub divisibility: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.levy) pub levy: ::std::option::Option<::protobuf::EnumOrUnknown>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.fee) pub fee: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.levy_address) pub levy_address: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.levy_namespace) pub levy_namespace: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.levy_mosaic) pub levy_mosaic: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.supply) pub supply: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.mutable_supply) pub mutable_supply: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.transferable) pub transferable: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.description) pub description: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.networks) pub networks: ::std::vec::Vec, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMMosaicDefinition { fn default() -> &'a NEMMosaicDefinition { ::default_instance() } } impl NEMMosaicDefinition { pub fn new() -> NEMMosaicDefinition { ::std::default::Default::default() } // optional string name = 1; pub fn name(&self) -> &str { match self.name.as_ref() { Some(v) => v, None => "", } } pub fn clear_name(&mut self) { self.name = ::std::option::Option::None; } pub fn has_name(&self) -> bool { self.name.is_some() } // Param is passed by value, moved pub fn set_name(&mut self, v: ::std::string::String) { self.name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_name(&mut self) -> &mut ::std::string::String { if self.name.is_none() { self.name = ::std::option::Option::Some(::std::string::String::new()); } self.name.as_mut().unwrap() } // Take field pub fn take_name(&mut self) -> ::std::string::String { self.name.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string ticker = 2; pub fn ticker(&self) -> &str { match self.ticker.as_ref() { Some(v) => v, None => "", } } pub fn clear_ticker(&mut self) { self.ticker = ::std::option::Option::None; } pub fn has_ticker(&self) -> bool { self.ticker.is_some() } // Param is passed by value, moved pub fn set_ticker(&mut self, v: ::std::string::String) { self.ticker = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_ticker(&mut self) -> &mut ::std::string::String { if self.ticker.is_none() { self.ticker = ::std::option::Option::Some(::std::string::String::new()); } self.ticker.as_mut().unwrap() } // Take field pub fn take_ticker(&mut self) -> ::std::string::String { self.ticker.take().unwrap_or_else(|| ::std::string::String::new()) } // required string namespace = 3; pub fn namespace(&self) -> &str { match self.namespace.as_ref() { Some(v) => v, None => "", } } pub fn clear_namespace(&mut self) { self.namespace = ::std::option::Option::None; } pub fn has_namespace(&self) -> bool { self.namespace.is_some() } // Param is passed by value, moved pub fn set_namespace(&mut self, v: ::std::string::String) { self.namespace = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_namespace(&mut self) -> &mut ::std::string::String { if self.namespace.is_none() { self.namespace = ::std::option::Option::Some(::std::string::String::new()); } self.namespace.as_mut().unwrap() } // Take field pub fn take_namespace(&mut self) -> ::std::string::String { self.namespace.take().unwrap_or_else(|| ::std::string::String::new()) } // required string mosaic = 4; pub fn mosaic(&self) -> &str { match self.mosaic.as_ref() { Some(v) => v, None => "", } } pub fn clear_mosaic(&mut self) { self.mosaic = ::std::option::Option::None; } pub fn has_mosaic(&self) -> bool { self.mosaic.is_some() } // Param is passed by value, moved pub fn set_mosaic(&mut self, v: ::std::string::String) { self.mosaic = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_mosaic(&mut self) -> &mut ::std::string::String { if self.mosaic.is_none() { self.mosaic = ::std::option::Option::Some(::std::string::String::new()); } self.mosaic.as_mut().unwrap() } // Take field pub fn take_mosaic(&mut self) -> ::std::string::String { self.mosaic.take().unwrap_or_else(|| ::std::string::String::new()) } // optional uint32 divisibility = 5; pub fn divisibility(&self) -> u32 { self.divisibility.unwrap_or(0) } pub fn clear_divisibility(&mut self) { self.divisibility = ::std::option::Option::None; } pub fn has_divisibility(&self) -> bool { self.divisibility.is_some() } // Param is passed by value, moved pub fn set_divisibility(&mut self, v: u32) { self.divisibility = ::std::option::Option::Some(v); } // optional .hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.NEMMosaicLevy levy = 6; pub fn levy(&self) -> nemmosaic_definition::NEMMosaicLevy { match self.levy { Some(e) => e.enum_value_or(nemmosaic_definition::NEMMosaicLevy::MosaicLevy_Absolute), None => nemmosaic_definition::NEMMosaicLevy::MosaicLevy_Absolute, } } pub fn clear_levy(&mut self) { self.levy = ::std::option::Option::None; } pub fn has_levy(&self) -> bool { self.levy.is_some() } // Param is passed by value, moved pub fn set_levy(&mut self, v: nemmosaic_definition::NEMMosaicLevy) { self.levy = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v)); } // optional uint64 fee = 7; pub fn fee(&self) -> u64 { self.fee.unwrap_or(0) } pub fn clear_fee(&mut self) { self.fee = ::std::option::Option::None; } pub fn has_fee(&self) -> bool { self.fee.is_some() } // Param is passed by value, moved pub fn set_fee(&mut self, v: u64) { self.fee = ::std::option::Option::Some(v); } // optional string levy_address = 8; pub fn levy_address(&self) -> &str { match self.levy_address.as_ref() { Some(v) => v, None => "", } } pub fn clear_levy_address(&mut self) { self.levy_address = ::std::option::Option::None; } pub fn has_levy_address(&self) -> bool { self.levy_address.is_some() } // Param is passed by value, moved pub fn set_levy_address(&mut self, v: ::std::string::String) { self.levy_address = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_levy_address(&mut self) -> &mut ::std::string::String { if self.levy_address.is_none() { self.levy_address = ::std::option::Option::Some(::std::string::String::new()); } self.levy_address.as_mut().unwrap() } // Take field pub fn take_levy_address(&mut self) -> ::std::string::String { self.levy_address.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string levy_namespace = 9; pub fn levy_namespace(&self) -> &str { match self.levy_namespace.as_ref() { Some(v) => v, None => "", } } pub fn clear_levy_namespace(&mut self) { self.levy_namespace = ::std::option::Option::None; } pub fn has_levy_namespace(&self) -> bool { self.levy_namespace.is_some() } // Param is passed by value, moved pub fn set_levy_namespace(&mut self, v: ::std::string::String) { self.levy_namespace = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_levy_namespace(&mut self) -> &mut ::std::string::String { if self.levy_namespace.is_none() { self.levy_namespace = ::std::option::Option::Some(::std::string::String::new()); } self.levy_namespace.as_mut().unwrap() } // Take field pub fn take_levy_namespace(&mut self) -> ::std::string::String { self.levy_namespace.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string levy_mosaic = 10; pub fn levy_mosaic(&self) -> &str { match self.levy_mosaic.as_ref() { Some(v) => v, None => "", } } pub fn clear_levy_mosaic(&mut self) { self.levy_mosaic = ::std::option::Option::None; } pub fn has_levy_mosaic(&self) -> bool { self.levy_mosaic.is_some() } // Param is passed by value, moved pub fn set_levy_mosaic(&mut self, v: ::std::string::String) { self.levy_mosaic = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_levy_mosaic(&mut self) -> &mut ::std::string::String { if self.levy_mosaic.is_none() { self.levy_mosaic = ::std::option::Option::Some(::std::string::String::new()); } self.levy_mosaic.as_mut().unwrap() } // Take field pub fn take_levy_mosaic(&mut self) -> ::std::string::String { self.levy_mosaic.take().unwrap_or_else(|| ::std::string::String::new()) } // optional uint64 supply = 11; pub fn supply(&self) -> u64 { self.supply.unwrap_or(0) } pub fn clear_supply(&mut self) { self.supply = ::std::option::Option::None; } pub fn has_supply(&self) -> bool { self.supply.is_some() } // Param is passed by value, moved pub fn set_supply(&mut self, v: u64) { self.supply = ::std::option::Option::Some(v); } // optional bool mutable_supply = 12; pub fn mutable_supply(&self) -> bool { self.mutable_supply.unwrap_or(false) } pub fn clear_mutable_supply(&mut self) { self.mutable_supply = ::std::option::Option::None; } pub fn has_mutable_supply(&self) -> bool { self.mutable_supply.is_some() } // Param is passed by value, moved pub fn set_mutable_supply(&mut self, v: bool) { self.mutable_supply = ::std::option::Option::Some(v); } // optional bool transferable = 13; pub fn transferable(&self) -> bool { self.transferable.unwrap_or(false) } pub fn clear_transferable(&mut self) { self.transferable = ::std::option::Option::None; } pub fn has_transferable(&self) -> bool { self.transferable.is_some() } // Param is passed by value, moved pub fn set_transferable(&mut self, v: bool) { self.transferable = ::std::option::Option::Some(v); } // required string description = 14; pub fn description(&self) -> &str { match self.description.as_ref() { Some(v) => v, None => "", } } pub fn clear_description(&mut self) { self.description = ::std::option::Option::None; } pub fn has_description(&self) -> bool { self.description.is_some() } // Param is passed by value, moved pub fn set_description(&mut self, v: ::std::string::String) { self.description = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_description(&mut self) -> &mut ::std::string::String { if self.description.is_none() { self.description = ::std::option::Option::Some(::std::string::String::new()); } self.description.as_mut().unwrap() } // Take field pub fn take_description(&mut self) -> ::std::string::String { self.description.take().unwrap_or_else(|| ::std::string::String::new()) } pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(15); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "name", |m: &NEMMosaicDefinition| { &m.name }, |m: &mut NEMMosaicDefinition| { &mut m.name }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "ticker", |m: &NEMMosaicDefinition| { &m.ticker }, |m: &mut NEMMosaicDefinition| { &mut m.ticker }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "namespace", |m: &NEMMosaicDefinition| { &m.namespace }, |m: &mut NEMMosaicDefinition| { &mut m.namespace }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "mosaic", |m: &NEMMosaicDefinition| { &m.mosaic }, |m: &mut NEMMosaicDefinition| { &mut m.mosaic }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "divisibility", |m: &NEMMosaicDefinition| { &m.divisibility }, |m: &mut NEMMosaicDefinition| { &mut m.divisibility }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "levy", |m: &NEMMosaicDefinition| { &m.levy }, |m: &mut NEMMosaicDefinition| { &mut m.levy }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "fee", |m: &NEMMosaicDefinition| { &m.fee }, |m: &mut NEMMosaicDefinition| { &mut m.fee }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "levy_address", |m: &NEMMosaicDefinition| { &m.levy_address }, |m: &mut NEMMosaicDefinition| { &mut m.levy_address }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "levy_namespace", |m: &NEMMosaicDefinition| { &m.levy_namespace }, |m: &mut NEMMosaicDefinition| { &mut m.levy_namespace }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "levy_mosaic", |m: &NEMMosaicDefinition| { &m.levy_mosaic }, |m: &mut NEMMosaicDefinition| { &mut m.levy_mosaic }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "supply", |m: &NEMMosaicDefinition| { &m.supply }, |m: &mut NEMMosaicDefinition| { &mut m.supply }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "mutable_supply", |m: &NEMMosaicDefinition| { &m.mutable_supply }, |m: &mut NEMMosaicDefinition| { &mut m.mutable_supply }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "transferable", |m: &NEMMosaicDefinition| { &m.transferable }, |m: &mut NEMMosaicDefinition| { &mut m.transferable }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "description", |m: &NEMMosaicDefinition| { &m.description }, |m: &mut NEMMosaicDefinition| { &mut m.description }, )); fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "networks", |m: &NEMMosaicDefinition| { &m.networks }, |m: &mut NEMMosaicDefinition| { &mut m.networks }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition", fields, oneofs, ) } } impl ::protobuf::Message for NEMMosaicDefinition { const NAME: &'static str = "NEMMosaicDefinition"; fn is_initialized(&self) -> bool { if self.namespace.is_none() { return false; } if self.mosaic.is_none() { return false; } if self.description.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.name = ::std::option::Option::Some(is.read_string()?); }, 18 => { self.ticker = ::std::option::Option::Some(is.read_string()?); }, 26 => { self.namespace = ::std::option::Option::Some(is.read_string()?); }, 34 => { self.mosaic = ::std::option::Option::Some(is.read_string()?); }, 40 => { self.divisibility = ::std::option::Option::Some(is.read_uint32()?); }, 48 => { self.levy = ::std::option::Option::Some(is.read_enum_or_unknown()?); }, 56 => { self.fee = ::std::option::Option::Some(is.read_uint64()?); }, 66 => { self.levy_address = ::std::option::Option::Some(is.read_string()?); }, 74 => { self.levy_namespace = ::std::option::Option::Some(is.read_string()?); }, 82 => { self.levy_mosaic = ::std::option::Option::Some(is.read_string()?); }, 88 => { self.supply = ::std::option::Option::Some(is.read_uint64()?); }, 96 => { self.mutable_supply = ::std::option::Option::Some(is.read_bool()?); }, 104 => { self.transferable = ::std::option::Option::Some(is.read_bool()?); }, 114 => { self.description = ::std::option::Option::Some(is.read_string()?); }, 122 => { is.read_repeated_packed_uint32_into(&mut self.networks)?; }, 120 => { self.networks.push(is.read_uint32()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.name.as_ref() { my_size += ::protobuf::rt::string_size(1, &v); } if let Some(v) = self.ticker.as_ref() { my_size += ::protobuf::rt::string_size(2, &v); } if let Some(v) = self.namespace.as_ref() { my_size += ::protobuf::rt::string_size(3, &v); } if let Some(v) = self.mosaic.as_ref() { my_size += ::protobuf::rt::string_size(4, &v); } if let Some(v) = self.divisibility { my_size += ::protobuf::rt::uint32_size(5, v); } if let Some(v) = self.levy { my_size += ::protobuf::rt::int32_size(6, v.value()); } if let Some(v) = self.fee { my_size += ::protobuf::rt::uint64_size(7, v); } if let Some(v) = self.levy_address.as_ref() { my_size += ::protobuf::rt::string_size(8, &v); } if let Some(v) = self.levy_namespace.as_ref() { my_size += ::protobuf::rt::string_size(9, &v); } if let Some(v) = self.levy_mosaic.as_ref() { my_size += ::protobuf::rt::string_size(10, &v); } if let Some(v) = self.supply { my_size += ::protobuf::rt::uint64_size(11, v); } if let Some(v) = self.mutable_supply { my_size += 1 + 1; } if let Some(v) = self.transferable { my_size += 1 + 1; } if let Some(v) = self.description.as_ref() { my_size += ::protobuf::rt::string_size(14, &v); } for value in &self.networks { my_size += ::protobuf::rt::uint32_size(15, *value); }; my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.name.as_ref() { os.write_string(1, v)?; } if let Some(v) = self.ticker.as_ref() { os.write_string(2, v)?; } if let Some(v) = self.namespace.as_ref() { os.write_string(3, v)?; } if let Some(v) = self.mosaic.as_ref() { os.write_string(4, v)?; } if let Some(v) = self.divisibility { os.write_uint32(5, v)?; } if let Some(v) = self.levy { os.write_enum(6, ::protobuf::EnumOrUnknown::value(&v))?; } if let Some(v) = self.fee { os.write_uint64(7, v)?; } if let Some(v) = self.levy_address.as_ref() { os.write_string(8, v)?; } if let Some(v) = self.levy_namespace.as_ref() { os.write_string(9, v)?; } if let Some(v) = self.levy_mosaic.as_ref() { os.write_string(10, v)?; } if let Some(v) = self.supply { os.write_uint64(11, v)?; } if let Some(v) = self.mutable_supply { os.write_bool(12, v)?; } if let Some(v) = self.transferable { os.write_bool(13, v)?; } if let Some(v) = self.description.as_ref() { os.write_string(14, v)?; } for v in &self.networks { os.write_uint32(15, *v)?; }; os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMMosaicDefinition { NEMMosaicDefinition::new() } fn clear(&mut self) { self.name = ::std::option::Option::None; self.ticker = ::std::option::Option::None; self.namespace = ::std::option::Option::None; self.mosaic = ::std::option::Option::None; self.divisibility = ::std::option::Option::None; self.levy = ::std::option::Option::None; self.fee = ::std::option::Option::None; self.levy_address = ::std::option::Option::None; self.levy_namespace = ::std::option::Option::None; self.levy_mosaic = ::std::option::Option::None; self.supply = ::std::option::Option::None; self.mutable_supply = ::std::option::Option::None; self.transferable = ::std::option::Option::None; self.description = ::std::option::Option::None; self.networks.clear(); self.special_fields.clear(); } fn default_instance() -> &'static NEMMosaicDefinition { static instance: NEMMosaicDefinition = NEMMosaicDefinition { name: ::std::option::Option::None, ticker: ::std::option::Option::None, namespace: ::std::option::Option::None, mosaic: ::std::option::Option::None, divisibility: ::std::option::Option::None, levy: ::std::option::Option::None, fee: ::std::option::Option::None, levy_address: ::std::option::Option::None, levy_namespace: ::std::option::Option::None, levy_mosaic: ::std::option::Option::None, supply: ::std::option::Option::None, mutable_supply: ::std::option::Option::None, transferable: ::std::option::Option::None, description: ::std::option::Option::None, networks: ::std::vec::Vec::new(), special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMMosaicDefinition { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition").unwrap()).clone() } } impl ::std::fmt::Display for NEMMosaicDefinition { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMMosaicDefinition { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `NEMMosaicDefinition` pub mod nemmosaic_definition { #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] // @@protoc_insertion_point(enum:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.NEMMosaicLevy) pub enum NEMMosaicLevy { // @@protoc_insertion_point(enum_value:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.NEMMosaicLevy.MosaicLevy_Absolute) MosaicLevy_Absolute = 1, // @@protoc_insertion_point(enum_value:hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.NEMMosaicLevy.MosaicLevy_Percentile) MosaicLevy_Percentile = 2, } impl ::protobuf::Enum for NEMMosaicLevy { const NAME: &'static str = "NEMMosaicLevy"; fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 1 => ::std::option::Option::Some(NEMMosaicLevy::MosaicLevy_Absolute), 2 => ::std::option::Option::Some(NEMMosaicLevy::MosaicLevy_Percentile), _ => ::std::option::Option::None } } fn from_str(str: &str) -> ::std::option::Option { match str { "MosaicLevy_Absolute" => ::std::option::Option::Some(NEMMosaicLevy::MosaicLevy_Absolute), "MosaicLevy_Percentile" => ::std::option::Option::Some(NEMMosaicLevy::MosaicLevy_Percentile), _ => ::std::option::Option::None } } const VALUES: &'static [NEMMosaicLevy] = &[ NEMMosaicLevy::MosaicLevy_Absolute, NEMMosaicLevy::MosaicLevy_Percentile, ]; } impl ::protobuf::EnumFull for NEMMosaicLevy { fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::super::super::file_descriptor().enum_by_package_relative_name("NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.NEMMosaicLevy").unwrap()).clone() } fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { let index = match self { NEMMosaicLevy::MosaicLevy_Absolute => 0, NEMMosaicLevy::MosaicLevy_Percentile => 1, }; Self::enum_descriptor().value_by_index(index) } } // Note, `Default` is implemented although default value is not 0 impl ::std::default::Default for NEMMosaicLevy { fn default() -> Self { NEMMosaicLevy::MosaicLevy_Absolute } } impl NEMMosaicLevy { pub(in super::super::super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { ::protobuf::reflect::GeneratedEnumDescriptorData::new::("NEMSignTx.NEMMosaicCreation.NEMMosaicDefinition.NEMMosaicLevy") } } } } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChange) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMMosaicSupplyChange { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChange.namespace) pub namespace: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChange.mosaic) pub mosaic: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChange.type) pub type_: ::std::option::Option<::protobuf::EnumOrUnknown>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChange.delta) pub delta: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChange.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMMosaicSupplyChange { fn default() -> &'a NEMMosaicSupplyChange { ::default_instance() } } impl NEMMosaicSupplyChange { pub fn new() -> NEMMosaicSupplyChange { ::std::default::Default::default() } // required string namespace = 1; pub fn namespace(&self) -> &str { match self.namespace.as_ref() { Some(v) => v, None => "", } } pub fn clear_namespace(&mut self) { self.namespace = ::std::option::Option::None; } pub fn has_namespace(&self) -> bool { self.namespace.is_some() } // Param is passed by value, moved pub fn set_namespace(&mut self, v: ::std::string::String) { self.namespace = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_namespace(&mut self) -> &mut ::std::string::String { if self.namespace.is_none() { self.namespace = ::std::option::Option::Some(::std::string::String::new()); } self.namespace.as_mut().unwrap() } // Take field pub fn take_namespace(&mut self) -> ::std::string::String { self.namespace.take().unwrap_or_else(|| ::std::string::String::new()) } // required string mosaic = 2; pub fn mosaic(&self) -> &str { match self.mosaic.as_ref() { Some(v) => v, None => "", } } pub fn clear_mosaic(&mut self) { self.mosaic = ::std::option::Option::None; } pub fn has_mosaic(&self) -> bool { self.mosaic.is_some() } // Param is passed by value, moved pub fn set_mosaic(&mut self, v: ::std::string::String) { self.mosaic = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_mosaic(&mut self) -> &mut ::std::string::String { if self.mosaic.is_none() { self.mosaic = ::std::option::Option::Some(::std::string::String::new()); } self.mosaic.as_mut().unwrap() } // Take field pub fn take_mosaic(&mut self) -> ::std::string::String { self.mosaic.take().unwrap_or_else(|| ::std::string::String::new()) } // required .hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChange.NEMSupplyChangeType type = 3; pub fn type_(&self) -> nemmosaic_supply_change::NEMSupplyChangeType { match self.type_ { Some(e) => e.enum_value_or(nemmosaic_supply_change::NEMSupplyChangeType::SupplyChange_Increase), None => nemmosaic_supply_change::NEMSupplyChangeType::SupplyChange_Increase, } } pub fn clear_type_(&mut self) { self.type_ = ::std::option::Option::None; } pub fn has_type(&self) -> bool { self.type_.is_some() } // Param is passed by value, moved pub fn set_type(&mut self, v: nemmosaic_supply_change::NEMSupplyChangeType) { self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v)); } // required uint64 delta = 4; pub fn delta(&self) -> u64 { self.delta.unwrap_or(0) } pub fn clear_delta(&mut self) { self.delta = ::std::option::Option::None; } pub fn has_delta(&self) -> bool { self.delta.is_some() } // Param is passed by value, moved pub fn set_delta(&mut self, v: u64) { self.delta = ::std::option::Option::Some(v); } pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(4); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "namespace", |m: &NEMMosaicSupplyChange| { &m.namespace }, |m: &mut NEMMosaicSupplyChange| { &mut m.namespace }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "mosaic", |m: &NEMMosaicSupplyChange| { &m.mosaic }, |m: &mut NEMMosaicSupplyChange| { &mut m.mosaic }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "type", |m: &NEMMosaicSupplyChange| { &m.type_ }, |m: &mut NEMMosaicSupplyChange| { &mut m.type_ }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "delta", |m: &NEMMosaicSupplyChange| { &m.delta }, |m: &mut NEMMosaicSupplyChange| { &mut m.delta }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx.NEMMosaicSupplyChange", fields, oneofs, ) } } impl ::protobuf::Message for NEMMosaicSupplyChange { const NAME: &'static str = "NEMMosaicSupplyChange"; fn is_initialized(&self) -> bool { if self.namespace.is_none() { return false; } if self.mosaic.is_none() { return false; } if self.type_.is_none() { return false; } if self.delta.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.namespace = ::std::option::Option::Some(is.read_string()?); }, 18 => { self.mosaic = ::std::option::Option::Some(is.read_string()?); }, 24 => { self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?); }, 32 => { self.delta = ::std::option::Option::Some(is.read_uint64()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.namespace.as_ref() { my_size += ::protobuf::rt::string_size(1, &v); } if let Some(v) = self.mosaic.as_ref() { my_size += ::protobuf::rt::string_size(2, &v); } if let Some(v) = self.type_ { my_size += ::protobuf::rt::int32_size(3, v.value()); } if let Some(v) = self.delta { my_size += ::protobuf::rt::uint64_size(4, v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.namespace.as_ref() { os.write_string(1, v)?; } if let Some(v) = self.mosaic.as_ref() { os.write_string(2, v)?; } if let Some(v) = self.type_ { os.write_enum(3, ::protobuf::EnumOrUnknown::value(&v))?; } if let Some(v) = self.delta { os.write_uint64(4, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMMosaicSupplyChange { NEMMosaicSupplyChange::new() } fn clear(&mut self) { self.namespace = ::std::option::Option::None; self.mosaic = ::std::option::Option::None; self.type_ = ::std::option::Option::None; self.delta = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMMosaicSupplyChange { static instance: NEMMosaicSupplyChange = NEMMosaicSupplyChange { namespace: ::std::option::Option::None, mosaic: ::std::option::Option::None, type_: ::std::option::Option::None, delta: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMMosaicSupplyChange { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("NEMSignTx.NEMMosaicSupplyChange").unwrap()).clone() } } impl ::std::fmt::Display for NEMMosaicSupplyChange { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMMosaicSupplyChange { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `NEMMosaicSupplyChange` pub mod nemmosaic_supply_change { #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] // @@protoc_insertion_point(enum:hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChange.NEMSupplyChangeType) pub enum NEMSupplyChangeType { // @@protoc_insertion_point(enum_value:hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChange.NEMSupplyChangeType.SupplyChange_Increase) SupplyChange_Increase = 1, // @@protoc_insertion_point(enum_value:hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChange.NEMSupplyChangeType.SupplyChange_Decrease) SupplyChange_Decrease = 2, } impl ::protobuf::Enum for NEMSupplyChangeType { const NAME: &'static str = "NEMSupplyChangeType"; fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 1 => ::std::option::Option::Some(NEMSupplyChangeType::SupplyChange_Increase), 2 => ::std::option::Option::Some(NEMSupplyChangeType::SupplyChange_Decrease), _ => ::std::option::Option::None } } fn from_str(str: &str) -> ::std::option::Option { match str { "SupplyChange_Increase" => ::std::option::Option::Some(NEMSupplyChangeType::SupplyChange_Increase), "SupplyChange_Decrease" => ::std::option::Option::Some(NEMSupplyChangeType::SupplyChange_Decrease), _ => ::std::option::Option::None } } const VALUES: &'static [NEMSupplyChangeType] = &[ NEMSupplyChangeType::SupplyChange_Increase, NEMSupplyChangeType::SupplyChange_Decrease, ]; } impl ::protobuf::EnumFull for NEMSupplyChangeType { fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::super::file_descriptor().enum_by_package_relative_name("NEMSignTx.NEMMosaicSupplyChange.NEMSupplyChangeType").unwrap()).clone() } fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { let index = match self { NEMSupplyChangeType::SupplyChange_Increase => 0, NEMSupplyChangeType::SupplyChange_Decrease => 1, }; Self::enum_descriptor().value_by_index(index) } } // Note, `Default` is implemented although default value is not 0 impl ::std::default::Default for NEMSupplyChangeType { fn default() -> Self { NEMSupplyChangeType::SupplyChange_Increase } } impl NEMSupplyChangeType { pub(in super::super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { ::protobuf::reflect::GeneratedEnumDescriptorData::new::("NEMSignTx.NEMMosaicSupplyChange.NEMSupplyChangeType") } } } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMAggregateModification { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.modifications) pub modifications: ::std::vec::Vec, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.relative_change) pub relative_change: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMAggregateModification { fn default() -> &'a NEMAggregateModification { ::default_instance() } } impl NEMAggregateModification { pub fn new() -> NEMAggregateModification { ::std::default::Default::default() } // optional sint32 relative_change = 2; pub fn relative_change(&self) -> i32 { self.relative_change.unwrap_or(0) } pub fn clear_relative_change(&mut self) { self.relative_change = ::std::option::Option::None; } pub fn has_relative_change(&self) -> bool { self.relative_change.is_some() } // Param is passed by value, moved pub fn set_relative_change(&mut self, v: i32) { self.relative_change = ::std::option::Option::Some(v); } pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(2); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "modifications", |m: &NEMAggregateModification| { &m.modifications }, |m: &mut NEMAggregateModification| { &mut m.modifications }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "relative_change", |m: &NEMAggregateModification| { &m.relative_change }, |m: &mut NEMAggregateModification| { &mut m.relative_change }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx.NEMAggregateModification", fields, oneofs, ) } } impl ::protobuf::Message for NEMAggregateModification { const NAME: &'static str = "NEMAggregateModification"; fn is_initialized(&self) -> bool { for v in &self.modifications { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.modifications.push(is.read_message()?); }, 16 => { self.relative_change = ::std::option::Option::Some(is.read_sint32()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; for value in &self.modifications { let len = value.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; }; if let Some(v) = self.relative_change { my_size += ::protobuf::rt::sint32_size(2, v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { for v in &self.modifications { ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?; }; if let Some(v) = self.relative_change { os.write_sint32(2, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMAggregateModification { NEMAggregateModification::new() } fn clear(&mut self) { self.modifications.clear(); self.relative_change = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMAggregateModification { static instance: NEMAggregateModification = NEMAggregateModification { modifications: ::std::vec::Vec::new(), relative_change: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMAggregateModification { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("NEMSignTx.NEMAggregateModification").unwrap()).clone() } } impl ::std::fmt::Display for NEMAggregateModification { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMAggregateModification { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `NEMAggregateModification` pub mod nemaggregate_modification { // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.NEMCosignatoryModification) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMCosignatoryModification { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.NEMCosignatoryModification.type) pub type_: ::std::option::Option<::protobuf::EnumOrUnknown>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.NEMCosignatoryModification.public_key) pub public_key: ::std::option::Option<::std::vec::Vec>, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.NEMCosignatoryModification.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMCosignatoryModification { fn default() -> &'a NEMCosignatoryModification { ::default_instance() } } impl NEMCosignatoryModification { pub fn new() -> NEMCosignatoryModification { ::std::default::Default::default() } // required .hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.NEMCosignatoryModification.NEMModificationType type = 1; pub fn type_(&self) -> nemcosignatory_modification::NEMModificationType { match self.type_ { Some(e) => e.enum_value_or(nemcosignatory_modification::NEMModificationType::CosignatoryModification_Add), None => nemcosignatory_modification::NEMModificationType::CosignatoryModification_Add, } } pub fn clear_type_(&mut self) { self.type_ = ::std::option::Option::None; } pub fn has_type(&self) -> bool { self.type_.is_some() } // Param is passed by value, moved pub fn set_type(&mut self, v: nemcosignatory_modification::NEMModificationType) { self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v)); } // required bytes public_key = 2; pub fn public_key(&self) -> &[u8] { match self.public_key.as_ref() { Some(v) => v, None => &[], } } pub fn clear_public_key(&mut self) { self.public_key = ::std::option::Option::None; } pub fn has_public_key(&self) -> bool { self.public_key.is_some() } // Param is passed by value, moved pub fn set_public_key(&mut self, v: ::std::vec::Vec) { self.public_key = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec { if self.public_key.is_none() { self.public_key = ::std::option::Option::Some(::std::vec::Vec::new()); } self.public_key.as_mut().unwrap() } // Take field pub fn take_public_key(&mut self) -> ::std::vec::Vec { self.public_key.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(2); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "type", |m: &NEMCosignatoryModification| { &m.type_ }, |m: &mut NEMCosignatoryModification| { &mut m.type_ }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "public_key", |m: &NEMCosignatoryModification| { &m.public_key }, |m: &mut NEMCosignatoryModification| { &mut m.public_key }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx.NEMAggregateModification.NEMCosignatoryModification", fields, oneofs, ) } } impl ::protobuf::Message for NEMCosignatoryModification { const NAME: &'static str = "NEMCosignatoryModification"; fn is_initialized(&self) -> bool { if self.type_.is_none() { return false; } if self.public_key.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 8 => { self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?); }, 18 => { self.public_key = ::std::option::Option::Some(is.read_bytes()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.type_ { my_size += ::protobuf::rt::int32_size(1, v.value()); } if let Some(v) = self.public_key.as_ref() { my_size += ::protobuf::rt::bytes_size(2, &v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.type_ { os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?; } if let Some(v) = self.public_key.as_ref() { os.write_bytes(2, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMCosignatoryModification { NEMCosignatoryModification::new() } fn clear(&mut self) { self.type_ = ::std::option::Option::None; self.public_key = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMCosignatoryModification { static instance: NEMCosignatoryModification = NEMCosignatoryModification { type_: ::std::option::Option::None, public_key: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMCosignatoryModification { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("NEMSignTx.NEMAggregateModification.NEMCosignatoryModification").unwrap()).clone() } } impl ::std::fmt::Display for NEMCosignatoryModification { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMCosignatoryModification { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `NEMCosignatoryModification` pub mod nemcosignatory_modification { #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] // @@protoc_insertion_point(enum:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.NEMCosignatoryModification.NEMModificationType) pub enum NEMModificationType { // @@protoc_insertion_point(enum_value:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.NEMCosignatoryModification.NEMModificationType.CosignatoryModification_Add) CosignatoryModification_Add = 1, // @@protoc_insertion_point(enum_value:hw.trezor.messages.nem.NEMSignTx.NEMAggregateModification.NEMCosignatoryModification.NEMModificationType.CosignatoryModification_Delete) CosignatoryModification_Delete = 2, } impl ::protobuf::Enum for NEMModificationType { const NAME: &'static str = "NEMModificationType"; fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 1 => ::std::option::Option::Some(NEMModificationType::CosignatoryModification_Add), 2 => ::std::option::Option::Some(NEMModificationType::CosignatoryModification_Delete), _ => ::std::option::Option::None } } fn from_str(str: &str) -> ::std::option::Option { match str { "CosignatoryModification_Add" => ::std::option::Option::Some(NEMModificationType::CosignatoryModification_Add), "CosignatoryModification_Delete" => ::std::option::Option::Some(NEMModificationType::CosignatoryModification_Delete), _ => ::std::option::Option::None } } const VALUES: &'static [NEMModificationType] = &[ NEMModificationType::CosignatoryModification_Add, NEMModificationType::CosignatoryModification_Delete, ]; } impl ::protobuf::EnumFull for NEMModificationType { fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::super::super::file_descriptor().enum_by_package_relative_name("NEMSignTx.NEMAggregateModification.NEMCosignatoryModification.NEMModificationType").unwrap()).clone() } fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { let index = match self { NEMModificationType::CosignatoryModification_Add => 0, NEMModificationType::CosignatoryModification_Delete => 1, }; Self::enum_descriptor().value_by_index(index) } } // Note, `Default` is implemented although default value is not 0 impl ::std::default::Default for NEMModificationType { fn default() -> Self { NEMModificationType::CosignatoryModification_Add } } impl NEMModificationType { pub(in super::super::super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { ::protobuf::reflect::GeneratedEnumDescriptorData::new::("NEMSignTx.NEMAggregateModification.NEMCosignatoryModification.NEMModificationType") } } } } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignTx.NEMImportanceTransfer) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMImportanceTransfer { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMImportanceTransfer.mode) pub mode: ::std::option::Option<::protobuf::EnumOrUnknown>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignTx.NEMImportanceTransfer.public_key) pub public_key: ::std::option::Option<::std::vec::Vec>, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignTx.NEMImportanceTransfer.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMImportanceTransfer { fn default() -> &'a NEMImportanceTransfer { ::default_instance() } } impl NEMImportanceTransfer { pub fn new() -> NEMImportanceTransfer { ::std::default::Default::default() } // required .hw.trezor.messages.nem.NEMSignTx.NEMImportanceTransfer.NEMImportanceTransferMode mode = 1; pub fn mode(&self) -> nemimportance_transfer::NEMImportanceTransferMode { match self.mode { Some(e) => e.enum_value_or(nemimportance_transfer::NEMImportanceTransferMode::ImportanceTransfer_Activate), None => nemimportance_transfer::NEMImportanceTransferMode::ImportanceTransfer_Activate, } } pub fn clear_mode(&mut self) { self.mode = ::std::option::Option::None; } pub fn has_mode(&self) -> bool { self.mode.is_some() } // Param is passed by value, moved pub fn set_mode(&mut self, v: nemimportance_transfer::NEMImportanceTransferMode) { self.mode = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v)); } // required bytes public_key = 2; pub fn public_key(&self) -> &[u8] { match self.public_key.as_ref() { Some(v) => v, None => &[], } } pub fn clear_public_key(&mut self) { self.public_key = ::std::option::Option::None; } pub fn has_public_key(&self) -> bool { self.public_key.is_some() } // Param is passed by value, moved pub fn set_public_key(&mut self, v: ::std::vec::Vec) { self.public_key = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec { if self.public_key.is_none() { self.public_key = ::std::option::Option::Some(::std::vec::Vec::new()); } self.public_key.as_mut().unwrap() } // Take field pub fn take_public_key(&mut self) -> ::std::vec::Vec { self.public_key.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(2); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "mode", |m: &NEMImportanceTransfer| { &m.mode }, |m: &mut NEMImportanceTransfer| { &mut m.mode }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "public_key", |m: &NEMImportanceTransfer| { &m.public_key }, |m: &mut NEMImportanceTransfer| { &mut m.public_key }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignTx.NEMImportanceTransfer", fields, oneofs, ) } } impl ::protobuf::Message for NEMImportanceTransfer { const NAME: &'static str = "NEMImportanceTransfer"; fn is_initialized(&self) -> bool { if self.mode.is_none() { return false; } if self.public_key.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 8 => { self.mode = ::std::option::Option::Some(is.read_enum_or_unknown()?); }, 18 => { self.public_key = ::std::option::Option::Some(is.read_bytes()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.mode { my_size += ::protobuf::rt::int32_size(1, v.value()); } if let Some(v) = self.public_key.as_ref() { my_size += ::protobuf::rt::bytes_size(2, &v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.mode { os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?; } if let Some(v) = self.public_key.as_ref() { os.write_bytes(2, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMImportanceTransfer { NEMImportanceTransfer::new() } fn clear(&mut self) { self.mode = ::std::option::Option::None; self.public_key = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMImportanceTransfer { static instance: NEMImportanceTransfer = NEMImportanceTransfer { mode: ::std::option::Option::None, public_key: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMImportanceTransfer { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("NEMSignTx.NEMImportanceTransfer").unwrap()).clone() } } impl ::std::fmt::Display for NEMImportanceTransfer { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMImportanceTransfer { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `NEMImportanceTransfer` pub mod nemimportance_transfer { #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] // @@protoc_insertion_point(enum:hw.trezor.messages.nem.NEMSignTx.NEMImportanceTransfer.NEMImportanceTransferMode) pub enum NEMImportanceTransferMode { // @@protoc_insertion_point(enum_value:hw.trezor.messages.nem.NEMSignTx.NEMImportanceTransfer.NEMImportanceTransferMode.ImportanceTransfer_Activate) ImportanceTransfer_Activate = 1, // @@protoc_insertion_point(enum_value:hw.trezor.messages.nem.NEMSignTx.NEMImportanceTransfer.NEMImportanceTransferMode.ImportanceTransfer_Deactivate) ImportanceTransfer_Deactivate = 2, } impl ::protobuf::Enum for NEMImportanceTransferMode { const NAME: &'static str = "NEMImportanceTransferMode"; fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 1 => ::std::option::Option::Some(NEMImportanceTransferMode::ImportanceTransfer_Activate), 2 => ::std::option::Option::Some(NEMImportanceTransferMode::ImportanceTransfer_Deactivate), _ => ::std::option::Option::None } } fn from_str(str: &str) -> ::std::option::Option { match str { "ImportanceTransfer_Activate" => ::std::option::Option::Some(NEMImportanceTransferMode::ImportanceTransfer_Activate), "ImportanceTransfer_Deactivate" => ::std::option::Option::Some(NEMImportanceTransferMode::ImportanceTransfer_Deactivate), _ => ::std::option::Option::None } } const VALUES: &'static [NEMImportanceTransferMode] = &[ NEMImportanceTransferMode::ImportanceTransfer_Activate, NEMImportanceTransferMode::ImportanceTransfer_Deactivate, ]; } impl ::protobuf::EnumFull for NEMImportanceTransferMode { fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| super::super::file_descriptor().enum_by_package_relative_name("NEMSignTx.NEMImportanceTransfer.NEMImportanceTransferMode").unwrap()).clone() } fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { let index = match self { NEMImportanceTransferMode::ImportanceTransfer_Activate => 0, NEMImportanceTransferMode::ImportanceTransfer_Deactivate => 1, }; Self::enum_descriptor().value_by_index(index) } } // Note, `Default` is implemented although default value is not 0 impl ::std::default::Default for NEMImportanceTransferMode { fn default() -> Self { NEMImportanceTransferMode::ImportanceTransfer_Activate } } impl NEMImportanceTransferMode { pub(in super::super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { ::protobuf::reflect::GeneratedEnumDescriptorData::new::("NEMSignTx.NEMImportanceTransfer.NEMImportanceTransferMode") } } } } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMSignedTx) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMSignedTx { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignedTx.data) pub data: ::std::option::Option<::std::vec::Vec>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMSignedTx.signature) pub signature: ::std::option::Option<::std::vec::Vec>, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMSignedTx.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMSignedTx { fn default() -> &'a NEMSignedTx { ::default_instance() } } impl NEMSignedTx { pub fn new() -> NEMSignedTx { ::std::default::Default::default() } // required bytes data = 1; pub fn data(&self) -> &[u8] { match self.data.as_ref() { Some(v) => v, None => &[], } } pub fn clear_data(&mut self) { self.data = ::std::option::Option::None; } pub fn has_data(&self) -> bool { self.data.is_some() } // Param is passed by value, moved pub fn set_data(&mut self, v: ::std::vec::Vec) { self.data = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_data(&mut self) -> &mut ::std::vec::Vec { if self.data.is_none() { self.data = ::std::option::Option::Some(::std::vec::Vec::new()); } self.data.as_mut().unwrap() } // Take field pub fn take_data(&mut self) -> ::std::vec::Vec { self.data.take().unwrap_or_else(|| ::std::vec::Vec::new()) } // required bytes signature = 2; pub fn signature(&self) -> &[u8] { match self.signature.as_ref() { Some(v) => v, None => &[], } } pub fn clear_signature(&mut self) { self.signature = ::std::option::Option::None; } pub fn has_signature(&self) -> bool { self.signature.is_some() } // Param is passed by value, moved pub fn set_signature(&mut self, v: ::std::vec::Vec) { self.signature = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec { if self.signature.is_none() { self.signature = ::std::option::Option::Some(::std::vec::Vec::new()); } self.signature.as_mut().unwrap() } // Take field pub fn take_signature(&mut self) -> ::std::vec::Vec { self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new()) } fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(2); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "data", |m: &NEMSignedTx| { &m.data }, |m: &mut NEMSignedTx| { &mut m.data }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "signature", |m: &NEMSignedTx| { &m.signature }, |m: &mut NEMSignedTx| { &mut m.signature }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMSignedTx", fields, oneofs, ) } } impl ::protobuf::Message for NEMSignedTx { const NAME: &'static str = "NEMSignedTx"; fn is_initialized(&self) -> bool { if self.data.is_none() { return false; } if self.signature.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.data = ::std::option::Option::Some(is.read_bytes()?); }, 18 => { self.signature = ::std::option::Option::Some(is.read_bytes()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.data.as_ref() { my_size += ::protobuf::rt::bytes_size(1, &v); } if let Some(v) = self.signature.as_ref() { my_size += ::protobuf::rt::bytes_size(2, &v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.data.as_ref() { os.write_bytes(1, v)?; } if let Some(v) = self.signature.as_ref() { os.write_bytes(2, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMSignedTx { NEMSignedTx::new() } fn clear(&mut self) { self.data = ::std::option::Option::None; self.signature = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMSignedTx { static instance: NEMSignedTx = NEMSignedTx { data: ::std::option::Option::None, signature: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMSignedTx { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("NEMSignedTx").unwrap()).clone() } } impl ::std::fmt::Display for NEMSignedTx { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMSignedTx { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMDecryptMessage) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMDecryptMessage { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMDecryptMessage.address_n) pub address_n: ::std::vec::Vec, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMDecryptMessage.network) pub network: ::std::option::Option, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMDecryptMessage.public_key) pub public_key: ::std::option::Option<::std::vec::Vec>, // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMDecryptMessage.payload) pub payload: ::std::option::Option<::std::vec::Vec>, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMDecryptMessage.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMDecryptMessage { fn default() -> &'a NEMDecryptMessage { ::default_instance() } } impl NEMDecryptMessage { pub fn new() -> NEMDecryptMessage { ::std::default::Default::default() } // optional uint32 network = 2; pub fn network(&self) -> u32 { self.network.unwrap_or(0) } pub fn clear_network(&mut self) { self.network = ::std::option::Option::None; } pub fn has_network(&self) -> bool { self.network.is_some() } // Param is passed by value, moved pub fn set_network(&mut self, v: u32) { self.network = ::std::option::Option::Some(v); } // optional bytes public_key = 3; pub fn public_key(&self) -> &[u8] { match self.public_key.as_ref() { Some(v) => v, None => &[], } } pub fn clear_public_key(&mut self) { self.public_key = ::std::option::Option::None; } pub fn has_public_key(&self) -> bool { self.public_key.is_some() } // Param is passed by value, moved pub fn set_public_key(&mut self, v: ::std::vec::Vec) { self.public_key = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec { if self.public_key.is_none() { self.public_key = ::std::option::Option::Some(::std::vec::Vec::new()); } self.public_key.as_mut().unwrap() } // Take field pub fn take_public_key(&mut self) -> ::std::vec::Vec { self.public_key.take().unwrap_or_else(|| ::std::vec::Vec::new()) } // optional bytes payload = 4; pub fn payload(&self) -> &[u8] { match self.payload.as_ref() { Some(v) => v, None => &[], } } pub fn clear_payload(&mut self) { self.payload = ::std::option::Option::None; } pub fn has_payload(&self) -> bool { self.payload.is_some() } // Param is passed by value, moved pub fn set_payload(&mut self, v: ::std::vec::Vec) { self.payload = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec { if self.payload.is_none() { self.payload = ::std::option::Option::Some(::std::vec::Vec::new()); } self.payload.as_mut().unwrap() } // Take field pub fn take_payload(&mut self) -> ::std::vec::Vec { self.payload.take().unwrap_or_else(|| ::std::vec::Vec::new()) } fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(4); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "address_n", |m: &NEMDecryptMessage| { &m.address_n }, |m: &mut NEMDecryptMessage| { &mut m.address_n }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "network", |m: &NEMDecryptMessage| { &m.network }, |m: &mut NEMDecryptMessage| { &mut m.network }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "public_key", |m: &NEMDecryptMessage| { &m.public_key }, |m: &mut NEMDecryptMessage| { &mut m.public_key }, )); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "payload", |m: &NEMDecryptMessage| { &m.payload }, |m: &mut NEMDecryptMessage| { &mut m.payload }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMDecryptMessage", fields, oneofs, ) } } impl ::protobuf::Message for NEMDecryptMessage { const NAME: &'static str = "NEMDecryptMessage"; fn is_initialized(&self) -> bool { true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { is.read_repeated_packed_uint32_into(&mut self.address_n)?; }, 8 => { self.address_n.push(is.read_uint32()?); }, 16 => { self.network = ::std::option::Option::Some(is.read_uint32()?); }, 26 => { self.public_key = ::std::option::Option::Some(is.read_bytes()?); }, 34 => { self.payload = ::std::option::Option::Some(is.read_bytes()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; for value in &self.address_n { my_size += ::protobuf::rt::uint32_size(1, *value); }; if let Some(v) = self.network { my_size += ::protobuf::rt::uint32_size(2, v); } if let Some(v) = self.public_key.as_ref() { my_size += ::protobuf::rt::bytes_size(3, &v); } if let Some(v) = self.payload.as_ref() { my_size += ::protobuf::rt::bytes_size(4, &v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { for v in &self.address_n { os.write_uint32(1, *v)?; }; if let Some(v) = self.network { os.write_uint32(2, v)?; } if let Some(v) = self.public_key.as_ref() { os.write_bytes(3, v)?; } if let Some(v) = self.payload.as_ref() { os.write_bytes(4, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMDecryptMessage { NEMDecryptMessage::new() } fn clear(&mut self) { self.address_n.clear(); self.network = ::std::option::Option::None; self.public_key = ::std::option::Option::None; self.payload = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMDecryptMessage { static instance: NEMDecryptMessage = NEMDecryptMessage { address_n: ::std::vec::Vec::new(), network: ::std::option::Option::None, public_key: ::std::option::Option::None, payload: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMDecryptMessage { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("NEMDecryptMessage").unwrap()).clone() } } impl ::std::fmt::Display for NEMDecryptMessage { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMDecryptMessage { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } // @@protoc_insertion_point(message:hw.trezor.messages.nem.NEMDecryptedMessage) #[derive(PartialEq,Clone,Default,Debug)] pub struct NEMDecryptedMessage { // message fields // @@protoc_insertion_point(field:hw.trezor.messages.nem.NEMDecryptedMessage.payload) pub payload: ::std::option::Option<::std::vec::Vec>, // special fields // @@protoc_insertion_point(special_field:hw.trezor.messages.nem.NEMDecryptedMessage.special_fields) pub special_fields: ::protobuf::SpecialFields, } impl<'a> ::std::default::Default for &'a NEMDecryptedMessage { fn default() -> &'a NEMDecryptedMessage { ::default_instance() } } impl NEMDecryptedMessage { pub fn new() -> NEMDecryptedMessage { ::std::default::Default::default() } // required bytes payload = 1; pub fn payload(&self) -> &[u8] { match self.payload.as_ref() { Some(v) => v, None => &[], } } pub fn clear_payload(&mut self) { self.payload = ::std::option::Option::None; } pub fn has_payload(&self) -> bool { self.payload.is_some() } // Param is passed by value, moved pub fn set_payload(&mut self, v: ::std::vec::Vec) { self.payload = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec { if self.payload.is_none() { self.payload = ::std::option::Option::Some(::std::vec::Vec::new()); } self.payload.as_mut().unwrap() } // Take field pub fn take_payload(&mut self) -> ::std::vec::Vec { self.payload.take().unwrap_or_else(|| ::std::vec::Vec::new()) } fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(1); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( "payload", |m: &NEMDecryptedMessage| { &m.payload }, |m: &mut NEMDecryptedMessage| { &mut m.payload }, )); ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( "NEMDecryptedMessage", fields, oneofs, ) } } impl ::protobuf::Message for NEMDecryptedMessage { const NAME: &'static str = "NEMDecryptedMessage"; fn is_initialized(&self) -> bool { if self.payload.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.payload = ::std::option::Option::Some(is.read_bytes()?); }, tag => { ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.payload.as_ref() { my_size += ::protobuf::rt::bytes_size(1, &v); } my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { if let Some(v) = self.payload.as_ref() { os.write_bytes(1, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &::protobuf::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { &mut self.special_fields } fn new() -> NEMDecryptedMessage { NEMDecryptedMessage::new() } fn clear(&mut self) { self.payload = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static NEMDecryptedMessage { static instance: NEMDecryptedMessage = NEMDecryptedMessage { payload: ::std::option::Option::None, special_fields: ::protobuf::SpecialFields::new(), }; &instance } } impl ::protobuf::MessageFull for NEMDecryptedMessage { fn descriptor() -> ::protobuf::reflect::MessageDescriptor { static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("NEMDecryptedMessage").unwrap()).clone() } } impl ::std::fmt::Display for NEMDecryptedMessage { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for NEMDecryptedMessage { type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; } static file_descriptor_proto_data: &'static [u8] = b"\ \n\x12messages-nem.proto\x12\x16hw.trezor.messages.nem\"\x8a\x01\n\rNEMG\ etAddress\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12\x1d\n\ \x07network\x18\x02\x20\x01(\r:\x03104R\x07network\x12!\n\x0cshow_displa\ y\x18\x03\x20\x01(\x08R\x0bshowDisplay\x12\x1a\n\x08chunkify\x18\x04\x20\ \x01(\x08R\x08chunkify\"&\n\nNEMAddress\x12\x18\n\x07address\x18\x01\x20\ \x02(\tR\x07address\"\xa2\x19\n\tNEMSignTx\x12X\n\x0btransaction\x18\x01\ \x20\x02(\x0b26.hw.trezor.messages.nem.NEMSignTx.NEMTransactionCommonR\ \x0btransaction\x12R\n\x08multisig\x18\x02\x20\x01(\x0b26.hw.trezor.mess\ ages.nem.NEMSignTx.NEMTransactionCommonR\x08multisig\x12I\n\x08transfer\ \x18\x03\x20\x01(\x0b2-.hw.trezor.messages.nem.NEMSignTx.NEMTransferR\ \x08transfer\x12\x1c\n\tcosigning\x18\x04\x20\x01(\x08R\tcosigning\x12h\ \n\x13provision_namespace\x18\x05\x20\x01(\x0b27.hw.trezor.messages.nem.\ NEMSignTx.NEMProvisionNamespaceR\x12provisionNamespace\x12\\\n\x0fmosaic\ _creation\x18\x06\x20\x01(\x0b23.hw.trezor.messages.nem.NEMSignTx.NEMMos\ aicCreationR\x0emosaicCreation\x12\\\n\rsupply_change\x18\x07\x20\x01(\ \x0b27.hw.trezor.messages.nem.NEMSignTx.NEMMosaicSupplyChangeR\x0csupply\ Change\x12q\n\x16aggregate_modification\x18\x08\x20\x01(\x0b2:.hw.trezor\ .messages.nem.NEMSignTx.NEMAggregateModificationR\x15aggregateModificati\ on\x12h\n\x13importance_transfer\x18\t\x20\x01(\x0b27.hw.trezor.messages\ .nem.NEMSignTx.NEMImportanceTransferR\x12importanceTransfer\x12\x1a\n\ \x08chunkify\x18\n\x20\x01(\x08R\x08chunkify\x1a\xb6\x01\n\x14NEMTransac\ tionCommon\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12\x1d\ \n\x07network\x18\x02\x20\x01(\r:\x03104R\x07network\x12\x1c\n\ttimestam\ p\x18\x03\x20\x02(\rR\ttimestamp\x12\x10\n\x03fee\x18\x04\x20\x02(\x04R\ \x03fee\x12\x1a\n\x08deadline\x18\x05\x20\x02(\rR\x08deadline\x12\x16\n\ \x06signer\x18\x06\x20\x01(\x0cR\x06signer\x1a\xae\x02\n\x0bNEMTransfer\ \x12\x1c\n\trecipient\x18\x01\x20\x02(\tR\trecipient\x12\x16\n\x06amount\ \x18\x02\x20\x02(\x04R\x06amount\x12\x18\n\x07payload\x18\x03\x20\x01(\ \x0cR\x07payload\x12\x1d\n\npublic_key\x18\x04\x20\x01(\x0cR\tpublicKey\ \x12Q\n\x07mosaics\x18\x05\x20\x03(\x0b27.hw.trezor.messages.nem.NEMSign\ Tx.NEMTransfer.NEMMosaicR\x07mosaics\x1a]\n\tNEMMosaic\x12\x1c\n\tnamesp\ ace\x18\x01\x20\x02(\tR\tnamespace\x12\x16\n\x06mosaic\x18\x02\x20\x02(\ \tR\x06mosaic\x12\x1a\n\x08quantity\x18\x03\x20\x02(\x04R\x08quantity\ \x1as\n\x15NEMProvisionNamespace\x12\x1c\n\tnamespace\x18\x01\x20\x02(\t\ R\tnamespace\x12\x16\n\x06parent\x18\x02\x20\x01(\tR\x06parent\x12\x12\n\ \x04sink\x18\x03\x20\x02(\tR\x04sink\x12\x10\n\x03fee\x18\x04\x20\x02(\ \x04R\x03fee\x1a\x8e\x06\n\x11NEMMosaicCreation\x12g\n\ndefinition\x18\ \x01\x20\x02(\x0b2G.hw.trezor.messages.nem.NEMSignTx.NEMMosaicCreation.N\ EMMosaicDefinitionR\ndefinition\x12\x12\n\x04sink\x18\x02\x20\x02(\tR\ \x04sink\x12\x10\n\x03fee\x18\x03\x20\x02(\x04R\x03fee\x1a\xe9\x04\n\x13\ NEMMosaicDefinition\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\ \x16\n\x06ticker\x18\x02\x20\x01(\tR\x06ticker\x12\x1c\n\tnamespace\x18\ \x03\x20\x02(\tR\tnamespace\x12\x16\n\x06mosaic\x18\x04\x20\x02(\tR\x06m\ osaic\x12\"\n\x0cdivisibility\x18\x05\x20\x01(\rR\x0cdivisibility\x12i\n\ \x04levy\x18\x06\x20\x01(\x0e2U.hw.trezor.messages.nem.NEMSignTx.NEMMosa\ icCreation.NEMMosaicDefinition.NEMMosaicLevyR\x04levy\x12\x10\n\x03fee\ \x18\x07\x20\x01(\x04R\x03fee\x12!\n\x0clevy_address\x18\x08\x20\x01(\tR\ \x0blevyAddress\x12%\n\x0elevy_namespace\x18\t\x20\x01(\tR\rlevyNamespac\ e\x12\x1f\n\x0blevy_mosaic\x18\n\x20\x01(\tR\nlevyMosaic\x12\x16\n\x06su\ pply\x18\x0b\x20\x01(\x04R\x06supply\x12%\n\x0emutable_supply\x18\x0c\ \x20\x01(\x08R\rmutableSupply\x12\"\n\x0ctransferable\x18\r\x20\x01(\x08\ R\x0ctransferable\x12\x20\n\x0bdescription\x18\x0e\x20\x02(\tR\x0bdescri\ ption\x12\x1a\n\x08networks\x18\x0f\x20\x03(\rR\x08networks\"C\n\rNEMMos\ aicLevy\x12\x17\n\x13MosaicLevy_Absolute\x10\x01\x12\x19\n\x15MosaicLevy\ _Percentile\x10\x02\x1a\x91\x02\n\x15NEMMosaicSupplyChange\x12\x1c\n\tna\ mespace\x18\x01\x20\x02(\tR\tnamespace\x12\x16\n\x06mosaic\x18\x02\x20\ \x02(\tR\x06mosaic\x12_\n\x04type\x18\x03\x20\x02(\x0e2K.hw.trezor.messa\ ges.nem.NEMSignTx.NEMMosaicSupplyChange.NEMSupplyChangeTypeR\x04type\x12\ \x14\n\x05delta\x18\x04\x20\x02(\x04R\x05delta\"K\n\x13NEMSupplyChangeTy\ pe\x12\x19\n\x15SupplyChange_Increase\x10\x01\x12\x19\n\x15SupplyChange_\ Decrease\x10\x02\x1a\xd9\x03\n\x18NEMAggregateModification\x12{\n\rmodif\ ications\x18\x01\x20\x03(\x0b2U.hw.trezor.messages.nem.NEMSignTx.NEMAggr\ egateModification.NEMCosignatoryModificationR\rmodifications\x12'\n\x0fr\ elative_change\x18\x02\x20\x01(\x11R\x0erelativeChange\x1a\x96\x02\n\x1a\ NEMCosignatoryModification\x12}\n\x04type\x18\x01\x20\x02(\x0e2i.hw.trez\ or.messages.nem.NEMSignTx.NEMAggregateModification.NEMCosignatoryModific\ ation.NEMModificationTypeR\x04type\x12\x1d\n\npublic_key\x18\x02\x20\x02\ (\x0cR\tpublicKey\"Z\n\x13NEMModificationType\x12\x1f\n\x1bCosignatoryMo\ dification_Add\x10\x01\x12\"\n\x1eCosignatoryModification_Delete\x10\x02\ \x1a\xfe\x01\n\x15NEMImportanceTransfer\x12e\n\x04mode\x18\x01\x20\x02(\ \x0e2Q.hw.trezor.messages.nem.NEMSignTx.NEMImportanceTransfer.NEMImporta\ nceTransferModeR\x04mode\x12\x1d\n\npublic_key\x18\x02\x20\x02(\x0cR\tpu\ blicKey\"_\n\x19NEMImportanceTransferMode\x12\x1f\n\x1bImportanceTransfe\ r_Activate\x10\x01\x12!\n\x1dImportanceTransfer_Deactivate\x10\x02\"?\n\ \x0bNEMSignedTx\x12\x12\n\x04data\x18\x01\x20\x02(\x0cR\x04data\x12\x1c\ \n\tsignature\x18\x02\x20\x02(\x0cR\tsignature\"\x83\x01\n\x11NEMDecrypt\ Message\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12\x18\n\ \x07network\x18\x02\x20\x01(\rR\x07network\x12\x1d\n\npublic_key\x18\x03\ \x20\x01(\x0cR\tpublicKey\x12\x18\n\x07payload\x18\x04\x20\x01(\x0cR\x07\ payload\"/\n\x13NEMDecryptedMessage\x12\x18\n\x07payload\x18\x01\x20\x02\ (\x0cR\x07payloadB7\n#com.satoshilabs.trezor.lib.protobufB\x10TrezorMess\ ageNem\ "; /// `FileDescriptorProto` object which was a source for this generated file fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new(); file_descriptor_proto_lazy.get(|| { ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap() }) } /// `FileDescriptor` object which allows dynamic access to files pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor { static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new(); static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new(); file_descriptor.get(|| { let generated_file_descriptor = generated_file_descriptor_lazy.get(|| { let mut deps = ::std::vec::Vec::with_capacity(0); let mut messages = ::std::vec::Vec::with_capacity(16); messages.push(NEMGetAddress::generated_message_descriptor_data()); messages.push(NEMAddress::generated_message_descriptor_data()); messages.push(NEMSignTx::generated_message_descriptor_data()); messages.push(NEMSignedTx::generated_message_descriptor_data()); messages.push(NEMDecryptMessage::generated_message_descriptor_data()); messages.push(NEMDecryptedMessage::generated_message_descriptor_data()); messages.push(nemsign_tx::NEMTransactionCommon::generated_message_descriptor_data()); messages.push(nemsign_tx::NEMTransfer::generated_message_descriptor_data()); messages.push(nemsign_tx::NEMProvisionNamespace::generated_message_descriptor_data()); messages.push(nemsign_tx::NEMMosaicCreation::generated_message_descriptor_data()); messages.push(nemsign_tx::NEMMosaicSupplyChange::generated_message_descriptor_data()); messages.push(nemsign_tx::NEMAggregateModification::generated_message_descriptor_data()); messages.push(nemsign_tx::NEMImportanceTransfer::generated_message_descriptor_data()); messages.push(nemsign_tx::nemtransfer::NEMMosaic::generated_message_descriptor_data()); messages.push(nemsign_tx::nemmosaic_creation::NEMMosaicDefinition::generated_message_descriptor_data()); messages.push(nemsign_tx::nemaggregate_modification::NEMCosignatoryModification::generated_message_descriptor_data()); let mut enums = ::std::vec::Vec::with_capacity(4); enums.push(nemsign_tx::nemmosaic_creation::nemmosaic_definition::NEMMosaicLevy::generated_enum_descriptor_data()); enums.push(nemsign_tx::nemmosaic_supply_change::NEMSupplyChangeType::generated_enum_descriptor_data()); enums.push(nemsign_tx::nemaggregate_modification::nemcosignatory_modification::NEMModificationType::generated_enum_descriptor_data()); enums.push(nemsign_tx::nemimportance_transfer::NEMImportanceTransferMode::generated_enum_descriptor_data()); ::protobuf::reflect::GeneratedFileDescriptor::new_generated( file_descriptor_proto(), deps, messages, enums, ) }); ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor) }) }