trezorlib 0.0.2

// This file is generated by rust-protobuf 2.25.2. Do not edit
// @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_imports)]
#![allow(unused_results)]
//! Generated file from `messages-crypto.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;

#[derive(PartialEq,Clone,Default)]
pub struct CipherKeyValue {
    // message fields
    pub address_n: ::std::vec::Vec<u32>,
    key: ::protobuf::SingularField<::std::string::String>,
    value: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    encrypt: ::std::option::Option<bool>,
    ask_on_encrypt: ::std::option::Option<bool>,
    ask_on_decrypt: ::std::option::Option<bool>,
    iv: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CipherKeyValue {
    fn default() -> &'a CipherKeyValue {
        <CipherKeyValue as ::protobuf::Message>::default_instance()
    }
}

impl CipherKeyValue {
    pub fn new() -> CipherKeyValue {
        ::std::default::Default::default()
    }

    // repeated uint32 address_n = 1;


    pub fn get_address_n(&self) -> &[u32] {
        &self.address_n
    }
    pub fn clear_address_n(&mut self) {
        self.address_n.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_n(&mut self, v: ::std::vec::Vec<u32>) {
        self.address_n = v;
    }

    // Mutable pointer to the field.
    pub fn mut_address_n(&mut self) -> &mut ::std::vec::Vec<u32> {
        &mut self.address_n
    }

    // Take field
    pub fn take_address_n(&mut self) -> ::std::vec::Vec<u32> {
        ::std::mem::replace(&mut self.address_n, ::std::vec::Vec::new())
    }

    // required string key = 2;


    pub fn get_key(&self) -> &str {
        match self.key.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_key(&mut self) {
        self.key.clear();
    }

    pub fn has_key(&self) -> bool {
        self.key.is_some()
    }

    // Param is passed by value, moved
    pub fn set_key(&mut self, v: ::std::string::String) {
        self.key = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_key(&mut self) -> &mut ::std::string::String {
        if self.key.is_none() {
            self.key.set_default();
        }
        self.key.as_mut().unwrap()
    }

    // Take field
    pub fn take_key(&mut self) -> ::std::string::String {
        self.key.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // required bytes value = 3;


    pub fn get_value(&self) -> &[u8] {
        match self.value.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    pub fn has_value(&self) -> bool {
        self.value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
        self.value = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.value.is_none() {
            self.value.set_default();
        }
        self.value.as_mut().unwrap()
    }

    // Take field
    pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
        self.value.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bool encrypt = 4;


    pub fn get_encrypt(&self) -> bool {
        self.encrypt.unwrap_or(false)
    }
    pub fn clear_encrypt(&mut self) {
        self.encrypt = ::std::option::Option::None;
    }

    pub fn has_encrypt(&self) -> bool {
        self.encrypt.is_some()
    }

    // Param is passed by value, moved
    pub fn set_encrypt(&mut self, v: bool) {
        self.encrypt = ::std::option::Option::Some(v);
    }

    // optional bool ask_on_encrypt = 5;


    pub fn get_ask_on_encrypt(&self) -> bool {
        self.ask_on_encrypt.unwrap_or(false)
    }
    pub fn clear_ask_on_encrypt(&mut self) {
        self.ask_on_encrypt = ::std::option::Option::None;
    }

    pub fn has_ask_on_encrypt(&self) -> bool {
        self.ask_on_encrypt.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ask_on_encrypt(&mut self, v: bool) {
        self.ask_on_encrypt = ::std::option::Option::Some(v);
    }

    // optional bool ask_on_decrypt = 6;


    pub fn get_ask_on_decrypt(&self) -> bool {
        self.ask_on_decrypt.unwrap_or(false)
    }
    pub fn clear_ask_on_decrypt(&mut self) {
        self.ask_on_decrypt = ::std::option::Option::None;
    }

    pub fn has_ask_on_decrypt(&self) -> bool {
        self.ask_on_decrypt.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ask_on_decrypt(&mut self, v: bool) {
        self.ask_on_decrypt = ::std::option::Option::Some(v);
    }

    // optional bytes iv = 7;


    pub fn get_iv(&self) -> &[u8] {
        match self.iv.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_iv(&mut self) {
        self.iv.clear();
    }

    pub fn has_iv(&self) -> bool {
        self.iv.is_some()
    }

    // Param is passed by value, moved
    pub fn set_iv(&mut self, v: ::std::vec::Vec<u8>) {
        self.iv = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_iv(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.iv.is_none() {
            self.iv.set_default();
        }
        self.iv.as_mut().unwrap()
    }

    // Take field
    pub fn take_iv(&mut self) -> ::std::vec::Vec<u8> {
        self.iv.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CipherKeyValue {
    fn is_initialized(&self) -> bool {
        if self.key.is_none() {
            return false;
        }
        if self.value.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.address_n)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.key)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.value)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.encrypt = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.ask_on_encrypt = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.ask_on_decrypt = ::std::option::Option::Some(tmp);
                },
                7 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.iv)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.address_n {
            my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if let Some(ref v) = self.key.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(ref v) = self.value.as_ref() {
            my_size += ::protobuf::rt::bytes_size(3, &v);
        }
        if let Some(v) = self.encrypt {
            my_size += 2;
        }
        if let Some(v) = self.ask_on_encrypt {
            my_size += 2;
        }
        if let Some(v) = self.ask_on_decrypt {
            my_size += 2;
        }
        if let Some(ref v) = self.iv.as_ref() {
            my_size += ::protobuf::rt::bytes_size(7, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.address_n {
            os.write_uint32(1, *v)?;
        };
        if let Some(ref v) = self.key.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(ref v) = self.value.as_ref() {
            os.write_bytes(3, &v)?;
        }
        if let Some(v) = self.encrypt {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.ask_on_encrypt {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.ask_on_decrypt {
            os.write_bool(6, v)?;
        }
        if let Some(ref v) = self.iv.as_ref() {
            os.write_bytes(7, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CipherKeyValue {
        CipherKeyValue::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "address_n",
                |m: &CipherKeyValue| { &m.address_n },
                |m: &mut CipherKeyValue| { &mut m.address_n },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "key",
                |m: &CipherKeyValue| { &m.key },
                |m: &mut CipherKeyValue| { &mut m.key },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "value",
                |m: &CipherKeyValue| { &m.value },
                |m: &mut CipherKeyValue| { &mut m.value },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "encrypt",
                |m: &CipherKeyValue| { &m.encrypt },
                |m: &mut CipherKeyValue| { &mut m.encrypt },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "ask_on_encrypt",
                |m: &CipherKeyValue| { &m.ask_on_encrypt },
                |m: &mut CipherKeyValue| { &mut m.ask_on_encrypt },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "ask_on_decrypt",
                |m: &CipherKeyValue| { &m.ask_on_decrypt },
                |m: &mut CipherKeyValue| { &mut m.ask_on_decrypt },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "iv",
                |m: &CipherKeyValue| { &m.iv },
                |m: &mut CipherKeyValue| { &mut m.iv },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CipherKeyValue>(
                "CipherKeyValue",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CipherKeyValue {
        static instance: ::protobuf::rt::LazyV2<CipherKeyValue> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CipherKeyValue::new)
    }
}

impl ::protobuf::Clear for CipherKeyValue {
    fn clear(&mut self) {
        self.address_n.clear();
        self.key.clear();
        self.value.clear();
        self.encrypt = ::std::option::Option::None;
        self.ask_on_encrypt = ::std::option::Option::None;
        self.ask_on_decrypt = ::std::option::Option::None;
        self.iv.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CipherKeyValue {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CipherKeyValue {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CipheredKeyValue {
    // message fields
    value: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CipheredKeyValue {
    fn default() -> &'a CipheredKeyValue {
        <CipheredKeyValue as ::protobuf::Message>::default_instance()
    }
}

impl CipheredKeyValue {
    pub fn new() -> CipheredKeyValue {
        ::std::default::Default::default()
    }

    // required bytes value = 1;


    pub fn get_value(&self) -> &[u8] {
        match self.value.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    pub fn has_value(&self) -> bool {
        self.value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
        self.value = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.value.is_none() {
            self.value.set_default();
        }
        self.value.as_mut().unwrap()
    }

    // Take field
    pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
        self.value.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CipheredKeyValue {
    fn is_initialized(&self) -> bool {
        if self.value.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.value)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.value.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.value.as_ref() {
            os.write_bytes(1, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CipheredKeyValue {
        CipheredKeyValue::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "value",
                |m: &CipheredKeyValue| { &m.value },
                |m: &mut CipheredKeyValue| { &mut m.value },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CipheredKeyValue>(
                "CipheredKeyValue",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CipheredKeyValue {
        static instance: ::protobuf::rt::LazyV2<CipheredKeyValue> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CipheredKeyValue::new)
    }
}

impl ::protobuf::Clear for CipheredKeyValue {
    fn clear(&mut self) {
        self.value.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CipheredKeyValue {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CipheredKeyValue {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct IdentityType {
    // message fields
    proto: ::protobuf::SingularField<::std::string::String>,
    user: ::protobuf::SingularField<::std::string::String>,
    host: ::protobuf::SingularField<::std::string::String>,
    port: ::protobuf::SingularField<::std::string::String>,
    path: ::protobuf::SingularField<::std::string::String>,
    index: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a IdentityType {
    fn default() -> &'a IdentityType {
        <IdentityType as ::protobuf::Message>::default_instance()
    }
}

impl IdentityType {
    pub fn new() -> IdentityType {
        ::std::default::Default::default()
    }

    // optional string proto = 1;


    pub fn get_proto(&self) -> &str {
        match self.proto.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_proto(&mut self) {
        self.proto.clear();
    }

    pub fn has_proto(&self) -> bool {
        self.proto.is_some()
    }

    // Param is passed by value, moved
    pub fn set_proto(&mut self, v: ::std::string::String) {
        self.proto = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_proto(&mut self) -> &mut ::std::string::String {
        if self.proto.is_none() {
            self.proto.set_default();
        }
        self.proto.as_mut().unwrap()
    }

    // Take field
    pub fn take_proto(&mut self) -> ::std::string::String {
        self.proto.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string user = 2;


    pub fn get_user(&self) -> &str {
        match self.user.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_user(&mut self) {
        self.user.clear();
    }

    pub fn has_user(&self) -> bool {
        self.user.is_some()
    }

    // Param is passed by value, moved
    pub fn set_user(&mut self, v: ::std::string::String) {
        self.user = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_user(&mut self) -> &mut ::std::string::String {
        if self.user.is_none() {
            self.user.set_default();
        }
        self.user.as_mut().unwrap()
    }

    // Take field
    pub fn take_user(&mut self) -> ::std::string::String {
        self.user.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string host = 3;


    pub fn get_host(&self) -> &str {
        match self.host.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_host(&mut self) {
        self.host.clear();
    }

    pub fn has_host(&self) -> bool {
        self.host.is_some()
    }

    // Param is passed by value, moved
    pub fn set_host(&mut self, v: ::std::string::String) {
        self.host = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_host(&mut self) -> &mut ::std::string::String {
        if self.host.is_none() {
            self.host.set_default();
        }
        self.host.as_mut().unwrap()
    }

    // Take field
    pub fn take_host(&mut self) -> ::std::string::String {
        self.host.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string port = 4;


    pub fn get_port(&self) -> &str {
        match self.port.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_port(&mut self) {
        self.port.clear();
    }

    pub fn has_port(&self) -> bool {
        self.port.is_some()
    }

    // Param is passed by value, moved
    pub fn set_port(&mut self, v: ::std::string::String) {
        self.port = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_port(&mut self) -> &mut ::std::string::String {
        if self.port.is_none() {
            self.port.set_default();
        }
        self.port.as_mut().unwrap()
    }

    // Take field
    pub fn take_port(&mut self) -> ::std::string::String {
        self.port.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string path = 5;


    pub fn get_path(&self) -> &str {
        match self.path.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_path(&mut self) {
        self.path.clear();
    }

    pub fn has_path(&self) -> bool {
        self.path.is_some()
    }

    // Param is passed by value, moved
    pub fn set_path(&mut self, v: ::std::string::String) {
        self.path = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_path(&mut self) -> &mut ::std::string::String {
        if self.path.is_none() {
            self.path.set_default();
        }
        self.path.as_mut().unwrap()
    }

    // Take field
    pub fn take_path(&mut self) -> ::std::string::String {
        self.path.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional uint32 index = 6;


    pub fn get_index(&self) -> u32 {
        self.index.unwrap_or(0u32)
    }
    pub fn clear_index(&mut self) {
        self.index = ::std::option::Option::None;
    }

    pub fn has_index(&self) -> bool {
        self.index.is_some()
    }

    // Param is passed by value, moved
    pub fn set_index(&mut self, v: u32) {
        self.index = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for IdentityType {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.proto)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.user)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.host)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.port)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.path)?;
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.index = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.proto.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.user.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(ref v) = self.host.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.port.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(ref v) = self.path.as_ref() {
            my_size += ::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.index {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.proto.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.user.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(ref v) = self.host.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.port.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(ref v) = self.path.as_ref() {
            os.write_string(5, &v)?;
        }
        if let Some(v) = self.index {
            os.write_uint32(6, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> IdentityType {
        IdentityType::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "proto",
                |m: &IdentityType| { &m.proto },
                |m: &mut IdentityType| { &mut m.proto },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "user",
                |m: &IdentityType| { &m.user },
                |m: &mut IdentityType| { &mut m.user },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "host",
                |m: &IdentityType| { &m.host },
                |m: &mut IdentityType| { &mut m.host },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "port",
                |m: &IdentityType| { &m.port },
                |m: &mut IdentityType| { &mut m.port },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "path",
                |m: &IdentityType| { &m.path },
                |m: &mut IdentityType| { &mut m.path },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "index",
                |m: &IdentityType| { &m.index },
                |m: &mut IdentityType| { &mut m.index },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<IdentityType>(
                "IdentityType",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static IdentityType {
        static instance: ::protobuf::rt::LazyV2<IdentityType> = ::protobuf::rt::LazyV2::INIT;
        instance.get(IdentityType::new)
    }
}

impl ::protobuf::Clear for IdentityType {
    fn clear(&mut self) {
        self.proto.clear();
        self.user.clear();
        self.host.clear();
        self.port.clear();
        self.path.clear();
        self.index = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for IdentityType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for IdentityType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct SignIdentity {
    // message fields
    pub identity: ::protobuf::SingularPtrField<IdentityType>,
    challenge_hidden: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    challenge_visual: ::protobuf::SingularField<::std::string::String>,
    ecdsa_curve_name: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a SignIdentity {
    fn default() -> &'a SignIdentity {
        <SignIdentity as ::protobuf::Message>::default_instance()
    }
}

impl SignIdentity {
    pub fn new() -> SignIdentity {
        ::std::default::Default::default()
    }

    // required .hw.trezor.messages.crypto.IdentityType identity = 1;


    pub fn get_identity(&self) -> &IdentityType {
        self.identity.as_ref().unwrap_or_else(|| <IdentityType as ::protobuf::Message>::default_instance())
    }
    pub fn clear_identity(&mut self) {
        self.identity.clear();
    }

    pub fn has_identity(&self) -> bool {
        self.identity.is_some()
    }

    // Param is passed by value, moved
    pub fn set_identity(&mut self, v: IdentityType) {
        self.identity = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_identity(&mut self) -> &mut IdentityType {
        if self.identity.is_none() {
            self.identity.set_default();
        }
        self.identity.as_mut().unwrap()
    }

    // Take field
    pub fn take_identity(&mut self) -> IdentityType {
        self.identity.take().unwrap_or_else(|| IdentityType::new())
    }

    // optional bytes challenge_hidden = 2;


    pub fn get_challenge_hidden(&self) -> &[u8] {
        match self.challenge_hidden.as_ref() {
            Some(v) => &v,
            None => b"",
        }
    }
    pub fn clear_challenge_hidden(&mut self) {
        self.challenge_hidden.clear();
    }

    pub fn has_challenge_hidden(&self) -> bool {
        self.challenge_hidden.is_some()
    }

    // Param is passed by value, moved
    pub fn set_challenge_hidden(&mut self, v: ::std::vec::Vec<u8>) {
        self.challenge_hidden = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_challenge_hidden(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.challenge_hidden.is_none() {
            self.challenge_hidden.set_default();
        }
        self.challenge_hidden.as_mut().unwrap()
    }

    // Take field
    pub fn take_challenge_hidden(&mut self) -> ::std::vec::Vec<u8> {
        self.challenge_hidden.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional string challenge_visual = 3;


    pub fn get_challenge_visual(&self) -> &str {
        match self.challenge_visual.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_challenge_visual(&mut self) {
        self.challenge_visual.clear();
    }

    pub fn has_challenge_visual(&self) -> bool {
        self.challenge_visual.is_some()
    }

    // Param is passed by value, moved
    pub fn set_challenge_visual(&mut self, v: ::std::string::String) {
        self.challenge_visual = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_challenge_visual(&mut self) -> &mut ::std::string::String {
        if self.challenge_visual.is_none() {
            self.challenge_visual.set_default();
        }
        self.challenge_visual.as_mut().unwrap()
    }

    // Take field
    pub fn take_challenge_visual(&mut self) -> ::std::string::String {
        self.challenge_visual.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string ecdsa_curve_name = 4;


    pub fn get_ecdsa_curve_name(&self) -> &str {
        match self.ecdsa_curve_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_ecdsa_curve_name(&mut self) {
        self.ecdsa_curve_name.clear();
    }

    pub fn has_ecdsa_curve_name(&self) -> bool {
        self.ecdsa_curve_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ecdsa_curve_name(&mut self, v: ::std::string::String) {
        self.ecdsa_curve_name = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_ecdsa_curve_name(&mut self) -> &mut ::std::string::String {
        if self.ecdsa_curve_name.is_none() {
            self.ecdsa_curve_name.set_default();
        }
        self.ecdsa_curve_name.as_mut().unwrap()
    }

    // Take field
    pub fn take_ecdsa_curve_name(&mut self) -> ::std::string::String {
        self.ecdsa_curve_name.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::protobuf::Message for SignIdentity {
    fn is_initialized(&self) -> bool {
        if self.identity.is_none() {
            return false;
        }
        for v in &self.identity {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.identity)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.challenge_hidden)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.challenge_visual)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.ecdsa_curve_name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.identity.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.challenge_hidden.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(ref v) = self.challenge_visual.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.ecdsa_curve_name.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.identity.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.challenge_hidden.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(ref v) = self.challenge_visual.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.ecdsa_curve_name.as_ref() {
            os.write_string(4, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> SignIdentity {
        SignIdentity::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<IdentityType>>(
                "identity",
                |m: &SignIdentity| { &m.identity },
                |m: &mut SignIdentity| { &mut m.identity },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "challenge_hidden",
                |m: &SignIdentity| { &m.challenge_hidden },
                |m: &mut SignIdentity| { &mut m.challenge_hidden },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "challenge_visual",
                |m: &SignIdentity| { &m.challenge_visual },
                |m: &mut SignIdentity| { &mut m.challenge_visual },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "ecdsa_curve_name",
                |m: &SignIdentity| { &m.ecdsa_curve_name },
                |m: &mut SignIdentity| { &mut m.ecdsa_curve_name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SignIdentity>(
                "SignIdentity",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SignIdentity {
        static instance: ::protobuf::rt::LazyV2<SignIdentity> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SignIdentity::new)
    }
}

impl ::protobuf::Clear for SignIdentity {
    fn clear(&mut self) {
        self.identity.clear();
        self.challenge_hidden.clear();
        self.challenge_visual.clear();
        self.ecdsa_curve_name.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for SignIdentity {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for SignIdentity {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct SignedIdentity {
    // message fields
    address: ::protobuf::SingularField<::std::string::String>,
    public_key: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a SignedIdentity {
    fn default() -> &'a SignedIdentity {
        <SignedIdentity as ::protobuf::Message>::default_instance()
    }
}

impl SignedIdentity {
    pub fn new() -> SignedIdentity {
        ::std::default::Default::default()
    }

    // optional string address = 1;


    pub fn get_address(&self) -> &str {
        match self.address.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_address(&mut self) {
        self.address.clear();
    }

    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 = ::protobuf::SingularField::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.set_default();
        }
        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())
    }

    // required bytes public_key = 2;


    pub fn get_public_key(&self) -> &[u8] {
        match self.public_key.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_public_key(&mut self) {
        self.public_key.clear();
    }

    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<u8>) {
        self.public_key = ::protobuf::SingularField::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<u8> {
        if self.public_key.is_none() {
            self.public_key.set_default();
        }
        self.public_key.as_mut().unwrap()
    }

    // Take field
    pub fn take_public_key(&mut self) -> ::std::vec::Vec<u8> {
        self.public_key.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // required bytes signature = 3;


    pub fn get_signature(&self) -> &[u8] {
        match self.signature.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_signature(&mut self) {
        self.signature.clear();
    }

    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<u8>) {
        self.signature = ::protobuf::SingularField::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<u8> {
        if self.signature.is_none() {
            self.signature.set_default();
        }
        self.signature.as_mut().unwrap()
    }

    // Take field
    pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
        self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for SignedIdentity {
    fn is_initialized(&self) -> bool {
        if self.public_key.is_none() {
            return false;
        }
        if self.signature.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.address)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.public_key)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.address.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.public_key.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(ref v) = self.signature.as_ref() {
            my_size += ::protobuf::rt::bytes_size(3, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.address.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.public_key.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(ref v) = self.signature.as_ref() {
            os.write_bytes(3, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> SignedIdentity {
        SignedIdentity::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "address",
                |m: &SignedIdentity| { &m.address },
                |m: &mut SignedIdentity| { &mut m.address },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "public_key",
                |m: &SignedIdentity| { &m.public_key },
                |m: &mut SignedIdentity| { &mut m.public_key },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "signature",
                |m: &SignedIdentity| { &m.signature },
                |m: &mut SignedIdentity| { &mut m.signature },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SignedIdentity>(
                "SignedIdentity",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SignedIdentity {
        static instance: ::protobuf::rt::LazyV2<SignedIdentity> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SignedIdentity::new)
    }
}

impl ::protobuf::Clear for SignedIdentity {
    fn clear(&mut self) {
        self.address.clear();
        self.public_key.clear();
        self.signature.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for SignedIdentity {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for SignedIdentity {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct GetECDHSessionKey {
    // message fields
    pub identity: ::protobuf::SingularPtrField<IdentityType>,
    peer_public_key: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    ecdsa_curve_name: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a GetECDHSessionKey {
    fn default() -> &'a GetECDHSessionKey {
        <GetECDHSessionKey as ::protobuf::Message>::default_instance()
    }
}

impl GetECDHSessionKey {
    pub fn new() -> GetECDHSessionKey {
        ::std::default::Default::default()
    }

    // required .hw.trezor.messages.crypto.IdentityType identity = 1;


    pub fn get_identity(&self) -> &IdentityType {
        self.identity.as_ref().unwrap_or_else(|| <IdentityType as ::protobuf::Message>::default_instance())
    }
    pub fn clear_identity(&mut self) {
        self.identity.clear();
    }

    pub fn has_identity(&self) -> bool {
        self.identity.is_some()
    }

    // Param is passed by value, moved
    pub fn set_identity(&mut self, v: IdentityType) {
        self.identity = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_identity(&mut self) -> &mut IdentityType {
        if self.identity.is_none() {
            self.identity.set_default();
        }
        self.identity.as_mut().unwrap()
    }

    // Take field
    pub fn take_identity(&mut self) -> IdentityType {
        self.identity.take().unwrap_or_else(|| IdentityType::new())
    }

    // required bytes peer_public_key = 2;


    pub fn get_peer_public_key(&self) -> &[u8] {
        match self.peer_public_key.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_peer_public_key(&mut self) {
        self.peer_public_key.clear();
    }

    pub fn has_peer_public_key(&self) -> bool {
        self.peer_public_key.is_some()
    }

    // Param is passed by value, moved
    pub fn set_peer_public_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.peer_public_key = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_peer_public_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.peer_public_key.is_none() {
            self.peer_public_key.set_default();
        }
        self.peer_public_key.as_mut().unwrap()
    }

    // Take field
    pub fn take_peer_public_key(&mut self) -> ::std::vec::Vec<u8> {
        self.peer_public_key.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional string ecdsa_curve_name = 3;


    pub fn get_ecdsa_curve_name(&self) -> &str {
        match self.ecdsa_curve_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_ecdsa_curve_name(&mut self) {
        self.ecdsa_curve_name.clear();
    }

    pub fn has_ecdsa_curve_name(&self) -> bool {
        self.ecdsa_curve_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ecdsa_curve_name(&mut self, v: ::std::string::String) {
        self.ecdsa_curve_name = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_ecdsa_curve_name(&mut self) -> &mut ::std::string::String {
        if self.ecdsa_curve_name.is_none() {
            self.ecdsa_curve_name.set_default();
        }
        self.ecdsa_curve_name.as_mut().unwrap()
    }

    // Take field
    pub fn take_ecdsa_curve_name(&mut self) -> ::std::string::String {
        self.ecdsa_curve_name.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::protobuf::Message for GetECDHSessionKey {
    fn is_initialized(&self) -> bool {
        if self.identity.is_none() {
            return false;
        }
        if self.peer_public_key.is_none() {
            return false;
        }
        for v in &self.identity {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.identity)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.peer_public_key)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.ecdsa_curve_name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.identity.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.peer_public_key.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(ref v) = self.ecdsa_curve_name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.identity.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.peer_public_key.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(ref v) = self.ecdsa_curve_name.as_ref() {
            os.write_string(3, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> GetECDHSessionKey {
        GetECDHSessionKey::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<IdentityType>>(
                "identity",
                |m: &GetECDHSessionKey| { &m.identity },
                |m: &mut GetECDHSessionKey| { &mut m.identity },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "peer_public_key",
                |m: &GetECDHSessionKey| { &m.peer_public_key },
                |m: &mut GetECDHSessionKey| { &mut m.peer_public_key },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "ecdsa_curve_name",
                |m: &GetECDHSessionKey| { &m.ecdsa_curve_name },
                |m: &mut GetECDHSessionKey| { &mut m.ecdsa_curve_name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetECDHSessionKey>(
                "GetECDHSessionKey",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static GetECDHSessionKey {
        static instance: ::protobuf::rt::LazyV2<GetECDHSessionKey> = ::protobuf::rt::LazyV2::INIT;
        instance.get(GetECDHSessionKey::new)
    }
}

impl ::protobuf::Clear for GetECDHSessionKey {
    fn clear(&mut self) {
        self.identity.clear();
        self.peer_public_key.clear();
        self.ecdsa_curve_name.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for GetECDHSessionKey {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for GetECDHSessionKey {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ECDHSessionKey {
    // message fields
    session_key: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    public_key: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ECDHSessionKey {
    fn default() -> &'a ECDHSessionKey {
        <ECDHSessionKey as ::protobuf::Message>::default_instance()
    }
}

impl ECDHSessionKey {
    pub fn new() -> ECDHSessionKey {
        ::std::default::Default::default()
    }

    // required bytes session_key = 1;


    pub fn get_session_key(&self) -> &[u8] {
        match self.session_key.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_session_key(&mut self) {
        self.session_key.clear();
    }

    pub fn has_session_key(&self) -> bool {
        self.session_key.is_some()
    }

    // Param is passed by value, moved
    pub fn set_session_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.session_key = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.session_key.is_none() {
            self.session_key.set_default();
        }
        self.session_key.as_mut().unwrap()
    }

    // Take field
    pub fn take_session_key(&mut self) -> ::std::vec::Vec<u8> {
        self.session_key.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bytes public_key = 2;


    pub fn get_public_key(&self) -> &[u8] {
        match self.public_key.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_public_key(&mut self) {
        self.public_key.clear();
    }

    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<u8>) {
        self.public_key = ::protobuf::SingularField::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<u8> {
        if self.public_key.is_none() {
            self.public_key.set_default();
        }
        self.public_key.as_mut().unwrap()
    }

    // Take field
    pub fn take_public_key(&mut self) -> ::std::vec::Vec<u8> {
        self.public_key.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for ECDHSessionKey {
    fn is_initialized(&self) -> bool {
        if self.session_key.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.session_key)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.public_key)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.session_key.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.public_key.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.session_key.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(ref v) = self.public_key.as_ref() {
            os.write_bytes(2, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ECDHSessionKey {
        ECDHSessionKey::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "session_key",
                |m: &ECDHSessionKey| { &m.session_key },
                |m: &mut ECDHSessionKey| { &mut m.session_key },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "public_key",
                |m: &ECDHSessionKey| { &m.public_key },
                |m: &mut ECDHSessionKey| { &mut m.public_key },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ECDHSessionKey>(
                "ECDHSessionKey",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ECDHSessionKey {
        static instance: ::protobuf::rt::LazyV2<ECDHSessionKey> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ECDHSessionKey::new)
    }
}

impl ::protobuf::Clear for ECDHSessionKey {
    fn clear(&mut self) {
        self.session_key.clear();
        self.public_key.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ECDHSessionKey {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ECDHSessionKey {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CosiCommit {
    // message fields
    pub address_n: ::std::vec::Vec<u32>,
    data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CosiCommit {
    fn default() -> &'a CosiCommit {
        <CosiCommit as ::protobuf::Message>::default_instance()
    }
}

impl CosiCommit {
    pub fn new() -> CosiCommit {
        ::std::default::Default::default()
    }

    // repeated uint32 address_n = 1;


    pub fn get_address_n(&self) -> &[u32] {
        &self.address_n
    }
    pub fn clear_address_n(&mut self) {
        self.address_n.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_n(&mut self, v: ::std::vec::Vec<u32>) {
        self.address_n = v;
    }

    // Mutable pointer to the field.
    pub fn mut_address_n(&mut self) -> &mut ::std::vec::Vec<u32> {
        &mut self.address_n
    }

    // Take field
    pub fn take_address_n(&mut self) -> ::std::vec::Vec<u32> {
        ::std::mem::replace(&mut self.address_n, ::std::vec::Vec::new())
    }

    // optional bytes data = 2;


    pub fn get_data(&self) -> &[u8] {
        match self.data.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_data(&mut self) {
        self.data.clear();
    }

    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<u8>) {
        self.data = ::protobuf::SingularField::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<u8> {
        if self.data.is_none() {
            self.data.set_default();
        }
        self.data.as_mut().unwrap()
    }

    // Take field
    pub fn take_data(&mut self) -> ::std::vec::Vec<u8> {
        self.data.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CosiCommit {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.address_n)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.data)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.address_n {
            my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if let Some(ref v) = self.data.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.address_n {
            os.write_uint32(1, *v)?;
        };
        if let Some(ref v) = self.data.as_ref() {
            os.write_bytes(2, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CosiCommit {
        CosiCommit::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "address_n",
                |m: &CosiCommit| { &m.address_n },
                |m: &mut CosiCommit| { &mut m.address_n },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "data",
                |m: &CosiCommit| { &m.data },
                |m: &mut CosiCommit| { &mut m.data },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CosiCommit>(
                "CosiCommit",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CosiCommit {
        static instance: ::protobuf::rt::LazyV2<CosiCommit> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CosiCommit::new)
    }
}

impl ::protobuf::Clear for CosiCommit {
    fn clear(&mut self) {
        self.address_n.clear();
        self.data.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CosiCommit {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CosiCommit {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CosiCommitment {
    // message fields
    commitment: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    pubkey: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CosiCommitment {
    fn default() -> &'a CosiCommitment {
        <CosiCommitment as ::protobuf::Message>::default_instance()
    }
}

impl CosiCommitment {
    pub fn new() -> CosiCommitment {
        ::std::default::Default::default()
    }

    // optional bytes commitment = 1;


    pub fn get_commitment(&self) -> &[u8] {
        match self.commitment.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_commitment(&mut self) {
        self.commitment.clear();
    }

    pub fn has_commitment(&self) -> bool {
        self.commitment.is_some()
    }

    // Param is passed by value, moved
    pub fn set_commitment(&mut self, v: ::std::vec::Vec<u8>) {
        self.commitment = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_commitment(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.commitment.is_none() {
            self.commitment.set_default();
        }
        self.commitment.as_mut().unwrap()
    }

    // Take field
    pub fn take_commitment(&mut self) -> ::std::vec::Vec<u8> {
        self.commitment.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bytes pubkey = 2;


    pub fn get_pubkey(&self) -> &[u8] {
        match self.pubkey.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_pubkey(&mut self) {
        self.pubkey.clear();
    }

    pub fn has_pubkey(&self) -> bool {
        self.pubkey.is_some()
    }

    // Param is passed by value, moved
    pub fn set_pubkey(&mut self, v: ::std::vec::Vec<u8>) {
        self.pubkey = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_pubkey(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.pubkey.is_none() {
            self.pubkey.set_default();
        }
        self.pubkey.as_mut().unwrap()
    }

    // Take field
    pub fn take_pubkey(&mut self) -> ::std::vec::Vec<u8> {
        self.pubkey.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CosiCommitment {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.commitment)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.pubkey)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.commitment.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.pubkey.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.commitment.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(ref v) = self.pubkey.as_ref() {
            os.write_bytes(2, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CosiCommitment {
        CosiCommitment::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "commitment",
                |m: &CosiCommitment| { &m.commitment },
                |m: &mut CosiCommitment| { &mut m.commitment },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "pubkey",
                |m: &CosiCommitment| { &m.pubkey },
                |m: &mut CosiCommitment| { &mut m.pubkey },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CosiCommitment>(
                "CosiCommitment",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CosiCommitment {
        static instance: ::protobuf::rt::LazyV2<CosiCommitment> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CosiCommitment::new)
    }
}

impl ::protobuf::Clear for CosiCommitment {
    fn clear(&mut self) {
        self.commitment.clear();
        self.pubkey.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CosiCommitment {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CosiCommitment {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CosiSign {
    // message fields
    pub address_n: ::std::vec::Vec<u32>,
    data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    global_commitment: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    global_pubkey: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CosiSign {
    fn default() -> &'a CosiSign {
        <CosiSign as ::protobuf::Message>::default_instance()
    }
}

impl CosiSign {
    pub fn new() -> CosiSign {
        ::std::default::Default::default()
    }

    // repeated uint32 address_n = 1;


    pub fn get_address_n(&self) -> &[u32] {
        &self.address_n
    }
    pub fn clear_address_n(&mut self) {
        self.address_n.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_n(&mut self, v: ::std::vec::Vec<u32>) {
        self.address_n = v;
    }

    // Mutable pointer to the field.
    pub fn mut_address_n(&mut self) -> &mut ::std::vec::Vec<u32> {
        &mut self.address_n
    }

    // Take field
    pub fn take_address_n(&mut self) -> ::std::vec::Vec<u32> {
        ::std::mem::replace(&mut self.address_n, ::std::vec::Vec::new())
    }

    // optional bytes data = 2;


    pub fn get_data(&self) -> &[u8] {
        match self.data.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_data(&mut self) {
        self.data.clear();
    }

    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<u8>) {
        self.data = ::protobuf::SingularField::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<u8> {
        if self.data.is_none() {
            self.data.set_default();
        }
        self.data.as_mut().unwrap()
    }

    // Take field
    pub fn take_data(&mut self) -> ::std::vec::Vec<u8> {
        self.data.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bytes global_commitment = 3;


    pub fn get_global_commitment(&self) -> &[u8] {
        match self.global_commitment.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_global_commitment(&mut self) {
        self.global_commitment.clear();
    }

    pub fn has_global_commitment(&self) -> bool {
        self.global_commitment.is_some()
    }

    // Param is passed by value, moved
    pub fn set_global_commitment(&mut self, v: ::std::vec::Vec<u8>) {
        self.global_commitment = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_global_commitment(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.global_commitment.is_none() {
            self.global_commitment.set_default();
        }
        self.global_commitment.as_mut().unwrap()
    }

    // Take field
    pub fn take_global_commitment(&mut self) -> ::std::vec::Vec<u8> {
        self.global_commitment.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bytes global_pubkey = 4;


    pub fn get_global_pubkey(&self) -> &[u8] {
        match self.global_pubkey.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_global_pubkey(&mut self) {
        self.global_pubkey.clear();
    }

    pub fn has_global_pubkey(&self) -> bool {
        self.global_pubkey.is_some()
    }

    // Param is passed by value, moved
    pub fn set_global_pubkey(&mut self, v: ::std::vec::Vec<u8>) {
        self.global_pubkey = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_global_pubkey(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.global_pubkey.is_none() {
            self.global_pubkey.set_default();
        }
        self.global_pubkey.as_mut().unwrap()
    }

    // Take field
    pub fn take_global_pubkey(&mut self) -> ::std::vec::Vec<u8> {
        self.global_pubkey.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CosiSign {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.address_n)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.data)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.global_commitment)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.global_pubkey)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.address_n {
            my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if let Some(ref v) = self.data.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(ref v) = self.global_commitment.as_ref() {
            my_size += ::protobuf::rt::bytes_size(3, &v);
        }
        if let Some(ref v) = self.global_pubkey.as_ref() {
            my_size += ::protobuf::rt::bytes_size(4, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.address_n {
            os.write_uint32(1, *v)?;
        };
        if let Some(ref v) = self.data.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(ref v) = self.global_commitment.as_ref() {
            os.write_bytes(3, &v)?;
        }
        if let Some(ref v) = self.global_pubkey.as_ref() {
            os.write_bytes(4, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CosiSign {
        CosiSign::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "address_n",
                |m: &CosiSign| { &m.address_n },
                |m: &mut CosiSign| { &mut m.address_n },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "data",
                |m: &CosiSign| { &m.data },
                |m: &mut CosiSign| { &mut m.data },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "global_commitment",
                |m: &CosiSign| { &m.global_commitment },
                |m: &mut CosiSign| { &mut m.global_commitment },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "global_pubkey",
                |m: &CosiSign| { &m.global_pubkey },
                |m: &mut CosiSign| { &mut m.global_pubkey },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CosiSign>(
                "CosiSign",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CosiSign {
        static instance: ::protobuf::rt::LazyV2<CosiSign> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CosiSign::new)
    }
}

impl ::protobuf::Clear for CosiSign {
    fn clear(&mut self) {
        self.address_n.clear();
        self.data.clear();
        self.global_commitment.clear();
        self.global_pubkey.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CosiSign {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CosiSign {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CosiSignature {
    // message fields
    signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CosiSignature {
    fn default() -> &'a CosiSignature {
        <CosiSignature as ::protobuf::Message>::default_instance()
    }
}

impl CosiSignature {
    pub fn new() -> CosiSignature {
        ::std::default::Default::default()
    }

    // required bytes signature = 1;


    pub fn get_signature(&self) -> &[u8] {
        match self.signature.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_signature(&mut self) {
        self.signature.clear();
    }

    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<u8>) {
        self.signature = ::protobuf::SingularField::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<u8> {
        if self.signature.is_none() {
            self.signature.set_default();
        }
        self.signature.as_mut().unwrap()
    }

    // Take field
    pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
        self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CosiSignature {
    fn is_initialized(&self) -> bool {
        if self.signature.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.signature.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.signature.as_ref() {
            os.write_bytes(1, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CosiSignature {
        CosiSignature::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "signature",
                |m: &CosiSignature| { &m.signature },
                |m: &mut CosiSignature| { &mut m.signature },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CosiSignature>(
                "CosiSignature",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CosiSignature {
        static instance: ::protobuf::rt::LazyV2<CosiSignature> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CosiSignature::new)
    }
}

impl ::protobuf::Clear for CosiSignature {
    fn clear(&mut self) {
        self.signature.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CosiSignature {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CosiSignature {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x15messages-crypto.proto\x12\x19hw.trezor.messages.crypto\x1a\x0emess\
    ages.proto\"\xcb\x01\n\x0eCipherKeyValue\x12\x1b\n\taddress_n\x18\x01\
    \x20\x03(\rR\x08addressN\x12\x10\n\x03key\x18\x02\x20\x02(\tR\x03key\x12\
    \x14\n\x05value\x18\x03\x20\x02(\x0cR\x05value\x12\x18\n\x07encrypt\x18\
    \x04\x20\x01(\x08R\x07encrypt\x12$\n\x0eask_on_encrypt\x18\x05\x20\x01(\
    \x08R\x0caskOnEncrypt\x12$\n\x0eask_on_decrypt\x18\x06\x20\x01(\x08R\x0c\
    askOnDecrypt\x12\x0e\n\x02iv\x18\x07\x20\x01(\x0cR\x02iv\"(\n\x10Ciphere\
    dKeyValue\x12\x14\n\x05value\x18\x01\x20\x02(\x0cR\x05value\"\x8d\x01\n\
    \x0cIdentityType\x12\x14\n\x05proto\x18\x01\x20\x01(\tR\x05proto\x12\x12\
    \n\x04user\x18\x02\x20\x01(\tR\x04user\x12\x12\n\x04host\x18\x03\x20\x01\
    (\tR\x04host\x12\x12\n\x04port\x18\x04\x20\x01(\tR\x04port\x12\x12\n\x04\
    path\x18\x05\x20\x01(\tR\x04path\x12\x17\n\x05index\x18\x06\x20\x01(\r:\
    \x010R\x05index\"\xd7\x01\n\x0cSignIdentity\x12C\n\x08identity\x18\x01\
    \x20\x02(\x0b2'.hw.trezor.messages.crypto.IdentityTypeR\x08identity\x12+\
    \n\x10challenge_hidden\x18\x02\x20\x01(\x0c:\0R\x0fchallengeHidden\x12+\
    \n\x10challenge_visual\x18\x03\x20\x01(\t:\0R\x0fchallengeVisual\x12(\n\
    \x10ecdsa_curve_name\x18\x04\x20\x01(\tR\x0eecdsaCurveName\"g\n\x0eSigne\
    dIdentity\x12\x18\n\x07address\x18\x01\x20\x01(\tR\x07address\x12\x1d\n\
    \npublic_key\x18\x02\x20\x02(\x0cR\tpublicKey\x12\x1c\n\tsignature\x18\
    \x03\x20\x02(\x0cR\tsignature\"\xaa\x01\n\x11GetECDHSessionKey\x12C\n\
    \x08identity\x18\x01\x20\x02(\x0b2'.hw.trezor.messages.crypto.IdentityTy\
    peR\x08identity\x12&\n\x0fpeer_public_key\x18\x02\x20\x02(\x0cR\rpeerPub\
    licKey\x12(\n\x10ecdsa_curve_name\x18\x03\x20\x01(\tR\x0eecdsaCurveName\
    \"P\n\x0eECDHSessionKey\x12\x1f\n\x0bsession_key\x18\x01\x20\x02(\x0cR\n\
    sessionKey\x12\x1d\n\npublic_key\x18\x02\x20\x01(\x0cR\tpublicKey\"=\n\n\
    CosiCommit\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12\x12\
    \n\x04data\x18\x02\x20\x01(\x0cR\x04data\"H\n\x0eCosiCommitment\x12\x1e\
    \n\ncommitment\x18\x01\x20\x01(\x0cR\ncommitment\x12\x16\n\x06pubkey\x18\
    \x02\x20\x01(\x0cR\x06pubkey\"\x8d\x01\n\x08CosiSign\x12\x1b\n\taddress_\
    n\x18\x01\x20\x03(\rR\x08addressN\x12\x12\n\x04data\x18\x02\x20\x01(\x0c\
    R\x04data\x12+\n\x11global_commitment\x18\x03\x20\x01(\x0cR\x10globalCom\
    mitment\x12#\n\rglobal_pubkey\x18\x04\x20\x01(\x0cR\x0cglobalPubkey\"-\n\
    \rCosiSignature\x12\x1c\n\tsignature\x18\x01\x20\x02(\x0cR\tsignatureB>\
    \n#com.satoshilabs.trezor.lib.protobufB\x13TrezorMessageCrypto\x80\xa6\
    \x1d\x01J\xbe$\n\x07\x12\x05\0\0\x83\x01\x01\n\x08\n\x01\x0c\x12\x03\0\0\
    \x12\n\x08\n\x01\x02\x12\x03\x01\x08!\n\x08\n\x01\x08\x12\x03\x04\0<\n.\
    \n\x02\x08\x01\x12\x03\x04\0<\x1a#\x20Sugar\x20for\x20easier\x20handling\
    \x20in\x20Java\n\n\x08\n\x01\x08\x12\x03\x05\04\n\t\n\x02\x08\x08\x12\
    \x03\x05\04\n\x08\n\x01\x08\x12\x03\x07\0(\n\x0b\n\x04\x08\xe0\xd4\x03\
    \x12\x03\x07\0(\n\t\n\x02\x03\0\x12\x03\t\x07\x17\n{\n\x02\x04\0\x12\x04\
    \x11\0\x19\x01\x1ao*\n\x20Request:\x20Ask\x20device\x20to\x20encrypt\x20\
    or\x20decrypt\x20value\x20of\x20given\x20key\n\x20@start\n\x20@next\x20C\
    ipheredKeyValue\n\x20@next\x20Failure\n\n\n\n\x03\x04\0\x01\x12\x03\x11\
    \x08\x16\n=\n\x04\x04\0\x02\0\x12\x03\x12\x04\"\"0\x20BIP-32\x20path\x20\
    to\x20derive\x20the\x20key\x20from\x20master\x20node\n\n\x0c\n\x05\x04\0\
    \x02\0\x04\x12\x03\x12\x04\x0c\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x12\r\
    \x13\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x12\x14\x1d\n\x0c\n\x05\x04\0\
    \x02\0\x03\x12\x03\x12\x20!\n)\n\x04\x04\0\x02\x01\x12\x03\x13\x04\x1c\"\
    \x1c\x20key\x20component\x20of\x20key:value\n\n\x0c\n\x05\x04\0\x02\x01\
    \x04\x12\x03\x13\x04\x0c\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x13\r\x13\
    \n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x13\x14\x17\n\x0c\n\x05\x04\0\x02\
    \x01\x03\x12\x03\x13\x1a\x1b\n+\n\x04\x04\0\x02\x02\x12\x03\x14\x04\x1d\
    \"\x1e\x20value\x20component\x20of\x20key:value\n\n\x0c\n\x05\x04\0\x02\
    \x02\x04\x12\x03\x14\x04\x0c\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03\x14\r\
    \x12\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03\x14\x13\x18\n\x0c\n\x05\x04\0\
    \x02\x02\x03\x12\x03\x14\x1b\x1c\n>\n\x04\x04\0\x02\x03\x12\x03\x15\x04\
    \x1e\"1\x20are\x20we\x20encrypting\x20(True)\x20or\x20decrypting\x20(Fal\
    se)?\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x03\x15\x04\x0c\n\x0c\n\x05\x04\
    \0\x02\x03\x05\x12\x03\x15\r\x11\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03\
    \x15\x12\x19\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03\x15\x1c\x1d\n2\n\x04\
    \x04\0\x02\x04\x12\x03\x16\x04%\"%\x20should\x20we\x20ask\x20on\x20encry\
    pt\x20operation?\n\n\x0c\n\x05\x04\0\x02\x04\x04\x12\x03\x16\x04\x0c\n\
    \x0c\n\x05\x04\0\x02\x04\x05\x12\x03\x16\r\x11\n\x0c\n\x05\x04\0\x02\x04\
    \x01\x12\x03\x16\x12\x20\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03\x16#$\n2\
    \n\x04\x04\0\x02\x05\x12\x03\x17\x04%\"%\x20should\x20we\x20ask\x20on\
    \x20decrypt\x20operation?\n\n\x0c\n\x05\x04\0\x02\x05\x04\x12\x03\x17\
    \x04\x0c\n\x0c\n\x05\x04\0\x02\x05\x05\x12\x03\x17\r\x11\n\x0c\n\x05\x04\
    \0\x02\x05\x01\x12\x03\x17\x12\x20\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03\
    \x17#$\nB\n\x04\x04\0\x02\x06\x12\x03\x18\x04\x1a\"5\x20initialization\
    \x20vector\x20(will\x20be\x20computed\x20if\x20not\x20set)\n\n\x0c\n\x05\
    \x04\0\x02\x06\x04\x12\x03\x18\x04\x0c\n\x0c\n\x05\x04\0\x02\x06\x05\x12\
    \x03\x18\r\x12\n\x0c\n\x05\x04\0\x02\x06\x01\x12\x03\x18\x13\x15\n\x0c\n\
    \x05\x04\0\x02\x06\x03\x12\x03\x18\x18\x19\n@\n\x02\x04\x01\x12\x04\x1f\
    \0!\x01\x1a4*\n\x20Response:\x20Return\x20ciphered/deciphered\x20value\n\
    \x20@end\n\n\n\n\x03\x04\x01\x01\x12\x03\x1f\x08\x18\n(\n\x04\x04\x01\
    \x02\0\x12\x03\x20\x04\x1d\"\x1b\x20ciphered/deciphered\x20value\n\n\x0c\
    \n\x05\x04\x01\x02\0\x04\x12\x03\x20\x04\x0c\n\x0c\n\x05\x04\x01\x02\0\
    \x05\x12\x03\x20\r\x12\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x20\x13\x18\
    \n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x20\x1b\x1c\n<\n\x02\x04\x02\x12\
    \x04'\0.\x01\x1a0*\n\x20Structure\x20representing\x20identity\x20data\n\
    \x20@embed\n\n\n\n\x03\x04\x02\x01\x12\x03'\x08\x14\n\x20\n\x04\x04\x02\
    \x02\0\x12\x03(\x04\x1e\"\x13\x20proto\x20part\x20of\x20URI\n\n\x0c\n\
    \x05\x04\x02\x02\0\x04\x12\x03(\x04\x0c\n\x0c\n\x05\x04\x02\x02\0\x05\
    \x12\x03(\r\x13\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03(\x14\x19\n\x0c\n\
    \x05\x04\x02\x02\0\x03\x12\x03(\x1c\x1d\n\x1f\n\x04\x04\x02\x02\x01\x12\
    \x03)\x04\x1d\"\x12\x20user\x20part\x20of\x20URI\n\n\x0c\n\x05\x04\x02\
    \x02\x01\x04\x12\x03)\x04\x0c\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03)\r\
    \x13\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03)\x14\x18\n\x0c\n\x05\x04\
    \x02\x02\x01\x03\x12\x03)\x1b\x1c\n\x1f\n\x04\x04\x02\x02\x02\x12\x03*\
    \x04\x1d\"\x12\x20host\x20part\x20of\x20URI\n\n\x0c\n\x05\x04\x02\x02\
    \x02\x04\x12\x03*\x04\x0c\n\x0c\n\x05\x04\x02\x02\x02\x05\x12\x03*\r\x13\
    \n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03*\x14\x18\n\x0c\n\x05\x04\x02\
    \x02\x02\x03\x12\x03*\x1b\x1c\n\x1f\n\x04\x04\x02\x02\x03\x12\x03+\x04\
    \x1d\"\x12\x20port\x20part\x20of\x20URI\n\n\x0c\n\x05\x04\x02\x02\x03\
    \x04\x12\x03+\x04\x0c\n\x0c\n\x05\x04\x02\x02\x03\x05\x12\x03+\r\x13\n\
    \x0c\n\x05\x04\x02\x02\x03\x01\x12\x03+\x14\x18\n\x0c\n\x05\x04\x02\x02\
    \x03\x03\x12\x03+\x1b\x1c\n\x1f\n\x04\x04\x02\x02\x04\x12\x03,\x04\x1d\"\
    \x12\x20path\x20part\x20of\x20URI\n\n\x0c\n\x05\x04\x02\x02\x04\x04\x12\
    \x03,\x04\x0c\n\x0c\n\x05\x04\x02\x02\x04\x05\x12\x03,\r\x13\n\x0c\n\x05\
    \x04\x02\x02\x04\x01\x12\x03,\x14\x18\n\x0c\n\x05\x04\x02\x02\x04\x03\
    \x12\x03,\x1b\x1c\n\x1d\n\x04\x04\x02\x02\x05\x12\x03-\x04*\"\x10\x20ide\
    ntity\x20index\n\n\x0c\n\x05\x04\x02\x02\x05\x04\x12\x03-\x04\x0c\n\x0c\
    \n\x05\x04\x02\x02\x05\x05\x12\x03-\r\x13\n\x0c\n\x05\x04\x02\x02\x05\
    \x01\x12\x03-\x14\x19\n\x0c\n\x05\x04\x02\x02\x05\x03\x12\x03-\x1c\x1d\n\
    \x0c\n\x05\x04\x02\x02\x05\x08\x12\x03-\x1e)\n\x0c\n\x05\x04\x02\x02\x05\
    \x07\x12\x03-'(\na\n\x02\x04\x03\x12\x046\0;\x01\x1aU*\n\x20Request:\x20\
    Ask\x20device\x20to\x20sign\x20identity\n\x20@start\n\x20@next\x20Signed\
    Identity\n\x20@next\x20Failure\n\n\n\n\x03\x04\x03\x01\x12\x036\x08\x14\
    \n\x17\n\x04\x04\x03\x02\0\x12\x037\x04'\"\n\x20identity\n\n\x0c\n\x05\
    \x04\x03\x02\0\x04\x12\x037\x04\x0c\n\x0c\n\x05\x04\x03\x02\0\x06\x12\
    \x037\r\x19\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x037\x1a\"\n\x0c\n\x05\x04\
    \x03\x02\0\x03\x12\x037%&\n$\n\x04\x04\x03\x02\x01\x12\x038\x045\"\x17\
    \x20non-visible\x20challenge\n\n\x0c\n\x05\x04\x03\x02\x01\x04\x12\x038\
    \x04\x0c\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x038\r\x12\n\x0c\n\x05\x04\
    \x03\x02\x01\x01\x12\x038\x13#\n\x0c\n\x05\x04\x03\x02\x01\x03\x12\x038&\
    '\n\x0c\n\x05\x04\x03\x02\x01\x08\x12\x038(4\n\x0c\n\x05\x04\x03\x02\x01\
    \x07\x12\x03813\n:\n\x04\x04\x03\x02\x02\x12\x039\x046\"-\x20challenge\
    \x20shown\x20on\x20display\x20(e.g.\x20date+time)\n\n\x0c\n\x05\x04\x03\
    \x02\x02\x04\x12\x039\x04\x0c\n\x0c\n\x05\x04\x03\x02\x02\x05\x12\x039\r\
    \x13\n\x0c\n\x05\x04\x03\x02\x02\x01\x12\x039\x14$\n\x0c\n\x05\x04\x03\
    \x02\x02\x03\x12\x039'(\n\x0c\n\x05\x04\x03\x02\x02\x08\x12\x039)5\n\x0c\
    \n\x05\x04\x03\x02\x02\x07\x12\x03924\n&\n\x04\x04\x03\x02\x03\x12\x03:\
    \x04)\"\x19\x20ECDSA\x20curve\x20name\x20to\x20use\n\n\x0c\n\x05\x04\x03\
    \x02\x03\x04\x12\x03:\x04\x0c\n\x0c\n\x05\x04\x03\x02\x03\x05\x12\x03:\r\
    \x13\n\x0c\n\x05\x04\x03\x02\x03\x01\x12\x03:\x14$\n\x0c\n\x05\x04\x03\
    \x02\x03\x03\x12\x03:'(\n?\n\x02\x04\x04\x12\x04A\0E\x01\x1a3*\n\x20Resp\
    onse:\x20Device\x20provides\x20signed\x20identity\n\x20@end\n\n\n\n\x03\
    \x04\x04\x01\x12\x03A\x08\x16\n\x1f\n\x04\x04\x04\x02\0\x12\x03B\x04\x20\
    \"\x12\x20identity\x20address\n\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x03B\
    \x04\x0c\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03B\r\x13\n\x0c\n\x05\x04\
    \x04\x02\0\x01\x12\x03B\x14\x1b\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03B\
    \x1e\x1f\n\"\n\x04\x04\x04\x02\x01\x12\x03C\x04\"\"\x15\x20identity\x20p\
    ublic\x20key\n\n\x0c\n\x05\x04\x04\x02\x01\x04\x12\x03C\x04\x0c\n\x0c\n\
    \x05\x04\x04\x02\x01\x05\x12\x03C\r\x12\n\x0c\n\x05\x04\x04\x02\x01\x01\
    \x12\x03C\x13\x1d\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x03C\x20!\n-\n\x04\
    \x04\x04\x02\x02\x12\x03D\x04!\"\x20\x20signature\x20of\x20the\x20identi\
    ty\x20data\n\n\x0c\n\x05\x04\x04\x02\x02\x04\x12\x03D\x04\x0c\n\x0c\n\
    \x05\x04\x04\x02\x02\x05\x12\x03D\r\x12\n\x0c\n\x05\x04\x04\x02\x02\x01\
    \x12\x03D\x13\x1c\n\x0c\n\x05\x04\x04\x02\x02\x03\x12\x03D\x1f\x20\nm\n\
    \x02\x04\x05\x12\x04M\0Q\x01\x1aa*\n\x20Request:\x20Ask\x20device\x20to\
    \x20generate\x20ECDH\x20session\x20key\n\x20@start\n\x20@next\x20ECDHSes\
    sionKey\n\x20@next\x20Failure\n\n\n\n\x03\x04\x05\x01\x12\x03M\x08\x19\n\
    \x17\n\x04\x04\x05\x02\0\x12\x03N\x04'\"\n\x20identity\n\n\x0c\n\x05\x04\
    \x05\x02\0\x04\x12\x03N\x04\x0c\n\x0c\n\x05\x04\x05\x02\0\x06\x12\x03N\r\
    \x19\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03N\x1a\"\n\x0c\n\x05\x04\x05\
    \x02\0\x03\x12\x03N%&\n\x20\n\x04\x04\x05\x02\x01\x12\x03O\x04'\"\x13\
    \x20peer's\x20public\x20key\n\n\x0c\n\x05\x04\x05\x02\x01\x04\x12\x03O\
    \x04\x0c\n\x0c\n\x05\x04\x05\x02\x01\x05\x12\x03O\r\x12\n\x0c\n\x05\x04\
    \x05\x02\x01\x01\x12\x03O\x13\"\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03O\
    %&\n&\n\x04\x04\x05\x02\x02\x12\x03P\x04)\"\x19\x20ECDSA\x20curve\x20nam\
    e\x20to\x20use\n\n\x0c\n\x05\x04\x05\x02\x02\x04\x12\x03P\x04\x0c\n\x0c\
    \n\x05\x04\x05\x02\x02\x05\x12\x03P\r\x13\n\x0c\n\x05\x04\x05\x02\x02\
    \x01\x12\x03P\x14$\n\x0c\n\x05\x04\x05\x02\x02\x03\x12\x03P'(\n@\n\x02\
    \x04\x06\x12\x04W\0Z\x01\x1a4*\n\x20Response:\x20Device\x20provides\x20E\
    CDH\x20session\x20key\n\x20@end\n\n\n\n\x03\x04\x06\x01\x12\x03W\x08\x16\
    \n\x1f\n\x04\x04\x06\x02\0\x12\x03X\x04#\"\x12\x20ECDH\x20session\x20key\
    \n\n\x0c\n\x05\x04\x06\x02\0\x04\x12\x03X\x04\x0c\n\x0c\n\x05\x04\x06\
    \x02\0\x05\x12\x03X\r\x12\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03X\x13\x1e\
    \n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03X!\"\n\"\n\x04\x04\x06\x02\x01\x12\
    \x03Y\x04\"\"\x15\x20identity\x20public\x20key\n\n\x0c\n\x05\x04\x06\x02\
    \x01\x04\x12\x03Y\x04\x0c\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03Y\r\x12\
    \n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03Y\x13\x1d\n\x0c\n\x05\x04\x06\
    \x02\x01\x03\x12\x03Y\x20!\nj\n\x02\x04\x07\x12\x04b\0e\x01\x1a^*\n\x20R\
    equest:\x20Ask\x20device\x20to\x20commit\x20to\x20CoSi\x20signing\n\x20@\
    start\n\x20@next\x20CosiCommitment\n\x20@next\x20Failure\n\n\n\n\x03\x04\
    \x07\x01\x12\x03b\x08\x12\n=\n\x04\x04\x07\x02\0\x12\x03c\x04\"\"0\x20BI\
    P-32\x20path\x20to\x20derive\x20the\x20key\x20from\x20master\x20node\n\n\
    \x0c\n\x05\x04\x07\x02\0\x04\x12\x03c\x04\x0c\n\x0c\n\x05\x04\x07\x02\0\
    \x05\x12\x03c\r\x13\n\x0c\n\x05\x04\x07\x02\0\x01\x12\x03c\x14\x1d\n\x0c\
    \n\x05\x04\x07\x02\0\x03\x12\x03c\x20!\n\x20\n\x04\x04\x07\x02\x01\x12\
    \x03d\x04\x1c\"\x13\x20Data\x20to\x20be\x20signed\n\n\x0c\n\x05\x04\x07\
    \x02\x01\x04\x12\x03d\x04\x0c\n\x0c\n\x05\x04\x07\x02\x01\x05\x12\x03d\r\
    \x12\n\x0c\n\x05\x04\x07\x02\x01\x01\x12\x03d\x13\x17\n\x0c\n\x05\x04\
    \x07\x02\x01\x03\x12\x03d\x1a\x1b\n:\n\x02\x04\x08\x12\x04k\0n\x01\x1a.*\
    \n\x20Response:\x20Contains\x20a\x20CoSi\x20commitment\n\x20@end\n\n\n\n\
    \x03\x04\x08\x01\x12\x03k\x08\x16\n\x19\n\x04\x04\x08\x02\0\x12\x03l\x04\
    \"\"\x0c\x20Commitment\n\n\x0c\n\x05\x04\x08\x02\0\x04\x12\x03l\x04\x0c\
    \n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03l\r\x12\n\x0c\n\x05\x04\x08\x02\0\
    \x01\x12\x03l\x13\x1d\n\x0c\n\x05\x04\x08\x02\0\x03\x12\x03l\x20!\n\x19\
    \n\x04\x04\x08\x02\x01\x12\x03m\x04\x1e\"\x0c\x20Public\x20key\n\n\x0c\n\
    \x05\x04\x08\x02\x01\x04\x12\x03m\x04\x0c\n\x0c\n\x05\x04\x08\x02\x01\
    \x05\x12\x03m\r\x12\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\x03m\x13\x19\n\
    \x0c\n\x05\x04\x08\x02\x01\x03\x12\x03m\x1c\x1d\nb\n\x02\x04\t\x12\x04v\
    \0{\x01\x1aV*\n\x20Request:\x20Ask\x20device\x20to\x20sign\x20using\x20C\
    oSi\n\x20@start\n\x20@next\x20CosiSignature\n\x20@next\x20Failure\n\n\n\
    \n\x03\x04\t\x01\x12\x03v\x08\x10\n=\n\x04\x04\t\x02\0\x12\x03w\x04\"\"0\
    \x20BIP-32\x20path\x20to\x20derive\x20the\x20key\x20from\x20master\x20no\
    de\n\n\x0c\n\x05\x04\t\x02\0\x04\x12\x03w\x04\x0c\n\x0c\n\x05\x04\t\x02\
    \0\x05\x12\x03w\r\x13\n\x0c\n\x05\x04\t\x02\0\x01\x12\x03w\x14\x1d\n\x0c\
    \n\x05\x04\t\x02\0\x03\x12\x03w\x20!\n\x20\n\x04\x04\t\x02\x01\x12\x03x\
    \x04\x1c\"\x13\x20Data\x20to\x20be\x20signed\n\n\x0c\n\x05\x04\t\x02\x01\
    \x04\x12\x03x\x04\x0c\n\x0c\n\x05\x04\t\x02\x01\x05\x12\x03x\r\x12\n\x0c\
    \n\x05\x04\t\x02\x01\x01\x12\x03x\x13\x17\n\x0c\n\x05\x04\t\x02\x01\x03\
    \x12\x03x\x1a\x1b\n$\n\x04\x04\t\x02\x02\x12\x03y\x04)\"\x17\x20Aggregat\
    ed\x20commitment\n\n\x0c\n\x05\x04\t\x02\x02\x04\x12\x03y\x04\x0c\n\x0c\
    \n\x05\x04\t\x02\x02\x05\x12\x03y\r\x12\n\x0c\n\x05\x04\t\x02\x02\x01\
    \x12\x03y\x13$\n\x0c\n\x05\x04\t\x02\x02\x03\x12\x03y'(\n$\n\x04\x04\t\
    \x02\x03\x12\x03z\x04%\"\x17\x20Aggregated\x20public\x20key\n\n\x0c\n\
    \x05\x04\t\x02\x03\x04\x12\x03z\x04\x0c\n\x0c\n\x05\x04\t\x02\x03\x05\
    \x12\x03z\r\x12\n\x0c\n\x05\x04\t\x02\x03\x01\x12\x03z\x13\x20\n\x0c\n\
    \x05\x04\t\x02\x03\x03\x12\x03z#$\n;\n\x02\x04\n\x12\x06\x81\x01\0\x83\
    \x01\x01\x1a-*\n\x20Response:\x20Contains\x20a\x20CoSi\x20signature\n\
    \x20@end\n\n\x0b\n\x03\x04\n\x01\x12\x04\x81\x01\x08\x15\n\x19\n\x04\x04\
    \n\x02\0\x12\x04\x82\x01\x04!\"\x0b\x20Signature\n\n\r\n\x05\x04\n\x02\0\
    \x04\x12\x04\x82\x01\x04\x0c\n\r\n\x05\x04\n\x02\0\x05\x12\x04\x82\x01\r\
    \x12\n\r\n\x05\x04\n\x02\0\x01\x12\x04\x82\x01\x13\x1c\n\r\n\x05\x04\n\
    \x02\0\x03\x12\x04\x82\x01\x1f\x20\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}