#![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)]
#[derive(PartialEq,Clone,Default)]
pub struct MultisigRedeemScriptType {
pub pubkeys: ::protobuf::RepeatedField<MultisigRedeemScriptType_HDNodePathType>,
pub signatures: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
m: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MultisigRedeemScriptType {
fn default() -> &'a MultisigRedeemScriptType {
<MultisigRedeemScriptType as ::protobuf::Message>::default_instance()
}
}
impl MultisigRedeemScriptType {
pub fn new() -> MultisigRedeemScriptType {
::std::default::Default::default()
}
pub fn get_pubkeys(&self) -> &[MultisigRedeemScriptType_HDNodePathType] {
&self.pubkeys
}
pub fn clear_pubkeys(&mut self) {
self.pubkeys.clear();
}
pub fn set_pubkeys(&mut self, v: ::protobuf::RepeatedField<MultisigRedeemScriptType_HDNodePathType>) {
self.pubkeys = v;
}
pub fn mut_pubkeys(&mut self) -> &mut ::protobuf::RepeatedField<MultisigRedeemScriptType_HDNodePathType> {
&mut self.pubkeys
}
pub fn take_pubkeys(&mut self) -> ::protobuf::RepeatedField<MultisigRedeemScriptType_HDNodePathType> {
::std::mem::replace(&mut self.pubkeys, ::protobuf::RepeatedField::new())
}
pub fn get_signatures(&self) -> &[::std::vec::Vec<u8>] {
&self.signatures
}
pub fn clear_signatures(&mut self) {
self.signatures.clear();
}
pub fn set_signatures(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.signatures = v;
}
pub fn mut_signatures(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.signatures
}
pub fn take_signatures(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.signatures, ::protobuf::RepeatedField::new())
}
pub fn get_m(&self) -> u32 {
self.m.unwrap_or(0)
}
pub fn clear_m(&mut self) {
self.m = ::std::option::Option::None;
}
pub fn has_m(&self) -> bool {
self.m.is_some()
}
pub fn set_m(&mut self, v: u32) {
self.m = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for MultisigRedeemScriptType {
fn is_initialized(&self) -> bool {
for v in &self.pubkeys {
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_repeated_message_into(wire_type, is, &mut self.pubkeys)?;
},
2 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.signatures)?;
},
3 => {
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.m = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.pubkeys {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.signatures {
my_size += ::protobuf::rt::bytes_size(2, &value);
};
if let Some(v) = self.m {
my_size += ::protobuf::rt::value_size(3, 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<()> {
for v in &self.pubkeys {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.signatures {
os.write_bytes(2, &v)?;
};
if let Some(v) = self.m {
os.write_uint32(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() -> MultisigRedeemScriptType {
MultisigRedeemScriptType::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_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MultisigRedeemScriptType_HDNodePathType>>(
"pubkeys",
|m: &MultisigRedeemScriptType| { &m.pubkeys },
|m: &mut MultisigRedeemScriptType| { &mut m.pubkeys },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"signatures",
|m: &MultisigRedeemScriptType| { &m.signatures },
|m: &mut MultisigRedeemScriptType| { &mut m.signatures },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"m",
|m: &MultisigRedeemScriptType| { &m.m },
|m: &mut MultisigRedeemScriptType| { &mut m.m },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MultisigRedeemScriptType>(
"MultisigRedeemScriptType",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static MultisigRedeemScriptType {
static instance: ::protobuf::rt::LazyV2<MultisigRedeemScriptType> = ::protobuf::rt::LazyV2::INIT;
instance.get(MultisigRedeemScriptType::new)
}
}
impl ::protobuf::Clear for MultisigRedeemScriptType {
fn clear(&mut self) {
self.pubkeys.clear();
self.signatures.clear();
self.m = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MultisigRedeemScriptType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MultisigRedeemScriptType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MultisigRedeemScriptType_HDNodePathType {
pub node: ::protobuf::SingularPtrField<super::messages_common::HDNodeType>,
pub address_n: ::std::vec::Vec<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MultisigRedeemScriptType_HDNodePathType {
fn default() -> &'a MultisigRedeemScriptType_HDNodePathType {
<MultisigRedeemScriptType_HDNodePathType as ::protobuf::Message>::default_instance()
}
}
impl MultisigRedeemScriptType_HDNodePathType {
pub fn new() -> MultisigRedeemScriptType_HDNodePathType {
::std::default::Default::default()
}
pub fn get_node(&self) -> &super::messages_common::HDNodeType {
self.node.as_ref().unwrap_or_else(|| <super::messages_common::HDNodeType as ::protobuf::Message>::default_instance())
}
pub fn clear_node(&mut self) {
self.node.clear();
}
pub fn has_node(&self) -> bool {
self.node.is_some()
}
pub fn set_node(&mut self, v: super::messages_common::HDNodeType) {
self.node = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_node(&mut self) -> &mut super::messages_common::HDNodeType {
if self.node.is_none() {
self.node.set_default();
}
self.node.as_mut().unwrap()
}
pub fn take_node(&mut self) -> super::messages_common::HDNodeType {
self.node.take().unwrap_or_else(|| super::messages_common::HDNodeType::new())
}
pub fn get_address_n(&self) -> &[u32] {
&self.address_n
}
pub fn clear_address_n(&mut self) {
self.address_n.clear();
}
pub fn set_address_n(&mut self, v: ::std::vec::Vec<u32>) {
self.address_n = v;
}
pub fn mut_address_n(&mut self) -> &mut ::std::vec::Vec<u32> {
&mut self.address_n
}
pub fn take_address_n(&mut self) -> ::std::vec::Vec<u32> {
::std::mem::replace(&mut self.address_n, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for MultisigRedeemScriptType_HDNodePathType {
fn is_initialized(&self) -> bool {
if self.node.is_none() {
return false;
}
for v in &self.node {
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.node)?;
},
2 => {
::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.address_n)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.node.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.address_n {
my_size += ::protobuf::rt::value_size(2, *value, ::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.node.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)?;
}
for v in &self.address_n {
os.write_uint32(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() -> MultisigRedeemScriptType_HDNodePathType {
MultisigRedeemScriptType_HDNodePathType::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<super::messages_common::HDNodeType>>(
"node",
|m: &MultisigRedeemScriptType_HDNodePathType| { &m.node },
|m: &mut MultisigRedeemScriptType_HDNodePathType| { &mut m.node },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"address_n",
|m: &MultisigRedeemScriptType_HDNodePathType| { &m.address_n },
|m: &mut MultisigRedeemScriptType_HDNodePathType| { &mut m.address_n },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MultisigRedeemScriptType_HDNodePathType>(
"MultisigRedeemScriptType.HDNodePathType",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static MultisigRedeemScriptType_HDNodePathType {
static instance: ::protobuf::rt::LazyV2<MultisigRedeemScriptType_HDNodePathType> = ::protobuf::rt::LazyV2::INIT;
instance.get(MultisigRedeemScriptType_HDNodePathType::new)
}
}
impl ::protobuf::Clear for MultisigRedeemScriptType_HDNodePathType {
fn clear(&mut self) {
self.node.clear();
self.address_n.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MultisigRedeemScriptType_HDNodePathType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MultisigRedeemScriptType_HDNodePathType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct GetPublicKey {
pub address_n: ::std::vec::Vec<u32>,
ecdsa_curve_name: ::protobuf::SingularField<::std::string::String>,
show_display: ::std::option::Option<bool>,
coin_name: ::protobuf::SingularField<::std::string::String>,
script_type: ::std::option::Option<InputScriptType>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a GetPublicKey {
fn default() -> &'a GetPublicKey {
<GetPublicKey as ::protobuf::Message>::default_instance()
}
}
impl GetPublicKey {
pub fn new() -> GetPublicKey {
::std::default::Default::default()
}
pub fn get_address_n(&self) -> &[u32] {
&self.address_n
}
pub fn clear_address_n(&mut self) {
self.address_n.clear();
}
pub fn set_address_n(&mut self, v: ::std::vec::Vec<u32>) {
self.address_n = v;
}
pub fn mut_address_n(&mut self) -> &mut ::std::vec::Vec<u32> {
&mut self.address_n
}
pub fn take_address_n(&mut self) -> ::std::vec::Vec<u32> {
::std::mem::replace(&mut self.address_n, ::std::vec::Vec::new())
}
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()
}
pub fn set_ecdsa_curve_name(&mut self, v: ::std::string::String) {
self.ecdsa_curve_name = ::protobuf::SingularField::some(v);
}
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()
}
pub fn take_ecdsa_curve_name(&mut self) -> ::std::string::String {
self.ecdsa_curve_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_show_display(&self) -> bool {
self.show_display.unwrap_or(false)
}
pub fn clear_show_display(&mut self) {
self.show_display = ::std::option::Option::None;
}
pub fn has_show_display(&self) -> bool {
self.show_display.is_some()
}
pub fn set_show_display(&mut self, v: bool) {
self.show_display = ::std::option::Option::Some(v);
}
pub fn get_coin_name(&self) -> &str {
match self.coin_name.as_ref() {
Some(v) => &v,
None => "Bitcoin",
}
}
pub fn clear_coin_name(&mut self) {
self.coin_name.clear();
}
pub fn has_coin_name(&self) -> bool {
self.coin_name.is_some()
}
pub fn set_coin_name(&mut self, v: ::std::string::String) {
self.coin_name = ::protobuf::SingularField::some(v);
}
pub fn mut_coin_name(&mut self) -> &mut ::std::string::String {
if self.coin_name.is_none() {
self.coin_name.set_default();
}
self.coin_name.as_mut().unwrap()
}
pub fn take_coin_name(&mut self) -> ::std::string::String {
self.coin_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_script_type(&self) -> InputScriptType {
self.script_type.unwrap_or(InputScriptType::SPENDADDRESS)
}
pub fn clear_script_type(&mut self) {
self.script_type = ::std::option::Option::None;
}
pub fn has_script_type(&self) -> bool {
self.script_type.is_some()
}
pub fn set_script_type(&mut self, v: InputScriptType) {
self.script_type = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for GetPublicKey {
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_string_into(wire_type, is, &mut self.ecdsa_curve_name)?;
},
3 => {
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.show_display = ::std::option::Option::Some(tmp);
},
4 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.coin_name)?;
},
5 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.script_type, 5, &mut self.unknown_fields)?
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[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.ecdsa_curve_name.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.show_display {
my_size += 2;
}
if let Some(ref v) = self.coin_name.as_ref() {
my_size += ::protobuf::rt::string_size(4, &v);
}
if let Some(v) = self.script_type {
my_size += ::protobuf::rt::enum_size(5, 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.ecdsa_curve_name.as_ref() {
os.write_string(2, &v)?;
}
if let Some(v) = self.show_display {
os.write_bool(3, v)?;
}
if let Some(ref v) = self.coin_name.as_ref() {
os.write_string(4, &v)?;
}
if let Some(v) = self.script_type {
os.write_enum(5, ::protobuf::ProtobufEnum::value(&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() -> GetPublicKey {
GetPublicKey::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: &GetPublicKey| { &m.address_n },
|m: &mut GetPublicKey| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"ecdsa_curve_name",
|m: &GetPublicKey| { &m.ecdsa_curve_name },
|m: &mut GetPublicKey| { &mut m.ecdsa_curve_name },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"show_display",
|m: &GetPublicKey| { &m.show_display },
|m: &mut GetPublicKey| { &mut m.show_display },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"coin_name",
|m: &GetPublicKey| { &m.coin_name },
|m: &mut GetPublicKey| { &mut m.coin_name },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<InputScriptType>>(
"script_type",
|m: &GetPublicKey| { &m.script_type },
|m: &mut GetPublicKey| { &mut m.script_type },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<GetPublicKey>(
"GetPublicKey",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static GetPublicKey {
static instance: ::protobuf::rt::LazyV2<GetPublicKey> = ::protobuf::rt::LazyV2::INIT;
instance.get(GetPublicKey::new)
}
}
impl ::protobuf::Clear for GetPublicKey {
fn clear(&mut self) {
self.address_n.clear();
self.ecdsa_curve_name.clear();
self.show_display = ::std::option::Option::None;
self.coin_name.clear();
self.script_type = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for GetPublicKey {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GetPublicKey {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PublicKey {
pub node: ::protobuf::SingularPtrField<super::messages_common::HDNodeType>,
xpub: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PublicKey {
fn default() -> &'a PublicKey {
<PublicKey as ::protobuf::Message>::default_instance()
}
}
impl PublicKey {
pub fn new() -> PublicKey {
::std::default::Default::default()
}
pub fn get_node(&self) -> &super::messages_common::HDNodeType {
self.node.as_ref().unwrap_or_else(|| <super::messages_common::HDNodeType as ::protobuf::Message>::default_instance())
}
pub fn clear_node(&mut self) {
self.node.clear();
}
pub fn has_node(&self) -> bool {
self.node.is_some()
}
pub fn set_node(&mut self, v: super::messages_common::HDNodeType) {
self.node = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_node(&mut self) -> &mut super::messages_common::HDNodeType {
if self.node.is_none() {
self.node.set_default();
}
self.node.as_mut().unwrap()
}
pub fn take_node(&mut self) -> super::messages_common::HDNodeType {
self.node.take().unwrap_or_else(|| super::messages_common::HDNodeType::new())
}
pub fn get_xpub(&self) -> &str {
match self.xpub.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_xpub(&mut self) {
self.xpub.clear();
}
pub fn has_xpub(&self) -> bool {
self.xpub.is_some()
}
pub fn set_xpub(&mut self, v: ::std::string::String) {
self.xpub = ::protobuf::SingularField::some(v);
}
pub fn mut_xpub(&mut self) -> &mut ::std::string::String {
if self.xpub.is_none() {
self.xpub.set_default();
}
self.xpub.as_mut().unwrap()
}
pub fn take_xpub(&mut self) -> ::std::string::String {
self.xpub.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for PublicKey {
fn is_initialized(&self) -> bool {
if self.node.is_none() {
return false;
}
for v in &self.node {
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.node)?;
},
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.xpub)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.node.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.xpub.as_ref() {
my_size += ::protobuf::rt::string_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.node.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.xpub.as_ref() {
os.write_string(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() -> PublicKey {
PublicKey::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<super::messages_common::HDNodeType>>(
"node",
|m: &PublicKey| { &m.node },
|m: &mut PublicKey| { &mut m.node },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"xpub",
|m: &PublicKey| { &m.xpub },
|m: &mut PublicKey| { &mut m.xpub },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<PublicKey>(
"PublicKey",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static PublicKey {
static instance: ::protobuf::rt::LazyV2<PublicKey> = ::protobuf::rt::LazyV2::INIT;
instance.get(PublicKey::new)
}
}
impl ::protobuf::Clear for PublicKey {
fn clear(&mut self) {
self.node.clear();
self.xpub.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for PublicKey {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PublicKey {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct GetAddress {
pub address_n: ::std::vec::Vec<u32>,
coin_name: ::protobuf::SingularField<::std::string::String>,
show_display: ::std::option::Option<bool>,
pub multisig: ::protobuf::SingularPtrField<MultisigRedeemScriptType>,
script_type: ::std::option::Option<InputScriptType>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a GetAddress {
fn default() -> &'a GetAddress {
<GetAddress as ::protobuf::Message>::default_instance()
}
}
impl GetAddress {
pub fn new() -> GetAddress {
::std::default::Default::default()
}
pub fn get_address_n(&self) -> &[u32] {
&self.address_n
}
pub fn clear_address_n(&mut self) {
self.address_n.clear();
}
pub fn set_address_n(&mut self, v: ::std::vec::Vec<u32>) {
self.address_n = v;
}
pub fn mut_address_n(&mut self) -> &mut ::std::vec::Vec<u32> {
&mut self.address_n
}
pub fn take_address_n(&mut self) -> ::std::vec::Vec<u32> {
::std::mem::replace(&mut self.address_n, ::std::vec::Vec::new())
}
pub fn get_coin_name(&self) -> &str {
match self.coin_name.as_ref() {
Some(v) => &v,
None => "Bitcoin",
}
}
pub fn clear_coin_name(&mut self) {
self.coin_name.clear();
}
pub fn has_coin_name(&self) -> bool {
self.coin_name.is_some()
}
pub fn set_coin_name(&mut self, v: ::std::string::String) {
self.coin_name = ::protobuf::SingularField::some(v);
}
pub fn mut_coin_name(&mut self) -> &mut ::std::string::String {
if self.coin_name.is_none() {
self.coin_name.set_default();
}
self.coin_name.as_mut().unwrap()
}
pub fn take_coin_name(&mut self) -> ::std::string::String {
self.coin_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_show_display(&self) -> bool {
self.show_display.unwrap_or(false)
}
pub fn clear_show_display(&mut self) {
self.show_display = ::std::option::Option::None;
}
pub fn has_show_display(&self) -> bool {
self.show_display.is_some()
}
pub fn set_show_display(&mut self, v: bool) {
self.show_display = ::std::option::Option::Some(v);
}
pub fn get_multisig(&self) -> &MultisigRedeemScriptType {
self.multisig.as_ref().unwrap_or_else(|| <MultisigRedeemScriptType as ::protobuf::Message>::default_instance())
}
pub fn clear_multisig(&mut self) {
self.multisig.clear();
}
pub fn has_multisig(&self) -> bool {
self.multisig.is_some()
}
pub fn set_multisig(&mut self, v: MultisigRedeemScriptType) {
self.multisig = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_multisig(&mut self) -> &mut MultisigRedeemScriptType {
if self.multisig.is_none() {
self.multisig.set_default();
}
self.multisig.as_mut().unwrap()
}
pub fn take_multisig(&mut self) -> MultisigRedeemScriptType {
self.multisig.take().unwrap_or_else(|| MultisigRedeemScriptType::new())
}
pub fn get_script_type(&self) -> InputScriptType {
self.script_type.unwrap_or(InputScriptType::SPENDADDRESS)
}
pub fn clear_script_type(&mut self) {
self.script_type = ::std::option::Option::None;
}
pub fn has_script_type(&self) -> bool {
self.script_type.is_some()
}
pub fn set_script_type(&mut self, v: InputScriptType) {
self.script_type = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for GetAddress {
fn is_initialized(&self) -> bool {
for v in &self.multisig {
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_repeated_uint32_into(wire_type, is, &mut self.address_n)?;
},
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.coin_name)?;
},
3 => {
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.show_display = ::std::option::Option::Some(tmp);
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.multisig)?;
},
5 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.script_type, 5, &mut self.unknown_fields)?
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[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.coin_name.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.show_display {
my_size += 2;
}
if let Some(ref v) = self.multisig.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(v) = self.script_type {
my_size += ::protobuf::rt::enum_size(5, 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.coin_name.as_ref() {
os.write_string(2, &v)?;
}
if let Some(v) = self.show_display {
os.write_bool(3, v)?;
}
if let Some(ref v) = self.multisig.as_ref() {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(v) = self.script_type {
os.write_enum(5, ::protobuf::ProtobufEnum::value(&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() -> GetAddress {
GetAddress::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: &GetAddress| { &m.address_n },
|m: &mut GetAddress| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"coin_name",
|m: &GetAddress| { &m.coin_name },
|m: &mut GetAddress| { &mut m.coin_name },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"show_display",
|m: &GetAddress| { &m.show_display },
|m: &mut GetAddress| { &mut m.show_display },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MultisigRedeemScriptType>>(
"multisig",
|m: &GetAddress| { &m.multisig },
|m: &mut GetAddress| { &mut m.multisig },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<InputScriptType>>(
"script_type",
|m: &GetAddress| { &m.script_type },
|m: &mut GetAddress| { &mut m.script_type },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<GetAddress>(
"GetAddress",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static GetAddress {
static instance: ::protobuf::rt::LazyV2<GetAddress> = ::protobuf::rt::LazyV2::INIT;
instance.get(GetAddress::new)
}
}
impl ::protobuf::Clear for GetAddress {
fn clear(&mut self) {
self.address_n.clear();
self.coin_name.clear();
self.show_display = ::std::option::Option::None;
self.multisig.clear();
self.script_type = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for GetAddress {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GetAddress {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Address {
address: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Address {
fn default() -> &'a Address {
<Address as ::protobuf::Message>::default_instance()
}
}
impl Address {
pub fn new() -> Address {
::std::default::Default::default()
}
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()
}
pub fn set_address(&mut self, v: ::std::string::String) {
self.address = ::protobuf::SingularField::some(v);
}
pub fn mut_address(&mut self) -> &mut ::std::string::String {
if self.address.is_none() {
self.address.set_default();
}
self.address.as_mut().unwrap()
}
pub fn take_address(&mut self) -> ::std::string::String {
self.address.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for Address {
fn is_initialized(&self) -> bool {
if self.address.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)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[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);
}
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)?;
}
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() -> Address {
Address::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: &Address| { &m.address },
|m: &mut Address| { &mut m.address },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Address>(
"Address",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static Address {
static instance: ::protobuf::rt::LazyV2<Address> = ::protobuf::rt::LazyV2::INIT;
instance.get(Address::new)
}
}
impl ::protobuf::Clear for Address {
fn clear(&mut self) {
self.address.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Address {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Address {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SignMessage {
pub address_n: ::std::vec::Vec<u32>,
message: ::protobuf::SingularField<::std::vec::Vec<u8>>,
coin_name: ::protobuf::SingularField<::std::string::String>,
script_type: ::std::option::Option<InputScriptType>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SignMessage {
fn default() -> &'a SignMessage {
<SignMessage as ::protobuf::Message>::default_instance()
}
}
impl SignMessage {
pub fn new() -> SignMessage {
::std::default::Default::default()
}
pub fn get_address_n(&self) -> &[u32] {
&self.address_n
}
pub fn clear_address_n(&mut self) {
self.address_n.clear();
}
pub fn set_address_n(&mut self, v: ::std::vec::Vec<u32>) {
self.address_n = v;
}
pub fn mut_address_n(&mut self) -> &mut ::std::vec::Vec<u32> {
&mut self.address_n
}
pub fn take_address_n(&mut self) -> ::std::vec::Vec<u32> {
::std::mem::replace(&mut self.address_n, ::std::vec::Vec::new())
}
pub fn get_message(&self) -> &[u8] {
match self.message.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_message(&mut self) {
self.message.clear();
}
pub fn has_message(&self) -> bool {
self.message.is_some()
}
pub fn set_message(&mut self, v: ::std::vec::Vec<u8>) {
self.message = ::protobuf::SingularField::some(v);
}
pub fn mut_message(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.message.is_none() {
self.message.set_default();
}
self.message.as_mut().unwrap()
}
pub fn take_message(&mut self) -> ::std::vec::Vec<u8> {
self.message.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_coin_name(&self) -> &str {
match self.coin_name.as_ref() {
Some(v) => &v,
None => "Bitcoin",
}
}
pub fn clear_coin_name(&mut self) {
self.coin_name.clear();
}
pub fn has_coin_name(&self) -> bool {
self.coin_name.is_some()
}
pub fn set_coin_name(&mut self, v: ::std::string::String) {
self.coin_name = ::protobuf::SingularField::some(v);
}
pub fn mut_coin_name(&mut self) -> &mut ::std::string::String {
if self.coin_name.is_none() {
self.coin_name.set_default();
}
self.coin_name.as_mut().unwrap()
}
pub fn take_coin_name(&mut self) -> ::std::string::String {
self.coin_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_script_type(&self) -> InputScriptType {
self.script_type.unwrap_or(InputScriptType::SPENDADDRESS)
}
pub fn clear_script_type(&mut self) {
self.script_type = ::std::option::Option::None;
}
pub fn has_script_type(&self) -> bool {
self.script_type.is_some()
}
pub fn set_script_type(&mut self, v: InputScriptType) {
self.script_type = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SignMessage {
fn is_initialized(&self) -> bool {
if self.message.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_bytes_into(wire_type, is, &mut self.message)?;
},
3 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.coin_name)?;
},
4 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.script_type, 4, &mut self.unknown_fields)?
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[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.message.as_ref() {
my_size += ::protobuf::rt::bytes_size(2, &v);
}
if let Some(ref v) = self.coin_name.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.script_type {
my_size += ::protobuf::rt::enum_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.message.as_ref() {
os.write_bytes(2, &v)?;
}
if let Some(ref v) = self.coin_name.as_ref() {
os.write_string(3, &v)?;
}
if let Some(v) = self.script_type {
os.write_enum(4, ::protobuf::ProtobufEnum::value(&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() -> SignMessage {
SignMessage::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: &SignMessage| { &m.address_n },
|m: &mut SignMessage| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"message",
|m: &SignMessage| { &m.message },
|m: &mut SignMessage| { &mut m.message },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"coin_name",
|m: &SignMessage| { &m.coin_name },
|m: &mut SignMessage| { &mut m.coin_name },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<InputScriptType>>(
"script_type",
|m: &SignMessage| { &m.script_type },
|m: &mut SignMessage| { &mut m.script_type },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SignMessage>(
"SignMessage",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SignMessage {
static instance: ::protobuf::rt::LazyV2<SignMessage> = ::protobuf::rt::LazyV2::INIT;
instance.get(SignMessage::new)
}
}
impl ::protobuf::Clear for SignMessage {
fn clear(&mut self) {
self.address_n.clear();
self.message.clear();
self.coin_name.clear();
self.script_type = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SignMessage {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SignMessage {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MessageSignature {
address: ::protobuf::SingularField<::std::string::String>,
signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MessageSignature {
fn default() -> &'a MessageSignature {
<MessageSignature as ::protobuf::Message>::default_instance()
}
}
impl MessageSignature {
pub fn new() -> MessageSignature {
::std::default::Default::default()
}
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()
}
pub fn set_address(&mut self, v: ::std::string::String) {
self.address = ::protobuf::SingularField::some(v);
}
pub fn mut_address(&mut self) -> &mut ::std::string::String {
if self.address.is_none() {
self.address.set_default();
}
self.address.as_mut().unwrap()
}
pub fn take_address(&mut self) -> ::std::string::String {
self.address.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
self.signature = ::protobuf::SingularField::some(v);
}
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()
}
pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for MessageSignature {
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.address)?;
},
2 => {
::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(())
}
#[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.signature.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.address.as_ref() {
os.write_string(1, &v)?;
}
if let Some(ref v) = self.signature.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() -> MessageSignature {
MessageSignature::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: &MessageSignature| { &m.address },
|m: &mut MessageSignature| { &mut m.address },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"signature",
|m: &MessageSignature| { &m.signature },
|m: &mut MessageSignature| { &mut m.signature },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MessageSignature>(
"MessageSignature",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static MessageSignature {
static instance: ::protobuf::rt::LazyV2<MessageSignature> = ::protobuf::rt::LazyV2::INIT;
instance.get(MessageSignature::new)
}
}
impl ::protobuf::Clear for MessageSignature {
fn clear(&mut self) {
self.address.clear();
self.signature.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MessageSignature {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MessageSignature {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct VerifyMessage {
address: ::protobuf::SingularField<::std::string::String>,
signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
message: ::protobuf::SingularField<::std::vec::Vec<u8>>,
coin_name: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a VerifyMessage {
fn default() -> &'a VerifyMessage {
<VerifyMessage as ::protobuf::Message>::default_instance()
}
}
impl VerifyMessage {
pub fn new() -> VerifyMessage {
::std::default::Default::default()
}
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()
}
pub fn set_address(&mut self, v: ::std::string::String) {
self.address = ::protobuf::SingularField::some(v);
}
pub fn mut_address(&mut self) -> &mut ::std::string::String {
if self.address.is_none() {
self.address.set_default();
}
self.address.as_mut().unwrap()
}
pub fn take_address(&mut self) -> ::std::string::String {
self.address.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
self.signature = ::protobuf::SingularField::some(v);
}
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()
}
pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_message(&self) -> &[u8] {
match self.message.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_message(&mut self) {
self.message.clear();
}
pub fn has_message(&self) -> bool {
self.message.is_some()
}
pub fn set_message(&mut self, v: ::std::vec::Vec<u8>) {
self.message = ::protobuf::SingularField::some(v);
}
pub fn mut_message(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.message.is_none() {
self.message.set_default();
}
self.message.as_mut().unwrap()
}
pub fn take_message(&mut self) -> ::std::vec::Vec<u8> {
self.message.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_coin_name(&self) -> &str {
match self.coin_name.as_ref() {
Some(v) => &v,
None => "Bitcoin",
}
}
pub fn clear_coin_name(&mut self) {
self.coin_name.clear();
}
pub fn has_coin_name(&self) -> bool {
self.coin_name.is_some()
}
pub fn set_coin_name(&mut self, v: ::std::string::String) {
self.coin_name = ::protobuf::SingularField::some(v);
}
pub fn mut_coin_name(&mut self) -> &mut ::std::string::String {
if self.coin_name.is_none() {
self.coin_name.set_default();
}
self.coin_name.as_mut().unwrap()
}
pub fn take_coin_name(&mut self) -> ::std::string::String {
self.coin_name.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for VerifyMessage {
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.address)?;
},
2 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
},
3 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.message)?;
},
4 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.coin_name)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[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.signature.as_ref() {
my_size += ::protobuf::rt::bytes_size(2, &v);
}
if let Some(ref v) = self.message.as_ref() {
my_size += ::protobuf::rt::bytes_size(3, &v);
}
if let Some(ref v) = self.coin_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.address.as_ref() {
os.write_string(1, &v)?;
}
if let Some(ref v) = self.signature.as_ref() {
os.write_bytes(2, &v)?;
}
if let Some(ref v) = self.message.as_ref() {
os.write_bytes(3, &v)?;
}
if let Some(ref v) = self.coin_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() -> VerifyMessage {
VerifyMessage::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: &VerifyMessage| { &m.address },
|m: &mut VerifyMessage| { &mut m.address },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"signature",
|m: &VerifyMessage| { &m.signature },
|m: &mut VerifyMessage| { &mut m.signature },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"message",
|m: &VerifyMessage| { &m.message },
|m: &mut VerifyMessage| { &mut m.message },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"coin_name",
|m: &VerifyMessage| { &m.coin_name },
|m: &mut VerifyMessage| { &mut m.coin_name },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<VerifyMessage>(
"VerifyMessage",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static VerifyMessage {
static instance: ::protobuf::rt::LazyV2<VerifyMessage> = ::protobuf::rt::LazyV2::INIT;
instance.get(VerifyMessage::new)
}
}
impl ::protobuf::Clear for VerifyMessage {
fn clear(&mut self) {
self.address.clear();
self.signature.clear();
self.message.clear();
self.coin_name.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for VerifyMessage {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for VerifyMessage {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SignTx {
outputs_count: ::std::option::Option<u32>,
inputs_count: ::std::option::Option<u32>,
coin_name: ::protobuf::SingularField<::std::string::String>,
version: ::std::option::Option<u32>,
lock_time: ::std::option::Option<u32>,
expiry: ::std::option::Option<u32>,
overwintered: ::std::option::Option<bool>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SignTx {
fn default() -> &'a SignTx {
<SignTx as ::protobuf::Message>::default_instance()
}
}
impl SignTx {
pub fn new() -> SignTx {
::std::default::Default::default()
}
pub fn get_outputs_count(&self) -> u32 {
self.outputs_count.unwrap_or(0)
}
pub fn clear_outputs_count(&mut self) {
self.outputs_count = ::std::option::Option::None;
}
pub fn has_outputs_count(&self) -> bool {
self.outputs_count.is_some()
}
pub fn set_outputs_count(&mut self, v: u32) {
self.outputs_count = ::std::option::Option::Some(v);
}
pub fn get_inputs_count(&self) -> u32 {
self.inputs_count.unwrap_or(0)
}
pub fn clear_inputs_count(&mut self) {
self.inputs_count = ::std::option::Option::None;
}
pub fn has_inputs_count(&self) -> bool {
self.inputs_count.is_some()
}
pub fn set_inputs_count(&mut self, v: u32) {
self.inputs_count = ::std::option::Option::Some(v);
}
pub fn get_coin_name(&self) -> &str {
match self.coin_name.as_ref() {
Some(v) => &v,
None => "Bitcoin",
}
}
pub fn clear_coin_name(&mut self) {
self.coin_name.clear();
}
pub fn has_coin_name(&self) -> bool {
self.coin_name.is_some()
}
pub fn set_coin_name(&mut self, v: ::std::string::String) {
self.coin_name = ::protobuf::SingularField::some(v);
}
pub fn mut_coin_name(&mut self) -> &mut ::std::string::String {
if self.coin_name.is_none() {
self.coin_name.set_default();
}
self.coin_name.as_mut().unwrap()
}
pub fn take_coin_name(&mut self) -> ::std::string::String {
self.coin_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_version(&self) -> u32 {
self.version.unwrap_or(1u32)
}
pub fn clear_version(&mut self) {
self.version = ::std::option::Option::None;
}
pub fn has_version(&self) -> bool {
self.version.is_some()
}
pub fn set_version(&mut self, v: u32) {
self.version = ::std::option::Option::Some(v);
}
pub fn get_lock_time(&self) -> u32 {
self.lock_time.unwrap_or(0u32)
}
pub fn clear_lock_time(&mut self) {
self.lock_time = ::std::option::Option::None;
}
pub fn has_lock_time(&self) -> bool {
self.lock_time.is_some()
}
pub fn set_lock_time(&mut self, v: u32) {
self.lock_time = ::std::option::Option::Some(v);
}
pub fn get_expiry(&self) -> u32 {
self.expiry.unwrap_or(0)
}
pub fn clear_expiry(&mut self) {
self.expiry = ::std::option::Option::None;
}
pub fn has_expiry(&self) -> bool {
self.expiry.is_some()
}
pub fn set_expiry(&mut self, v: u32) {
self.expiry = ::std::option::Option::Some(v);
}
pub fn get_overwintered(&self) -> bool {
self.overwintered.unwrap_or(false)
}
pub fn clear_overwintered(&mut self) {
self.overwintered = ::std::option::Option::None;
}
pub fn has_overwintered(&self) -> bool {
self.overwintered.is_some()
}
pub fn set_overwintered(&mut self, v: bool) {
self.overwintered = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SignTx {
fn is_initialized(&self) -> bool {
if self.outputs_count.is_none() {
return false;
}
if self.inputs_count.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 => {
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.outputs_count = ::std::option::Option::Some(tmp);
},
2 => {
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.inputs_count = ::std::option::Option::Some(tmp);
},
3 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.coin_name)?;
},
4 => {
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.version = ::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_uint32()?;
self.lock_time = ::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_uint32()?;
self.expiry = ::std::option::Option::Some(tmp);
},
7 => {
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.overwintered = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.outputs_count {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.inputs_count {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.coin_name.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.version {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.lock_time {
my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.expiry {
my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.overwintered {
my_size += 2;
}
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(v) = self.outputs_count {
os.write_uint32(1, v)?;
}
if let Some(v) = self.inputs_count {
os.write_uint32(2, v)?;
}
if let Some(ref v) = self.coin_name.as_ref() {
os.write_string(3, &v)?;
}
if let Some(v) = self.version {
os.write_uint32(4, v)?;
}
if let Some(v) = self.lock_time {
os.write_uint32(5, v)?;
}
if let Some(v) = self.expiry {
os.write_uint32(6, v)?;
}
if let Some(v) = self.overwintered {
os.write_bool(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() -> SignTx {
SignTx::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_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"outputs_count",
|m: &SignTx| { &m.outputs_count },
|m: &mut SignTx| { &mut m.outputs_count },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"inputs_count",
|m: &SignTx| { &m.inputs_count },
|m: &mut SignTx| { &mut m.inputs_count },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"coin_name",
|m: &SignTx| { &m.coin_name },
|m: &mut SignTx| { &mut m.coin_name },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"version",
|m: &SignTx| { &m.version },
|m: &mut SignTx| { &mut m.version },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"lock_time",
|m: &SignTx| { &m.lock_time },
|m: &mut SignTx| { &mut m.lock_time },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"expiry",
|m: &SignTx| { &m.expiry },
|m: &mut SignTx| { &mut m.expiry },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"overwintered",
|m: &SignTx| { &m.overwintered },
|m: &mut SignTx| { &mut m.overwintered },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SignTx>(
"SignTx",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SignTx {
static instance: ::protobuf::rt::LazyV2<SignTx> = ::protobuf::rt::LazyV2::INIT;
instance.get(SignTx::new)
}
}
impl ::protobuf::Clear for SignTx {
fn clear(&mut self) {
self.outputs_count = ::std::option::Option::None;
self.inputs_count = ::std::option::Option::None;
self.coin_name.clear();
self.version = ::std::option::Option::None;
self.lock_time = ::std::option::Option::None;
self.expiry = ::std::option::Option::None;
self.overwintered = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SignTx {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SignTx {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxRequest {
request_type: ::std::option::Option<TxRequest_RequestType>,
pub details: ::protobuf::SingularPtrField<TxRequest_TxRequestDetailsType>,
pub serialized: ::protobuf::SingularPtrField<TxRequest_TxRequestSerializedType>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxRequest {
fn default() -> &'a TxRequest {
<TxRequest as ::protobuf::Message>::default_instance()
}
}
impl TxRequest {
pub fn new() -> TxRequest {
::std::default::Default::default()
}
pub fn get_request_type(&self) -> TxRequest_RequestType {
self.request_type.unwrap_or(TxRequest_RequestType::TXINPUT)
}
pub fn clear_request_type(&mut self) {
self.request_type = ::std::option::Option::None;
}
pub fn has_request_type(&self) -> bool {
self.request_type.is_some()
}
pub fn set_request_type(&mut self, v: TxRequest_RequestType) {
self.request_type = ::std::option::Option::Some(v);
}
pub fn get_details(&self) -> &TxRequest_TxRequestDetailsType {
self.details.as_ref().unwrap_or_else(|| <TxRequest_TxRequestDetailsType as ::protobuf::Message>::default_instance())
}
pub fn clear_details(&mut self) {
self.details.clear();
}
pub fn has_details(&self) -> bool {
self.details.is_some()
}
pub fn set_details(&mut self, v: TxRequest_TxRequestDetailsType) {
self.details = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_details(&mut self) -> &mut TxRequest_TxRequestDetailsType {
if self.details.is_none() {
self.details.set_default();
}
self.details.as_mut().unwrap()
}
pub fn take_details(&mut self) -> TxRequest_TxRequestDetailsType {
self.details.take().unwrap_or_else(|| TxRequest_TxRequestDetailsType::new())
}
pub fn get_serialized(&self) -> &TxRequest_TxRequestSerializedType {
self.serialized.as_ref().unwrap_or_else(|| <TxRequest_TxRequestSerializedType as ::protobuf::Message>::default_instance())
}
pub fn clear_serialized(&mut self) {
self.serialized.clear();
}
pub fn has_serialized(&self) -> bool {
self.serialized.is_some()
}
pub fn set_serialized(&mut self, v: TxRequest_TxRequestSerializedType) {
self.serialized = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_serialized(&mut self) -> &mut TxRequest_TxRequestSerializedType {
if self.serialized.is_none() {
self.serialized.set_default();
}
self.serialized.as_mut().unwrap()
}
pub fn take_serialized(&mut self) -> TxRequest_TxRequestSerializedType {
self.serialized.take().unwrap_or_else(|| TxRequest_TxRequestSerializedType::new())
}
}
impl ::protobuf::Message for TxRequest {
fn is_initialized(&self) -> bool {
for v in &self.details {
if !v.is_initialized() {
return false;
}
};
for v in &self.serialized {
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_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.request_type, 1, &mut self.unknown_fields)?
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.details)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.serialized)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.request_type {
my_size += ::protobuf::rt::enum_size(1, v);
}
if let Some(ref v) = self.details.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.serialized.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
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(v) = self.request_type {
os.write_enum(1, ::protobuf::ProtobufEnum::value(&v))?;
}
if let Some(ref v) = self.details.as_ref() {
os.write_tag(2, ::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.serialized.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
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() -> TxRequest {
TxRequest::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_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<TxRequest_RequestType>>(
"request_type",
|m: &TxRequest| { &m.request_type },
|m: &mut TxRequest| { &mut m.request_type },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TxRequest_TxRequestDetailsType>>(
"details",
|m: &TxRequest| { &m.details },
|m: &mut TxRequest| { &mut m.details },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TxRequest_TxRequestSerializedType>>(
"serialized",
|m: &TxRequest| { &m.serialized },
|m: &mut TxRequest| { &mut m.serialized },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxRequest>(
"TxRequest",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxRequest {
static instance: ::protobuf::rt::LazyV2<TxRequest> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxRequest::new)
}
}
impl ::protobuf::Clear for TxRequest {
fn clear(&mut self) {
self.request_type = ::std::option::Option::None;
self.details.clear();
self.serialized.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxRequest {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxRequest_TxRequestDetailsType {
request_index: ::std::option::Option<u32>,
tx_hash: ::protobuf::SingularField<::std::vec::Vec<u8>>,
extra_data_len: ::std::option::Option<u32>,
extra_data_offset: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxRequest_TxRequestDetailsType {
fn default() -> &'a TxRequest_TxRequestDetailsType {
<TxRequest_TxRequestDetailsType as ::protobuf::Message>::default_instance()
}
}
impl TxRequest_TxRequestDetailsType {
pub fn new() -> TxRequest_TxRequestDetailsType {
::std::default::Default::default()
}
pub fn get_request_index(&self) -> u32 {
self.request_index.unwrap_or(0)
}
pub fn clear_request_index(&mut self) {
self.request_index = ::std::option::Option::None;
}
pub fn has_request_index(&self) -> bool {
self.request_index.is_some()
}
pub fn set_request_index(&mut self, v: u32) {
self.request_index = ::std::option::Option::Some(v);
}
pub fn get_tx_hash(&self) -> &[u8] {
match self.tx_hash.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_tx_hash(&mut self) {
self.tx_hash.clear();
}
pub fn has_tx_hash(&self) -> bool {
self.tx_hash.is_some()
}
pub fn set_tx_hash(&mut self, v: ::std::vec::Vec<u8>) {
self.tx_hash = ::protobuf::SingularField::some(v);
}
pub fn mut_tx_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.tx_hash.is_none() {
self.tx_hash.set_default();
}
self.tx_hash.as_mut().unwrap()
}
pub fn take_tx_hash(&mut self) -> ::std::vec::Vec<u8> {
self.tx_hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_extra_data_len(&self) -> u32 {
self.extra_data_len.unwrap_or(0)
}
pub fn clear_extra_data_len(&mut self) {
self.extra_data_len = ::std::option::Option::None;
}
pub fn has_extra_data_len(&self) -> bool {
self.extra_data_len.is_some()
}
pub fn set_extra_data_len(&mut self, v: u32) {
self.extra_data_len = ::std::option::Option::Some(v);
}
pub fn get_extra_data_offset(&self) -> u32 {
self.extra_data_offset.unwrap_or(0)
}
pub fn clear_extra_data_offset(&mut self) {
self.extra_data_offset = ::std::option::Option::None;
}
pub fn has_extra_data_offset(&self) -> bool {
self.extra_data_offset.is_some()
}
pub fn set_extra_data_offset(&mut self, v: u32) {
self.extra_data_offset = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TxRequest_TxRequestDetailsType {
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 => {
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.request_index = ::std::option::Option::Some(tmp);
},
2 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.tx_hash)?;
},
3 => {
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.extra_data_len = ::std::option::Option::Some(tmp);
},
4 => {
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.extra_data_offset = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.request_index {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.tx_hash.as_ref() {
my_size += ::protobuf::rt::bytes_size(2, &v);
}
if let Some(v) = self.extra_data_len {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.extra_data_offset {
my_size += ::protobuf::rt::value_size(4, 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(v) = self.request_index {
os.write_uint32(1, v)?;
}
if let Some(ref v) = self.tx_hash.as_ref() {
os.write_bytes(2, &v)?;
}
if let Some(v) = self.extra_data_len {
os.write_uint32(3, v)?;
}
if let Some(v) = self.extra_data_offset {
os.write_uint32(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() -> TxRequest_TxRequestDetailsType {
TxRequest_TxRequestDetailsType::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_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"request_index",
|m: &TxRequest_TxRequestDetailsType| { &m.request_index },
|m: &mut TxRequest_TxRequestDetailsType| { &mut m.request_index },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"tx_hash",
|m: &TxRequest_TxRequestDetailsType| { &m.tx_hash },
|m: &mut TxRequest_TxRequestDetailsType| { &mut m.tx_hash },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"extra_data_len",
|m: &TxRequest_TxRequestDetailsType| { &m.extra_data_len },
|m: &mut TxRequest_TxRequestDetailsType| { &mut m.extra_data_len },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"extra_data_offset",
|m: &TxRequest_TxRequestDetailsType| { &m.extra_data_offset },
|m: &mut TxRequest_TxRequestDetailsType| { &mut m.extra_data_offset },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxRequest_TxRequestDetailsType>(
"TxRequest.TxRequestDetailsType",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxRequest_TxRequestDetailsType {
static instance: ::protobuf::rt::LazyV2<TxRequest_TxRequestDetailsType> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxRequest_TxRequestDetailsType::new)
}
}
impl ::protobuf::Clear for TxRequest_TxRequestDetailsType {
fn clear(&mut self) {
self.request_index = ::std::option::Option::None;
self.tx_hash.clear();
self.extra_data_len = ::std::option::Option::None;
self.extra_data_offset = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxRequest_TxRequestDetailsType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxRequest_TxRequestDetailsType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxRequest_TxRequestSerializedType {
signature_index: ::std::option::Option<u32>,
signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
serialized_tx: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxRequest_TxRequestSerializedType {
fn default() -> &'a TxRequest_TxRequestSerializedType {
<TxRequest_TxRequestSerializedType as ::protobuf::Message>::default_instance()
}
}
impl TxRequest_TxRequestSerializedType {
pub fn new() -> TxRequest_TxRequestSerializedType {
::std::default::Default::default()
}
pub fn get_signature_index(&self) -> u32 {
self.signature_index.unwrap_or(0)
}
pub fn clear_signature_index(&mut self) {
self.signature_index = ::std::option::Option::None;
}
pub fn has_signature_index(&self) -> bool {
self.signature_index.is_some()
}
pub fn set_signature_index(&mut self, v: u32) {
self.signature_index = ::std::option::Option::Some(v);
}
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()
}
pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
self.signature = ::protobuf::SingularField::some(v);
}
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()
}
pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_serialized_tx(&self) -> &[u8] {
match self.serialized_tx.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_serialized_tx(&mut self) {
self.serialized_tx.clear();
}
pub fn has_serialized_tx(&self) -> bool {
self.serialized_tx.is_some()
}
pub fn set_serialized_tx(&mut self, v: ::std::vec::Vec<u8>) {
self.serialized_tx = ::protobuf::SingularField::some(v);
}
pub fn mut_serialized_tx(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.serialized_tx.is_none() {
self.serialized_tx.set_default();
}
self.serialized_tx.as_mut().unwrap()
}
pub fn take_serialized_tx(&mut self) -> ::std::vec::Vec<u8> {
self.serialized_tx.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for TxRequest_TxRequestSerializedType {
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 => {
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.signature_index = ::std::option::Option::Some(tmp);
},
2 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
},
3 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.serialized_tx)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.signature_index {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.signature.as_ref() {
my_size += ::protobuf::rt::bytes_size(2, &v);
}
if let Some(ref v) = self.serialized_tx.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(v) = self.signature_index {
os.write_uint32(1, v)?;
}
if let Some(ref v) = self.signature.as_ref() {
os.write_bytes(2, &v)?;
}
if let Some(ref v) = self.serialized_tx.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() -> TxRequest_TxRequestSerializedType {
TxRequest_TxRequestSerializedType::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_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"signature_index",
|m: &TxRequest_TxRequestSerializedType| { &m.signature_index },
|m: &mut TxRequest_TxRequestSerializedType| { &mut m.signature_index },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"signature",
|m: &TxRequest_TxRequestSerializedType| { &m.signature },
|m: &mut TxRequest_TxRequestSerializedType| { &mut m.signature },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"serialized_tx",
|m: &TxRequest_TxRequestSerializedType| { &m.serialized_tx },
|m: &mut TxRequest_TxRequestSerializedType| { &mut m.serialized_tx },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxRequest_TxRequestSerializedType>(
"TxRequest.TxRequestSerializedType",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxRequest_TxRequestSerializedType {
static instance: ::protobuf::rt::LazyV2<TxRequest_TxRequestSerializedType> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxRequest_TxRequestSerializedType::new)
}
}
impl ::protobuf::Clear for TxRequest_TxRequestSerializedType {
fn clear(&mut self) {
self.signature_index = ::std::option::Option::None;
self.signature.clear();
self.serialized_tx.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxRequest_TxRequestSerializedType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxRequest_TxRequestSerializedType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum TxRequest_RequestType {
TXINPUT = 0,
TXOUTPUT = 1,
TXMETA = 2,
TXFINISHED = 3,
TXEXTRADATA = 4,
}
impl ::protobuf::ProtobufEnum for TxRequest_RequestType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<TxRequest_RequestType> {
match value {
0 => ::std::option::Option::Some(TxRequest_RequestType::TXINPUT),
1 => ::std::option::Option::Some(TxRequest_RequestType::TXOUTPUT),
2 => ::std::option::Option::Some(TxRequest_RequestType::TXMETA),
3 => ::std::option::Option::Some(TxRequest_RequestType::TXFINISHED),
4 => ::std::option::Option::Some(TxRequest_RequestType::TXEXTRADATA),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [TxRequest_RequestType] = &[
TxRequest_RequestType::TXINPUT,
TxRequest_RequestType::TXOUTPUT,
TxRequest_RequestType::TXMETA,
TxRequest_RequestType::TXFINISHED,
TxRequest_RequestType::TXEXTRADATA,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<TxRequest_RequestType>("TxRequest.RequestType", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for TxRequest_RequestType {
}
impl ::std::default::Default for TxRequest_RequestType {
fn default() -> Self {
TxRequest_RequestType::TXINPUT
}
}
impl ::protobuf::reflect::ProtobufValue for TxRequest_RequestType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAck {
pub tx: ::protobuf::SingularPtrField<TxAck_TransactionType>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAck {
fn default() -> &'a TxAck {
<TxAck as ::protobuf::Message>::default_instance()
}
}
impl TxAck {
pub fn new() -> TxAck {
::std::default::Default::default()
}
pub fn get_tx(&self) -> &TxAck_TransactionType {
self.tx.as_ref().unwrap_or_else(|| <TxAck_TransactionType as ::protobuf::Message>::default_instance())
}
pub fn clear_tx(&mut self) {
self.tx.clear();
}
pub fn has_tx(&self) -> bool {
self.tx.is_some()
}
pub fn set_tx(&mut self, v: TxAck_TransactionType) {
self.tx = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_tx(&mut self) -> &mut TxAck_TransactionType {
if self.tx.is_none() {
self.tx.set_default();
}
self.tx.as_mut().unwrap()
}
pub fn take_tx(&mut self) -> TxAck_TransactionType {
self.tx.take().unwrap_or_else(|| TxAck_TransactionType::new())
}
}
impl ::protobuf::Message for TxAck {
fn is_initialized(&self) -> bool {
for v in &self.tx {
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.tx)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.tx.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
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.tx.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)?;
}
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() -> TxAck {
TxAck::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<TxAck_TransactionType>>(
"tx",
|m: &TxAck| { &m.tx },
|m: &mut TxAck| { &mut m.tx },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAck>(
"TxAck",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAck {
static instance: ::protobuf::rt::LazyV2<TxAck> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAck::new)
}
}
impl ::protobuf::Clear for TxAck {
fn clear(&mut self) {
self.tx.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAck {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAck {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAck_TransactionType {
version: ::std::option::Option<u32>,
pub inputs: ::protobuf::RepeatedField<TxAck_TransactionType_TxInputType>,
pub bin_outputs: ::protobuf::RepeatedField<TxAck_TransactionType_TxOutputBinType>,
lock_time: ::std::option::Option<u32>,
pub outputs: ::protobuf::RepeatedField<TxAck_TransactionType_TxOutputType>,
inputs_cnt: ::std::option::Option<u32>,
outputs_cnt: ::std::option::Option<u32>,
extra_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
extra_data_len: ::std::option::Option<u32>,
expiry: ::std::option::Option<u32>,
overwintered: ::std::option::Option<bool>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAck_TransactionType {
fn default() -> &'a TxAck_TransactionType {
<TxAck_TransactionType as ::protobuf::Message>::default_instance()
}
}
impl TxAck_TransactionType {
pub fn new() -> TxAck_TransactionType {
::std::default::Default::default()
}
pub fn get_version(&self) -> u32 {
self.version.unwrap_or(0)
}
pub fn clear_version(&mut self) {
self.version = ::std::option::Option::None;
}
pub fn has_version(&self) -> bool {
self.version.is_some()
}
pub fn set_version(&mut self, v: u32) {
self.version = ::std::option::Option::Some(v);
}
pub fn get_inputs(&self) -> &[TxAck_TransactionType_TxInputType] {
&self.inputs
}
pub fn clear_inputs(&mut self) {
self.inputs.clear();
}
pub fn set_inputs(&mut self, v: ::protobuf::RepeatedField<TxAck_TransactionType_TxInputType>) {
self.inputs = v;
}
pub fn mut_inputs(&mut self) -> &mut ::protobuf::RepeatedField<TxAck_TransactionType_TxInputType> {
&mut self.inputs
}
pub fn take_inputs(&mut self) -> ::protobuf::RepeatedField<TxAck_TransactionType_TxInputType> {
::std::mem::replace(&mut self.inputs, ::protobuf::RepeatedField::new())
}
pub fn get_bin_outputs(&self) -> &[TxAck_TransactionType_TxOutputBinType] {
&self.bin_outputs
}
pub fn clear_bin_outputs(&mut self) {
self.bin_outputs.clear();
}
pub fn set_bin_outputs(&mut self, v: ::protobuf::RepeatedField<TxAck_TransactionType_TxOutputBinType>) {
self.bin_outputs = v;
}
pub fn mut_bin_outputs(&mut self) -> &mut ::protobuf::RepeatedField<TxAck_TransactionType_TxOutputBinType> {
&mut self.bin_outputs
}
pub fn take_bin_outputs(&mut self) -> ::protobuf::RepeatedField<TxAck_TransactionType_TxOutputBinType> {
::std::mem::replace(&mut self.bin_outputs, ::protobuf::RepeatedField::new())
}
pub fn get_lock_time(&self) -> u32 {
self.lock_time.unwrap_or(0)
}
pub fn clear_lock_time(&mut self) {
self.lock_time = ::std::option::Option::None;
}
pub fn has_lock_time(&self) -> bool {
self.lock_time.is_some()
}
pub fn set_lock_time(&mut self, v: u32) {
self.lock_time = ::std::option::Option::Some(v);
}
pub fn get_outputs(&self) -> &[TxAck_TransactionType_TxOutputType] {
&self.outputs
}
pub fn clear_outputs(&mut self) {
self.outputs.clear();
}
pub fn set_outputs(&mut self, v: ::protobuf::RepeatedField<TxAck_TransactionType_TxOutputType>) {
self.outputs = v;
}
pub fn mut_outputs(&mut self) -> &mut ::protobuf::RepeatedField<TxAck_TransactionType_TxOutputType> {
&mut self.outputs
}
pub fn take_outputs(&mut self) -> ::protobuf::RepeatedField<TxAck_TransactionType_TxOutputType> {
::std::mem::replace(&mut self.outputs, ::protobuf::RepeatedField::new())
}
pub fn get_inputs_cnt(&self) -> u32 {
self.inputs_cnt.unwrap_or(0)
}
pub fn clear_inputs_cnt(&mut self) {
self.inputs_cnt = ::std::option::Option::None;
}
pub fn has_inputs_cnt(&self) -> bool {
self.inputs_cnt.is_some()
}
pub fn set_inputs_cnt(&mut self, v: u32) {
self.inputs_cnt = ::std::option::Option::Some(v);
}
pub fn get_outputs_cnt(&self) -> u32 {
self.outputs_cnt.unwrap_or(0)
}
pub fn clear_outputs_cnt(&mut self) {
self.outputs_cnt = ::std::option::Option::None;
}
pub fn has_outputs_cnt(&self) -> bool {
self.outputs_cnt.is_some()
}
pub fn set_outputs_cnt(&mut self, v: u32) {
self.outputs_cnt = ::std::option::Option::Some(v);
}
pub fn get_extra_data(&self) -> &[u8] {
match self.extra_data.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_extra_data(&mut self) {
self.extra_data.clear();
}
pub fn has_extra_data(&self) -> bool {
self.extra_data.is_some()
}
pub fn set_extra_data(&mut self, v: ::std::vec::Vec<u8>) {
self.extra_data = ::protobuf::SingularField::some(v);
}
pub fn mut_extra_data(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.extra_data.is_none() {
self.extra_data.set_default();
}
self.extra_data.as_mut().unwrap()
}
pub fn take_extra_data(&mut self) -> ::std::vec::Vec<u8> {
self.extra_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_extra_data_len(&self) -> u32 {
self.extra_data_len.unwrap_or(0)
}
pub fn clear_extra_data_len(&mut self) {
self.extra_data_len = ::std::option::Option::None;
}
pub fn has_extra_data_len(&self) -> bool {
self.extra_data_len.is_some()
}
pub fn set_extra_data_len(&mut self, v: u32) {
self.extra_data_len = ::std::option::Option::Some(v);
}
pub fn get_expiry(&self) -> u32 {
self.expiry.unwrap_or(0)
}
pub fn clear_expiry(&mut self) {
self.expiry = ::std::option::Option::None;
}
pub fn has_expiry(&self) -> bool {
self.expiry.is_some()
}
pub fn set_expiry(&mut self, v: u32) {
self.expiry = ::std::option::Option::Some(v);
}
pub fn get_overwintered(&self) -> bool {
self.overwintered.unwrap_or(false)
}
pub fn clear_overwintered(&mut self) {
self.overwintered = ::std::option::Option::None;
}
pub fn has_overwintered(&self) -> bool {
self.overwintered.is_some()
}
pub fn set_overwintered(&mut self, v: bool) {
self.overwintered = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TxAck_TransactionType {
fn is_initialized(&self) -> bool {
for v in &self.inputs {
if !v.is_initialized() {
return false;
}
};
for v in &self.bin_outputs {
if !v.is_initialized() {
return false;
}
};
for v in &self.outputs {
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 => {
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.version = ::std::option::Option::Some(tmp);
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.inputs)?;
},
3 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.bin_outputs)?;
},
4 => {
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.lock_time = ::std::option::Option::Some(tmp);
},
5 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.outputs)?;
},
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.inputs_cnt = ::std::option::Option::Some(tmp);
},
7 => {
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.outputs_cnt = ::std::option::Option::Some(tmp);
},
8 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.extra_data)?;
},
9 => {
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.extra_data_len = ::std::option::Option::Some(tmp);
},
10 => {
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.expiry = ::std::option::Option::Some(tmp);
},
11 => {
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.overwintered = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.version {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.inputs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.bin_outputs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if let Some(v) = self.lock_time {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.outputs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if let Some(v) = self.inputs_cnt {
my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.outputs_cnt {
my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.extra_data.as_ref() {
my_size += ::protobuf::rt::bytes_size(8, &v);
}
if let Some(v) = self.extra_data_len {
my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.expiry {
my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.overwintered {
my_size += 2;
}
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(v) = self.version {
os.write_uint32(1, v)?;
}
for v in &self.inputs {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.bin_outputs {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if let Some(v) = self.lock_time {
os.write_uint32(4, v)?;
}
for v in &self.outputs {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if let Some(v) = self.inputs_cnt {
os.write_uint32(6, v)?;
}
if let Some(v) = self.outputs_cnt {
os.write_uint32(7, v)?;
}
if let Some(ref v) = self.extra_data.as_ref() {
os.write_bytes(8, &v)?;
}
if let Some(v) = self.extra_data_len {
os.write_uint32(9, v)?;
}
if let Some(v) = self.expiry {
os.write_uint32(10, v)?;
}
if let Some(v) = self.overwintered {
os.write_bool(11, 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() -> TxAck_TransactionType {
TxAck_TransactionType::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_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"version",
|m: &TxAck_TransactionType| { &m.version },
|m: &mut TxAck_TransactionType| { &mut m.version },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TxAck_TransactionType_TxInputType>>(
"inputs",
|m: &TxAck_TransactionType| { &m.inputs },
|m: &mut TxAck_TransactionType| { &mut m.inputs },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TxAck_TransactionType_TxOutputBinType>>(
"bin_outputs",
|m: &TxAck_TransactionType| { &m.bin_outputs },
|m: &mut TxAck_TransactionType| { &mut m.bin_outputs },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"lock_time",
|m: &TxAck_TransactionType| { &m.lock_time },
|m: &mut TxAck_TransactionType| { &mut m.lock_time },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TxAck_TransactionType_TxOutputType>>(
"outputs",
|m: &TxAck_TransactionType| { &m.outputs },
|m: &mut TxAck_TransactionType| { &mut m.outputs },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"inputs_cnt",
|m: &TxAck_TransactionType| { &m.inputs_cnt },
|m: &mut TxAck_TransactionType| { &mut m.inputs_cnt },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"outputs_cnt",
|m: &TxAck_TransactionType| { &m.outputs_cnt },
|m: &mut TxAck_TransactionType| { &mut m.outputs_cnt },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"extra_data",
|m: &TxAck_TransactionType| { &m.extra_data },
|m: &mut TxAck_TransactionType| { &mut m.extra_data },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"extra_data_len",
|m: &TxAck_TransactionType| { &m.extra_data_len },
|m: &mut TxAck_TransactionType| { &mut m.extra_data_len },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"expiry",
|m: &TxAck_TransactionType| { &m.expiry },
|m: &mut TxAck_TransactionType| { &mut m.expiry },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"overwintered",
|m: &TxAck_TransactionType| { &m.overwintered },
|m: &mut TxAck_TransactionType| { &mut m.overwintered },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAck_TransactionType>(
"TxAck.TransactionType",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAck_TransactionType {
static instance: ::protobuf::rt::LazyV2<TxAck_TransactionType> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAck_TransactionType::new)
}
}
impl ::protobuf::Clear for TxAck_TransactionType {
fn clear(&mut self) {
self.version = ::std::option::Option::None;
self.inputs.clear();
self.bin_outputs.clear();
self.lock_time = ::std::option::Option::None;
self.outputs.clear();
self.inputs_cnt = ::std::option::Option::None;
self.outputs_cnt = ::std::option::Option::None;
self.extra_data.clear();
self.extra_data_len = ::std::option::Option::None;
self.expiry = ::std::option::Option::None;
self.overwintered = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAck_TransactionType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAck_TransactionType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAck_TransactionType_TxInputType {
pub address_n: ::std::vec::Vec<u32>,
prev_hash: ::protobuf::SingularField<::std::vec::Vec<u8>>,
prev_index: ::std::option::Option<u32>,
script_sig: ::protobuf::SingularField<::std::vec::Vec<u8>>,
sequence: ::std::option::Option<u32>,
script_type: ::std::option::Option<InputScriptType>,
pub multisig: ::protobuf::SingularPtrField<MultisigRedeemScriptType>,
amount: ::std::option::Option<u64>,
decred_tree: ::std::option::Option<u32>,
decred_script_version: ::std::option::Option<u32>,
prev_block_hash_bip115: ::protobuf::SingularField<::std::vec::Vec<u8>>,
prev_block_height_bip115: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAck_TransactionType_TxInputType {
fn default() -> &'a TxAck_TransactionType_TxInputType {
<TxAck_TransactionType_TxInputType as ::protobuf::Message>::default_instance()
}
}
impl TxAck_TransactionType_TxInputType {
pub fn new() -> TxAck_TransactionType_TxInputType {
::std::default::Default::default()
}
pub fn get_address_n(&self) -> &[u32] {
&self.address_n
}
pub fn clear_address_n(&mut self) {
self.address_n.clear();
}
pub fn set_address_n(&mut self, v: ::std::vec::Vec<u32>) {
self.address_n = v;
}
pub fn mut_address_n(&mut self) -> &mut ::std::vec::Vec<u32> {
&mut self.address_n
}
pub fn take_address_n(&mut self) -> ::std::vec::Vec<u32> {
::std::mem::replace(&mut self.address_n, ::std::vec::Vec::new())
}
pub fn get_prev_hash(&self) -> &[u8] {
match self.prev_hash.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_prev_hash(&mut self) {
self.prev_hash.clear();
}
pub fn has_prev_hash(&self) -> bool {
self.prev_hash.is_some()
}
pub fn set_prev_hash(&mut self, v: ::std::vec::Vec<u8>) {
self.prev_hash = ::protobuf::SingularField::some(v);
}
pub fn mut_prev_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.prev_hash.is_none() {
self.prev_hash.set_default();
}
self.prev_hash.as_mut().unwrap()
}
pub fn take_prev_hash(&mut self) -> ::std::vec::Vec<u8> {
self.prev_hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_prev_index(&self) -> u32 {
self.prev_index.unwrap_or(0)
}
pub fn clear_prev_index(&mut self) {
self.prev_index = ::std::option::Option::None;
}
pub fn has_prev_index(&self) -> bool {
self.prev_index.is_some()
}
pub fn set_prev_index(&mut self, v: u32) {
self.prev_index = ::std::option::Option::Some(v);
}
pub fn get_script_sig(&self) -> &[u8] {
match self.script_sig.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_script_sig(&mut self) {
self.script_sig.clear();
}
pub fn has_script_sig(&self) -> bool {
self.script_sig.is_some()
}
pub fn set_script_sig(&mut self, v: ::std::vec::Vec<u8>) {
self.script_sig = ::protobuf::SingularField::some(v);
}
pub fn mut_script_sig(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.script_sig.is_none() {
self.script_sig.set_default();
}
self.script_sig.as_mut().unwrap()
}
pub fn take_script_sig(&mut self) -> ::std::vec::Vec<u8> {
self.script_sig.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_sequence(&self) -> u32 {
self.sequence.unwrap_or(4294967295u32)
}
pub fn clear_sequence(&mut self) {
self.sequence = ::std::option::Option::None;
}
pub fn has_sequence(&self) -> bool {
self.sequence.is_some()
}
pub fn set_sequence(&mut self, v: u32) {
self.sequence = ::std::option::Option::Some(v);
}
pub fn get_script_type(&self) -> InputScriptType {
self.script_type.unwrap_or(InputScriptType::SPENDADDRESS)
}
pub fn clear_script_type(&mut self) {
self.script_type = ::std::option::Option::None;
}
pub fn has_script_type(&self) -> bool {
self.script_type.is_some()
}
pub fn set_script_type(&mut self, v: InputScriptType) {
self.script_type = ::std::option::Option::Some(v);
}
pub fn get_multisig(&self) -> &MultisigRedeemScriptType {
self.multisig.as_ref().unwrap_or_else(|| <MultisigRedeemScriptType as ::protobuf::Message>::default_instance())
}
pub fn clear_multisig(&mut self) {
self.multisig.clear();
}
pub fn has_multisig(&self) -> bool {
self.multisig.is_some()
}
pub fn set_multisig(&mut self, v: MultisigRedeemScriptType) {
self.multisig = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_multisig(&mut self) -> &mut MultisigRedeemScriptType {
if self.multisig.is_none() {
self.multisig.set_default();
}
self.multisig.as_mut().unwrap()
}
pub fn take_multisig(&mut self) -> MultisigRedeemScriptType {
self.multisig.take().unwrap_or_else(|| MultisigRedeemScriptType::new())
}
pub fn get_amount(&self) -> u64 {
self.amount.unwrap_or(0)
}
pub fn clear_amount(&mut self) {
self.amount = ::std::option::Option::None;
}
pub fn has_amount(&self) -> bool {
self.amount.is_some()
}
pub fn set_amount(&mut self, v: u64) {
self.amount = ::std::option::Option::Some(v);
}
pub fn get_decred_tree(&self) -> u32 {
self.decred_tree.unwrap_or(0)
}
pub fn clear_decred_tree(&mut self) {
self.decred_tree = ::std::option::Option::None;
}
pub fn has_decred_tree(&self) -> bool {
self.decred_tree.is_some()
}
pub fn set_decred_tree(&mut self, v: u32) {
self.decred_tree = ::std::option::Option::Some(v);
}
pub fn get_decred_script_version(&self) -> u32 {
self.decred_script_version.unwrap_or(0)
}
pub fn clear_decred_script_version(&mut self) {
self.decred_script_version = ::std::option::Option::None;
}
pub fn has_decred_script_version(&self) -> bool {
self.decred_script_version.is_some()
}
pub fn set_decred_script_version(&mut self, v: u32) {
self.decred_script_version = ::std::option::Option::Some(v);
}
pub fn get_prev_block_hash_bip115(&self) -> &[u8] {
match self.prev_block_hash_bip115.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_prev_block_hash_bip115(&mut self) {
self.prev_block_hash_bip115.clear();
}
pub fn has_prev_block_hash_bip115(&self) -> bool {
self.prev_block_hash_bip115.is_some()
}
pub fn set_prev_block_hash_bip115(&mut self, v: ::std::vec::Vec<u8>) {
self.prev_block_hash_bip115 = ::protobuf::SingularField::some(v);
}
pub fn mut_prev_block_hash_bip115(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.prev_block_hash_bip115.is_none() {
self.prev_block_hash_bip115.set_default();
}
self.prev_block_hash_bip115.as_mut().unwrap()
}
pub fn take_prev_block_hash_bip115(&mut self) -> ::std::vec::Vec<u8> {
self.prev_block_hash_bip115.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_prev_block_height_bip115(&self) -> u32 {
self.prev_block_height_bip115.unwrap_or(0)
}
pub fn clear_prev_block_height_bip115(&mut self) {
self.prev_block_height_bip115 = ::std::option::Option::None;
}
pub fn has_prev_block_height_bip115(&self) -> bool {
self.prev_block_height_bip115.is_some()
}
pub fn set_prev_block_height_bip115(&mut self, v: u32) {
self.prev_block_height_bip115 = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TxAck_TransactionType_TxInputType {
fn is_initialized(&self) -> bool {
if self.prev_hash.is_none() {
return false;
}
if self.prev_index.is_none() {
return false;
}
for v in &self.multisig {
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_repeated_uint32_into(wire_type, is, &mut self.address_n)?;
},
2 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.prev_hash)?;
},
3 => {
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.prev_index = ::std::option::Option::Some(tmp);
},
4 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.script_sig)?;
},
5 => {
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.sequence = ::std::option::Option::Some(tmp);
},
6 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.script_type, 6, &mut self.unknown_fields)?
},
7 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.multisig)?;
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.amount = ::std::option::Option::Some(tmp);
},
9 => {
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.decred_tree = ::std::option::Option::Some(tmp);
},
10 => {
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.decred_script_version = ::std::option::Option::Some(tmp);
},
11 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.prev_block_hash_bip115)?;
},
12 => {
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.prev_block_height_bip115 = ::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(())
}
#[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.prev_hash.as_ref() {
my_size += ::protobuf::rt::bytes_size(2, &v);
}
if let Some(v) = self.prev_index {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.script_sig.as_ref() {
my_size += ::protobuf::rt::bytes_size(4, &v);
}
if let Some(v) = self.sequence {
my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.script_type {
my_size += ::protobuf::rt::enum_size(6, v);
}
if let Some(ref v) = self.multisig.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(v) = self.amount {
my_size += ::protobuf::rt::value_size(8, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.decred_tree {
my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.decred_script_version {
my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.prev_block_hash_bip115.as_ref() {
my_size += ::protobuf::rt::bytes_size(11, &v);
}
if let Some(v) = self.prev_block_height_bip115 {
my_size += ::protobuf::rt::value_size(12, 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<()> {
for v in &self.address_n {
os.write_uint32(1, *v)?;
};
if let Some(ref v) = self.prev_hash.as_ref() {
os.write_bytes(2, &v)?;
}
if let Some(v) = self.prev_index {
os.write_uint32(3, v)?;
}
if let Some(ref v) = self.script_sig.as_ref() {
os.write_bytes(4, &v)?;
}
if let Some(v) = self.sequence {
os.write_uint32(5, v)?;
}
if let Some(v) = self.script_type {
os.write_enum(6, ::protobuf::ProtobufEnum::value(&v))?;
}
if let Some(ref v) = self.multisig.as_ref() {
os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(v) = self.amount {
os.write_uint64(8, v)?;
}
if let Some(v) = self.decred_tree {
os.write_uint32(9, v)?;
}
if let Some(v) = self.decred_script_version {
os.write_uint32(10, v)?;
}
if let Some(ref v) = self.prev_block_hash_bip115.as_ref() {
os.write_bytes(11, &v)?;
}
if let Some(v) = self.prev_block_height_bip115 {
os.write_uint32(12, 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() -> TxAck_TransactionType_TxInputType {
TxAck_TransactionType_TxInputType::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: &TxAck_TransactionType_TxInputType| { &m.address_n },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"prev_hash",
|m: &TxAck_TransactionType_TxInputType| { &m.prev_hash },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.prev_hash },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"prev_index",
|m: &TxAck_TransactionType_TxInputType| { &m.prev_index },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.prev_index },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"script_sig",
|m: &TxAck_TransactionType_TxInputType| { &m.script_sig },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.script_sig },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"sequence",
|m: &TxAck_TransactionType_TxInputType| { &m.sequence },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.sequence },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<InputScriptType>>(
"script_type",
|m: &TxAck_TransactionType_TxInputType| { &m.script_type },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.script_type },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MultisigRedeemScriptType>>(
"multisig",
|m: &TxAck_TransactionType_TxInputType| { &m.multisig },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.multisig },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"amount",
|m: &TxAck_TransactionType_TxInputType| { &m.amount },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.amount },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"decred_tree",
|m: &TxAck_TransactionType_TxInputType| { &m.decred_tree },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.decred_tree },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"decred_script_version",
|m: &TxAck_TransactionType_TxInputType| { &m.decred_script_version },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.decred_script_version },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"prev_block_hash_bip115",
|m: &TxAck_TransactionType_TxInputType| { &m.prev_block_hash_bip115 },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.prev_block_hash_bip115 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"prev_block_height_bip115",
|m: &TxAck_TransactionType_TxInputType| { &m.prev_block_height_bip115 },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.prev_block_height_bip115 },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAck_TransactionType_TxInputType>(
"TxAck.TransactionType.TxInputType",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAck_TransactionType_TxInputType {
static instance: ::protobuf::rt::LazyV2<TxAck_TransactionType_TxInputType> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAck_TransactionType_TxInputType::new)
}
}
impl ::protobuf::Clear for TxAck_TransactionType_TxInputType {
fn clear(&mut self) {
self.address_n.clear();
self.prev_hash.clear();
self.prev_index = ::std::option::Option::None;
self.script_sig.clear();
self.sequence = ::std::option::Option::None;
self.script_type = ::std::option::Option::None;
self.multisig.clear();
self.amount = ::std::option::Option::None;
self.decred_tree = ::std::option::Option::None;
self.decred_script_version = ::std::option::Option::None;
self.prev_block_hash_bip115.clear();
self.prev_block_height_bip115 = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAck_TransactionType_TxInputType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAck_TransactionType_TxInputType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAck_TransactionType_TxOutputBinType {
amount: ::std::option::Option<u64>,
script_pubkey: ::protobuf::SingularField<::std::vec::Vec<u8>>,
decred_script_version: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAck_TransactionType_TxOutputBinType {
fn default() -> &'a TxAck_TransactionType_TxOutputBinType {
<TxAck_TransactionType_TxOutputBinType as ::protobuf::Message>::default_instance()
}
}
impl TxAck_TransactionType_TxOutputBinType {
pub fn new() -> TxAck_TransactionType_TxOutputBinType {
::std::default::Default::default()
}
pub fn get_amount(&self) -> u64 {
self.amount.unwrap_or(0)
}
pub fn clear_amount(&mut self) {
self.amount = ::std::option::Option::None;
}
pub fn has_amount(&self) -> bool {
self.amount.is_some()
}
pub fn set_amount(&mut self, v: u64) {
self.amount = ::std::option::Option::Some(v);
}
pub fn get_script_pubkey(&self) -> &[u8] {
match self.script_pubkey.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_script_pubkey(&mut self) {
self.script_pubkey.clear();
}
pub fn has_script_pubkey(&self) -> bool {
self.script_pubkey.is_some()
}
pub fn set_script_pubkey(&mut self, v: ::std::vec::Vec<u8>) {
self.script_pubkey = ::protobuf::SingularField::some(v);
}
pub fn mut_script_pubkey(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.script_pubkey.is_none() {
self.script_pubkey.set_default();
}
self.script_pubkey.as_mut().unwrap()
}
pub fn take_script_pubkey(&mut self) -> ::std::vec::Vec<u8> {
self.script_pubkey.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_decred_script_version(&self) -> u32 {
self.decred_script_version.unwrap_or(0)
}
pub fn clear_decred_script_version(&mut self) {
self.decred_script_version = ::std::option::Option::None;
}
pub fn has_decred_script_version(&self) -> bool {
self.decred_script_version.is_some()
}
pub fn set_decred_script_version(&mut self, v: u32) {
self.decred_script_version = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TxAck_TransactionType_TxOutputBinType {
fn is_initialized(&self) -> bool {
if self.amount.is_none() {
return false;
}
if self.script_pubkey.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 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.amount = ::std::option::Option::Some(tmp);
},
2 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.script_pubkey)?;
},
3 => {
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.decred_script_version = ::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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.amount {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.script_pubkey.as_ref() {
my_size += ::protobuf::rt::bytes_size(2, &v);
}
if let Some(v) = self.decred_script_version {
my_size += ::protobuf::rt::value_size(3, 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(v) = self.amount {
os.write_uint64(1, v)?;
}
if let Some(ref v) = self.script_pubkey.as_ref() {
os.write_bytes(2, &v)?;
}
if let Some(v) = self.decred_script_version {
os.write_uint32(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() -> TxAck_TransactionType_TxOutputBinType {
TxAck_TransactionType_TxOutputBinType::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_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"amount",
|m: &TxAck_TransactionType_TxOutputBinType| { &m.amount },
|m: &mut TxAck_TransactionType_TxOutputBinType| { &mut m.amount },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"script_pubkey",
|m: &TxAck_TransactionType_TxOutputBinType| { &m.script_pubkey },
|m: &mut TxAck_TransactionType_TxOutputBinType| { &mut m.script_pubkey },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"decred_script_version",
|m: &TxAck_TransactionType_TxOutputBinType| { &m.decred_script_version },
|m: &mut TxAck_TransactionType_TxOutputBinType| { &mut m.decred_script_version },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAck_TransactionType_TxOutputBinType>(
"TxAck.TransactionType.TxOutputBinType",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAck_TransactionType_TxOutputBinType {
static instance: ::protobuf::rt::LazyV2<TxAck_TransactionType_TxOutputBinType> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAck_TransactionType_TxOutputBinType::new)
}
}
impl ::protobuf::Clear for TxAck_TransactionType_TxOutputBinType {
fn clear(&mut self) {
self.amount = ::std::option::Option::None;
self.script_pubkey.clear();
self.decred_script_version = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAck_TransactionType_TxOutputBinType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAck_TransactionType_TxOutputBinType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAck_TransactionType_TxOutputType {
address: ::protobuf::SingularField<::std::string::String>,
pub address_n: ::std::vec::Vec<u32>,
amount: ::std::option::Option<u64>,
script_type: ::std::option::Option<TxAck_TransactionType_TxOutputType_OutputScriptType>,
pub multisig: ::protobuf::SingularPtrField<MultisigRedeemScriptType>,
op_return_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
decred_script_version: ::std::option::Option<u32>,
block_hash_bip115: ::protobuf::SingularField<::std::vec::Vec<u8>>,
block_height_bip115: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAck_TransactionType_TxOutputType {
fn default() -> &'a TxAck_TransactionType_TxOutputType {
<TxAck_TransactionType_TxOutputType as ::protobuf::Message>::default_instance()
}
}
impl TxAck_TransactionType_TxOutputType {
pub fn new() -> TxAck_TransactionType_TxOutputType {
::std::default::Default::default()
}
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()
}
pub fn set_address(&mut self, v: ::std::string::String) {
self.address = ::protobuf::SingularField::some(v);
}
pub fn mut_address(&mut self) -> &mut ::std::string::String {
if self.address.is_none() {
self.address.set_default();
}
self.address.as_mut().unwrap()
}
pub fn take_address(&mut self) -> ::std::string::String {
self.address.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_address_n(&self) -> &[u32] {
&self.address_n
}
pub fn clear_address_n(&mut self) {
self.address_n.clear();
}
pub fn set_address_n(&mut self, v: ::std::vec::Vec<u32>) {
self.address_n = v;
}
pub fn mut_address_n(&mut self) -> &mut ::std::vec::Vec<u32> {
&mut self.address_n
}
pub fn take_address_n(&mut self) -> ::std::vec::Vec<u32> {
::std::mem::replace(&mut self.address_n, ::std::vec::Vec::new())
}
pub fn get_amount(&self) -> u64 {
self.amount.unwrap_or(0)
}
pub fn clear_amount(&mut self) {
self.amount = ::std::option::Option::None;
}
pub fn has_amount(&self) -> bool {
self.amount.is_some()
}
pub fn set_amount(&mut self, v: u64) {
self.amount = ::std::option::Option::Some(v);
}
pub fn get_script_type(&self) -> TxAck_TransactionType_TxOutputType_OutputScriptType {
self.script_type.unwrap_or(TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOADDRESS)
}
pub fn clear_script_type(&mut self) {
self.script_type = ::std::option::Option::None;
}
pub fn has_script_type(&self) -> bool {
self.script_type.is_some()
}
pub fn set_script_type(&mut self, v: TxAck_TransactionType_TxOutputType_OutputScriptType) {
self.script_type = ::std::option::Option::Some(v);
}
pub fn get_multisig(&self) -> &MultisigRedeemScriptType {
self.multisig.as_ref().unwrap_or_else(|| <MultisigRedeemScriptType as ::protobuf::Message>::default_instance())
}
pub fn clear_multisig(&mut self) {
self.multisig.clear();
}
pub fn has_multisig(&self) -> bool {
self.multisig.is_some()
}
pub fn set_multisig(&mut self, v: MultisigRedeemScriptType) {
self.multisig = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_multisig(&mut self) -> &mut MultisigRedeemScriptType {
if self.multisig.is_none() {
self.multisig.set_default();
}
self.multisig.as_mut().unwrap()
}
pub fn take_multisig(&mut self) -> MultisigRedeemScriptType {
self.multisig.take().unwrap_or_else(|| MultisigRedeemScriptType::new())
}
pub fn get_op_return_data(&self) -> &[u8] {
match self.op_return_data.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_op_return_data(&mut self) {
self.op_return_data.clear();
}
pub fn has_op_return_data(&self) -> bool {
self.op_return_data.is_some()
}
pub fn set_op_return_data(&mut self, v: ::std::vec::Vec<u8>) {
self.op_return_data = ::protobuf::SingularField::some(v);
}
pub fn mut_op_return_data(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.op_return_data.is_none() {
self.op_return_data.set_default();
}
self.op_return_data.as_mut().unwrap()
}
pub fn take_op_return_data(&mut self) -> ::std::vec::Vec<u8> {
self.op_return_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_decred_script_version(&self) -> u32 {
self.decred_script_version.unwrap_or(0)
}
pub fn clear_decred_script_version(&mut self) {
self.decred_script_version = ::std::option::Option::None;
}
pub fn has_decred_script_version(&self) -> bool {
self.decred_script_version.is_some()
}
pub fn set_decred_script_version(&mut self, v: u32) {
self.decred_script_version = ::std::option::Option::Some(v);
}
pub fn get_block_hash_bip115(&self) -> &[u8] {
match self.block_hash_bip115.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_block_hash_bip115(&mut self) {
self.block_hash_bip115.clear();
}
pub fn has_block_hash_bip115(&self) -> bool {
self.block_hash_bip115.is_some()
}
pub fn set_block_hash_bip115(&mut self, v: ::std::vec::Vec<u8>) {
self.block_hash_bip115 = ::protobuf::SingularField::some(v);
}
pub fn mut_block_hash_bip115(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.block_hash_bip115.is_none() {
self.block_hash_bip115.set_default();
}
self.block_hash_bip115.as_mut().unwrap()
}
pub fn take_block_hash_bip115(&mut self) -> ::std::vec::Vec<u8> {
self.block_hash_bip115.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_block_height_bip115(&self) -> u32 {
self.block_height_bip115.unwrap_or(0)
}
pub fn clear_block_height_bip115(&mut self) {
self.block_height_bip115 = ::std::option::Option::None;
}
pub fn has_block_height_bip115(&self) -> bool {
self.block_height_bip115.is_some()
}
pub fn set_block_height_bip115(&mut self, v: u32) {
self.block_height_bip115 = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TxAck_TransactionType_TxOutputType {
fn is_initialized(&self) -> bool {
if self.amount.is_none() {
return false;
}
if self.script_type.is_none() {
return false;
}
for v in &self.multisig {
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_string_into(wire_type, is, &mut self.address)?;
},
2 => {
::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.address_n)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.amount = ::std::option::Option::Some(tmp);
},
4 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.script_type, 4, &mut self.unknown_fields)?
},
5 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.multisig)?;
},
6 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.op_return_data)?;
},
7 => {
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.decred_script_version = ::std::option::Option::Some(tmp);
},
8 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.block_hash_bip115)?;
},
9 => {
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.block_height_bip115 = ::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(())
}
#[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);
}
for value in &self.address_n {
my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint);
};
if let Some(v) = self.amount {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.script_type {
my_size += ::protobuf::rt::enum_size(4, v);
}
if let Some(ref v) = self.multisig.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.op_return_data.as_ref() {
my_size += ::protobuf::rt::bytes_size(6, &v);
}
if let Some(v) = self.decred_script_version {
my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.block_hash_bip115.as_ref() {
my_size += ::protobuf::rt::bytes_size(8, &v);
}
if let Some(v) = self.block_height_bip115 {
my_size += ::protobuf::rt::value_size(9, 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.address.as_ref() {
os.write_string(1, &v)?;
}
for v in &self.address_n {
os.write_uint32(2, *v)?;
};
if let Some(v) = self.amount {
os.write_uint64(3, v)?;
}
if let Some(v) = self.script_type {
os.write_enum(4, ::protobuf::ProtobufEnum::value(&v))?;
}
if let Some(ref v) = self.multisig.as_ref() {
os.write_tag(5, ::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.op_return_data.as_ref() {
os.write_bytes(6, &v)?;
}
if let Some(v) = self.decred_script_version {
os.write_uint32(7, v)?;
}
if let Some(ref v) = self.block_hash_bip115.as_ref() {
os.write_bytes(8, &v)?;
}
if let Some(v) = self.block_height_bip115 {
os.write_uint32(9, 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() -> TxAck_TransactionType_TxOutputType {
TxAck_TransactionType_TxOutputType::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: &TxAck_TransactionType_TxOutputType| { &m.address },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.address },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"address_n",
|m: &TxAck_TransactionType_TxOutputType| { &m.address_n },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"amount",
|m: &TxAck_TransactionType_TxOutputType| { &m.amount },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.amount },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<TxAck_TransactionType_TxOutputType_OutputScriptType>>(
"script_type",
|m: &TxAck_TransactionType_TxOutputType| { &m.script_type },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.script_type },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MultisigRedeemScriptType>>(
"multisig",
|m: &TxAck_TransactionType_TxOutputType| { &m.multisig },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.multisig },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"op_return_data",
|m: &TxAck_TransactionType_TxOutputType| { &m.op_return_data },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.op_return_data },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"decred_script_version",
|m: &TxAck_TransactionType_TxOutputType| { &m.decred_script_version },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.decred_script_version },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"block_hash_bip115",
|m: &TxAck_TransactionType_TxOutputType| { &m.block_hash_bip115 },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.block_hash_bip115 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"block_height_bip115",
|m: &TxAck_TransactionType_TxOutputType| { &m.block_height_bip115 },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.block_height_bip115 },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAck_TransactionType_TxOutputType>(
"TxAck.TransactionType.TxOutputType",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAck_TransactionType_TxOutputType {
static instance: ::protobuf::rt::LazyV2<TxAck_TransactionType_TxOutputType> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAck_TransactionType_TxOutputType::new)
}
}
impl ::protobuf::Clear for TxAck_TransactionType_TxOutputType {
fn clear(&mut self) {
self.address.clear();
self.address_n.clear();
self.amount = ::std::option::Option::None;
self.script_type = ::std::option::Option::None;
self.multisig.clear();
self.op_return_data.clear();
self.decred_script_version = ::std::option::Option::None;
self.block_hash_bip115.clear();
self.block_height_bip115 = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAck_TransactionType_TxOutputType {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAck_TransactionType_TxOutputType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum TxAck_TransactionType_TxOutputType_OutputScriptType {
PAYTOADDRESS = 0,
PAYTOSCRIPTHASH = 1,
PAYTOMULTISIG = 2,
PAYTOOPRETURN = 3,
PAYTOWITNESS = 4,
PAYTOP2SHWITNESS = 5,
}
impl ::protobuf::ProtobufEnum for TxAck_TransactionType_TxOutputType_OutputScriptType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<TxAck_TransactionType_TxOutputType_OutputScriptType> {
match value {
0 => ::std::option::Option::Some(TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOADDRESS),
1 => ::std::option::Option::Some(TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOSCRIPTHASH),
2 => ::std::option::Option::Some(TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOMULTISIG),
3 => ::std::option::Option::Some(TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOOPRETURN),
4 => ::std::option::Option::Some(TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOWITNESS),
5 => ::std::option::Option::Some(TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOP2SHWITNESS),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [TxAck_TransactionType_TxOutputType_OutputScriptType] = &[
TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOADDRESS,
TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOSCRIPTHASH,
TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOMULTISIG,
TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOOPRETURN,
TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOWITNESS,
TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOP2SHWITNESS,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<TxAck_TransactionType_TxOutputType_OutputScriptType>("TxAck.TransactionType.TxOutputType.OutputScriptType", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for TxAck_TransactionType_TxOutputType_OutputScriptType {
}
impl ::std::default::Default for TxAck_TransactionType_TxOutputType_OutputScriptType {
fn default() -> Self {
TxAck_TransactionType_TxOutputType_OutputScriptType::PAYTOADDRESS
}
}
impl ::protobuf::reflect::ProtobufValue for TxAck_TransactionType_TxOutputType_OutputScriptType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum InputScriptType {
SPENDADDRESS = 0,
SPENDMULTISIG = 1,
EXTERNAL = 2,
SPENDWITNESS = 3,
SPENDP2SHWITNESS = 4,
}
impl ::protobuf::ProtobufEnum for InputScriptType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<InputScriptType> {
match value {
0 => ::std::option::Option::Some(InputScriptType::SPENDADDRESS),
1 => ::std::option::Option::Some(InputScriptType::SPENDMULTISIG),
2 => ::std::option::Option::Some(InputScriptType::EXTERNAL),
3 => ::std::option::Option::Some(InputScriptType::SPENDWITNESS),
4 => ::std::option::Option::Some(InputScriptType::SPENDP2SHWITNESS),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [InputScriptType] = &[
InputScriptType::SPENDADDRESS,
InputScriptType::SPENDMULTISIG,
InputScriptType::EXTERNAL,
InputScriptType::SPENDWITNESS,
InputScriptType::SPENDP2SHWITNESS,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<InputScriptType>("InputScriptType", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for InputScriptType {
}
impl ::std::default::Default for InputScriptType {
fn default() -> Self {
InputScriptType::SPENDADDRESS
}
}
impl ::protobuf::reflect::ProtobufValue for InputScriptType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x16messages-bitcoin.proto\x12\x1ahw.trezor.messages.bitcoin\x1a\x15me\
ssages-common.proto\"\x91\x02\n\x18MultisigRedeemScriptType\x12]\n\x07pu\
bkeys\x18\x01\x20\x03(\x0b2C.hw.trezor.messages.bitcoin.MultisigRedeemSc\
riptType.HDNodePathTypeR\x07pubkeys\x12\x1e\n\nsignatures\x18\x02\x20\
\x03(\x0cR\nsignatures\x12\x0c\n\x01m\x18\x03\x20\x01(\rR\x01m\x1ah\n\
\x0eHDNodePathType\x129\n\x04node\x18\x01\x20\x02(\x0b2%.hw.trezor.messa\
ges.common.HDNodeTypeR\x04node\x12\x1b\n\taddress_n\x18\x02\x20\x03(\rR\
\x08addressN\"\xfa\x01\n\x0cGetPublicKey\x12\x1b\n\taddress_n\x18\x01\
\x20\x03(\rR\x08addressN\x12(\n\x10ecdsa_curve_name\x18\x02\x20\x01(\tR\
\x0eecdsaCurveName\x12!\n\x0cshow_display\x18\x03\x20\x01(\x08R\x0bshowD\
isplay\x12$\n\tcoin_name\x18\x04\x20\x01(\t:\x07BitcoinR\x08coinName\x12\
Z\n\x0bscript_type\x18\x05\x20\x01(\x0e2+.hw.trezor.messages.bitcoin.Inp\
utScriptType:\x0cSPENDADDRESSR\nscriptType\"Z\n\tPublicKey\x129\n\x04nod\
e\x18\x01\x20\x02(\x0b2%.hw.trezor.messages.common.HDNodeTypeR\x04node\
\x12\x12\n\x04xpub\x18\x02\x20\x01(\tR\x04xpub\"\xa0\x02\n\nGetAddress\
\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12$\n\tcoin_name\
\x18\x02\x20\x01(\t:\x07BitcoinR\x08coinName\x12!\n\x0cshow_display\x18\
\x03\x20\x01(\x08R\x0bshowDisplay\x12P\n\x08multisig\x18\x04\x20\x01(\
\x0b24.hw.trezor.messages.bitcoin.MultisigRedeemScriptTypeR\x08multisig\
\x12Z\n\x0bscript_type\x18\x05\x20\x01(\x0e2+.hw.trezor.messages.bitcoin\
.InputScriptType:\x0cSPENDADDRESSR\nscriptType\"#\n\x07Address\x12\x18\n\
\x07address\x18\x01\x20\x02(\tR\x07address\"\xc6\x01\n\x0bSignMessage\
\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12\x18\n\x07messa\
ge\x18\x02\x20\x02(\x0cR\x07message\x12$\n\tcoin_name\x18\x03\x20\x01(\t\
:\x07BitcoinR\x08coinName\x12Z\n\x0bscript_type\x18\x04\x20\x01(\x0e2+.h\
w.trezor.messages.bitcoin.InputScriptType:\x0cSPENDADDRESSR\nscriptType\
\"J\n\x10MessageSignature\x12\x18\n\x07address\x18\x01\x20\x01(\tR\x07ad\
dress\x12\x1c\n\tsignature\x18\x02\x20\x01(\x0cR\tsignature\"\x87\x01\n\
\rVerifyMessage\x12\x18\n\x07address\x18\x01\x20\x01(\tR\x07address\x12\
\x1c\n\tsignature\x18\x02\x20\x01(\x0cR\tsignature\x12\x18\n\x07message\
\x18\x03\x20\x01(\x0cR\x07message\x12$\n\tcoin_name\x18\x04\x20\x01(\t:\
\x07BitcoinR\x08coinName\"\xef\x01\n\x06SignTx\x12#\n\routputs_count\x18\
\x01\x20\x02(\rR\x0coutputsCount\x12!\n\x0cinputs_count\x18\x02\x20\x02(\
\rR\x0binputsCount\x12$\n\tcoin_name\x18\x03\x20\x01(\t:\x07BitcoinR\x08\
coinName\x12\x1b\n\x07version\x18\x04\x20\x01(\r:\x011R\x07version\x12\
\x1e\n\tlock_time\x18\x05\x20\x01(\r:\x010R\x08lockTime\x12\x16\n\x06exp\
iry\x18\x06\x20\x01(\rR\x06expiry\x12\"\n\x0coverwintered\x18\x07\x20\
\x01(\x08R\x0coverwintered\"\x9e\x05\n\tTxRequest\x12T\n\x0crequest_type\
\x18\x01\x20\x01(\x0e21.hw.trezor.messages.bitcoin.TxRequest.RequestType\
R\x0brequestType\x12T\n\x07details\x18\x02\x20\x01(\x0b2:.hw.trezor.mess\
ages.bitcoin.TxRequest.TxRequestDetailsTypeR\x07details\x12]\n\nserializ\
ed\x18\x03\x20\x01(\x0b2=.hw.trezor.messages.bitcoin.TxRequest.TxRequest\
SerializedTypeR\nserialized\x1a\xa6\x01\n\x14TxRequestDetailsType\x12#\n\
\rrequest_index\x18\x01\x20\x01(\rR\x0crequestIndex\x12\x17\n\x07tx_hash\
\x18\x02\x20\x01(\x0cR\x06txHash\x12$\n\x0eextra_data_len\x18\x03\x20\
\x01(\rR\x0cextraDataLen\x12*\n\x11extra_data_offset\x18\x04\x20\x01(\rR\
\x0fextraDataOffset\x1a\x85\x01\n\x17TxRequestSerializedType\x12'\n\x0fs\
ignature_index\x18\x01\x20\x01(\rR\x0esignatureIndex\x12\x1c\n\tsignatur\
e\x18\x02\x20\x01(\x0cR\tsignature\x12#\n\rserialized_tx\x18\x03\x20\x01\
(\x0cR\x0cserializedTx\"U\n\x0bRequestType\x12\x0b\n\x07TXINPUT\x10\0\
\x12\x0c\n\x08TXOUTPUT\x10\x01\x12\n\n\x06TXMETA\x10\x02\x12\x0e\n\nTXFI\
NISHED\x10\x03\x12\x0f\n\x0bTXEXTRADATA\x10\x04\"\x8d\x0f\n\x05TxAck\x12\
A\n\x02tx\x18\x01\x20\x01(\x0b21.hw.trezor.messages.bitcoin.TxAck.Transa\
ctionTypeR\x02tx\x1a\xc0\x0e\n\x0fTransactionType\x12\x18\n\x07version\
\x18\x01\x20\x01(\rR\x07version\x12U\n\x06inputs\x18\x02\x20\x03(\x0b2=.\
hw.trezor.messages.bitcoin.TxAck.TransactionType.TxInputTypeR\x06inputs\
\x12b\n\x0bbin_outputs\x18\x03\x20\x03(\x0b2A.hw.trezor.messages.bitcoin\
.TxAck.TransactionType.TxOutputBinTypeR\nbinOutputs\x12\x1b\n\tlock_time\
\x18\x04\x20\x01(\rR\x08lockTime\x12X\n\x07outputs\x18\x05\x20\x03(\x0b2\
>.hw.trezor.messages.bitcoin.TxAck.TransactionType.TxOutputTypeR\x07outp\
uts\x12\x1d\n\ninputs_cnt\x18\x06\x20\x01(\rR\tinputsCnt\x12\x1f\n\x0bou\
tputs_cnt\x18\x07\x20\x01(\rR\noutputsCnt\x12\x1d\n\nextra_data\x18\x08\
\x20\x01(\x0cR\textraData\x12$\n\x0eextra_data_len\x18\t\x20\x01(\rR\x0c\
extraDataLen\x12\x16\n\x06expiry\x18\n\x20\x01(\rR\x06expiry\x12\"\n\x0c\
overwintered\x18\x0b\x20\x01(\x08R\x0coverwintered\x1a\xb6\x04\n\x0bTxIn\
putType\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12\x1b\n\t\
prev_hash\x18\x02\x20\x02(\x0cR\x08prevHash\x12\x1d\n\nprev_index\x18\
\x03\x20\x02(\rR\tprevIndex\x12\x1d\n\nscript_sig\x18\x04\x20\x01(\x0cR\
\tscriptSig\x12&\n\x08sequence\x18\x05\x20\x01(\r:\n4294967295R\x08seque\
nce\x12Z\n\x0bscript_type\x18\x06\x20\x01(\x0e2+.hw.trezor.messages.bitc\
oin.InputScriptType:\x0cSPENDADDRESSR\nscriptType\x12P\n\x08multisig\x18\
\x07\x20\x01(\x0b24.hw.trezor.messages.bitcoin.MultisigRedeemScriptTypeR\
\x08multisig\x12\x16\n\x06amount\x18\x08\x20\x01(\x04R\x06amount\x12\x1f\
\n\x0bdecred_tree\x18\t\x20\x01(\rR\ndecredTree\x122\n\x15decred_script_\
version\x18\n\x20\x01(\rR\x13decredScriptVersion\x123\n\x16prev_block_ha\
sh_bip115\x18\x0b\x20\x01(\x0cR\x13prevBlockHashBip115\x127\n\x18prev_bl\
ock_height_bip115\x18\x0c\x20\x01(\rR\x15prevBlockHeightBip115\x1a\x82\
\x01\n\x0fTxOutputBinType\x12\x16\n\x06amount\x18\x01\x20\x02(\x04R\x06a\
mount\x12#\n\rscript_pubkey\x18\x02\x20\x02(\x0cR\x0cscriptPubkey\x122\n\
\x15decred_script_version\x18\x03\x20\x01(\rR\x13decredScriptVersion\x1a\
\xe1\x04\n\x0cTxOutputType\x12\x18\n\x07address\x18\x01\x20\x01(\tR\x07a\
ddress\x12\x1b\n\taddress_n\x18\x02\x20\x03(\rR\x08addressN\x12\x16\n\
\x06amount\x18\x03\x20\x02(\x04R\x06amount\x12p\n\x0bscript_type\x18\x04\
\x20\x02(\x0e2O.hw.trezor.messages.bitcoin.TxAck.TransactionType.TxOutpu\
tType.OutputScriptTypeR\nscriptType\x12P\n\x08multisig\x18\x05\x20\x01(\
\x0b24.hw.trezor.messages.bitcoin.MultisigRedeemScriptTypeR\x08multisig\
\x12$\n\x0eop_return_data\x18\x06\x20\x01(\x0cR\x0copReturnData\x122\n\
\x15decred_script_version\x18\x07\x20\x01(\rR\x13decredScriptVersion\x12\
*\n\x11block_hash_bip115\x18\x08\x20\x01(\x0cR\x0fblockHashBip115\x12.\n\
\x13block_height_bip115\x18\t\x20\x01(\rR\x11blockHeightBip115\"\x87\x01\
\n\x10OutputScriptType\x12\x10\n\x0cPAYTOADDRESS\x10\0\x12\x13\n\x0fPAYT\
OSCRIPTHASH\x10\x01\x12\x11\n\rPAYTOMULTISIG\x10\x02\x12\x11\n\rPAYTOOPR\
ETURN\x10\x03\x12\x10\n\x0cPAYTOWITNESS\x10\x04\x12\x14\n\x10PAYTOP2SHWI\
TNESS\x10\x05*l\n\x0fInputScriptType\x12\x10\n\x0cSPENDADDRESS\x10\0\x12\
\x11\n\rSPENDMULTISIG\x10\x01\x12\x0c\n\x08EXTERNAL\x10\x02\x12\x10\n\
\x0cSPENDWITNESS\x10\x03\x12\x14\n\x10SPENDP2SHWITNESS\x10\x04B;\n#com.s\
atoshilabs.trezor.lib.protobufB\x14TrezorMessageBitcoinJ\xd4f\n\x07\x12\
\x05\0\0\xf2\x01\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\
\x03\x01\0#\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\05\n\t\n\x02\x08\x08\x12\x03\x05\05\n\t\n\x02\x03\0\
\x12\x03\x07\0\x1f\nH\n\x02\x05\0\x12\x04\x0c\0\x12\x01\x1a<*\n\x20Type\
\x20of\x20script\x20which\x20will\x20be\x20used\x20for\x20transaction\
\x20output\n\n\n\n\x03\x05\0\x01\x12\x03\x0c\x05\x14\n%\n\x04\x05\0\x02\
\0\x12\x03\r\x04\x15\"\x18\x20standard\x20P2PKH\x20address\n\n\x0c\n\x05\
\x05\0\x02\0\x01\x12\x03\r\x04\x10\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03\r\
\x13\x14\n$\n\x04\x05\0\x02\x01\x12\x03\x0e\x04\x16\"\x17\x20P2SH\x20mul\
tisig\x20address\n\n\x0c\n\x05\x05\0\x02\x01\x01\x12\x03\x0e\x04\x11\n\
\x0c\n\x05\x05\0\x02\x01\x02\x12\x03\x0e\x14\x15\n6\n\x04\x05\0\x02\x02\
\x12\x03\x0f\x04\x11\")\x20reserved\x20for\x20external\x20inputs\x20(coi\
njoin)\n\n\x0c\n\x05\x05\0\x02\x02\x01\x12\x03\x0f\x04\x0c\n\x0c\n\x05\
\x05\0\x02\x02\x02\x12\x03\x0f\x0f\x10\n\x1c\n\x04\x05\0\x02\x03\x12\x03\
\x10\x04\x15\"\x0f\x20native\x20SegWit\n\n\x0c\n\x05\x05\0\x02\x03\x01\
\x12\x03\x10\x04\x10\n\x0c\n\x05\x05\0\x02\x03\x02\x12\x03\x10\x13\x14\n\
5\n\x04\x05\0\x02\x04\x12\x03\x11\x04\x19\"(\x20SegWit\x20over\x20P2SH\
\x20(backward\x20compatible)\n\n\x0c\n\x05\x05\0\x02\x04\x01\x12\x03\x11\
\x04\x14\n\x0c\n\x05\x05\0\x02\x04\x02\x12\x03\x11\x17\x18\n;\n\x02\x04\
\0\x12\x04\x18\0#\x01\x1a/*\n\x20Type\x20of\x20redeem\x20script\x20used\
\x20in\x20input\n\x20@embed\n\n\n\n\x03\x04\0\x01\x12\x03\x18\x08\x20\nG\
\n\x04\x04\0\x02\0\x12\x03\x19\x04(\":\x20pubkeys\x20from\x20multisig\
\x20address\x20(sorted\x20lexicographically)\n\n\x0c\n\x05\x04\0\x02\0\
\x04\x12\x03\x19\x04\x0c\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03\x19\r\x1b\n\
\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x19\x1c#\n\x0c\n\x05\x04\0\x02\0\x03\
\x12\x03\x19&'\n=\n\x04\x04\0\x02\x01\x12\x03\x1a\x04\"\"0\x20existing\
\x20signatures\x20for\x20partially\x20signed\x20input\n\n\x0c\n\x05\x04\
\0\x02\x01\x04\x12\x03\x1a\x04\x0c\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\
\x1a\r\x12\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x1a\x13\x1d\n\x0c\n\x05\
\x04\0\x02\x01\x03\x12\x03\x1a\x20!\nN\n\x04\x04\0\x02\x02\x12\x03\x1b\
\x04\x1a\"A\x20\"m\"\x20from\x20n,\x20how\x20many\x20valid\x20signatures\
\x20is\x20necessary\x20for\x20spending\n\n\x0c\n\x05\x04\0\x02\x02\x04\
\x12\x03\x1b\x04\x0c\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03\x1b\r\x13\n\
\x0c\n\x05\x04\0\x02\x02\x01\x12\x03\x1b\x14\x15\n\x0c\n\x05\x04\0\x02\
\x02\x03\x12\x03\x1b\x18\x19\n6\n\x04\x04\0\x03\0\x12\x04\x1f\x04\"\x05\
\x1a(*\n\x20Structure\x20representing\x20HDNode\x20+\x20Path\n\n\x0c\n\
\x05\x04\0\x03\0\x01\x12\x03\x1f\x0c\x1a\n1\n\x06\x04\0\x03\0\x02\0\x12\
\x03\x20\x08?\"\"\x20BIP-32\x20node\x20in\x20deserialized\x20form\n\n\
\x0e\n\x07\x04\0\x03\0\x02\0\x04\x12\x03\x20\x08\x10\n\x0e\n\x07\x04\0\
\x03\0\x02\0\x06\x12\x03\x20\x115\n\x0e\n\x07\x04\0\x03\0\x02\0\x01\x12\
\x03\x206:\n\x0e\n\x07\x04\0\x03\0\x02\0\x03\x12\x03\x20=>\n8\n\x06\x04\
\0\x03\0\x02\x01\x12\x03!\x08&\")\x20BIP-32\x20path\x20to\x20derive\x20t\
he\x20key\x20from\x20node\n\n\x0e\n\x07\x04\0\x03\0\x02\x01\x04\x12\x03!\
\x08\x10\n\x0e\n\x07\x04\0\x03\0\x02\x01\x05\x12\x03!\x11\x17\n\x0e\n\
\x07\x04\0\x03\0\x02\x01\x01\x12\x03!\x18!\n\x0e\n\x07\x04\0\x03\0\x02\
\x01\x03\x12\x03!$%\nz\n\x02\x04\x01\x12\x04+\01\x01\x1an*\n\x20Request:\
\x20Ask\x20device\x20for\x20public\x20key\x20corresponding\x20to\x20addr\
ess_n\x20path\n\x20@start\n\x20@next\x20PublicKey\n\x20@next\x20Failure\
\n\n\n\n\x03\x04\x01\x01\x12\x03+\x08\x14\n=\n\x04\x04\x01\x02\0\x12\x03\
,\x04\"\"0\x20BIP-32\x20path\x20to\x20derive\x20the\x20key\x20from\x20ma\
ster\x20node\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03,\x04\x0c\n\x0c\n\
\x05\x04\x01\x02\0\x05\x12\x03,\r\x13\n\x0c\n\x05\x04\x01\x02\0\x01\x12\
\x03,\x14\x1d\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03,\x20!\n&\n\x04\x04\
\x01\x02\x01\x12\x03-\x04)\"\x19\x20ECDSA\x20curve\x20name\x20to\x20use\
\n\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03-\x04\x0c\n\x0c\n\x05\x04\x01\
\x02\x01\x05\x12\x03-\r\x13\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03-\x14\
$\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03-'(\nC\n\x04\x04\x01\x02\x02\
\x12\x03.\x04#\"6\x20optionally\x20show\x20on\x20display\x20before\x20se\
nding\x20the\x20result\n\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03.\x04\
\x0c\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03.\r\x11\n\x0c\n\x05\x04\x01\
\x02\x02\x01\x12\x03.\x12\x1e\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03.!\
\"\n(\n\x04\x04\x01\x02\x03\x12\x03/\x046\"\x1b\x20coin\x20to\x20use\x20\
for\x20verifying\n\n\x0c\n\x05\x04\x01\x02\x03\x04\x12\x03/\x04\x0c\n\
\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03/\r\x13\n\x0c\n\x05\x04\x01\x02\
\x03\x01\x12\x03/\x14\x1d\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03/\x20!\
\n\x0c\n\x05\x04\x01\x02\x03\x08\x12\x03/\"5\n\x0c\n\x05\x04\x01\x02\x03\
\x07\x12\x03/+4\n]\n\x04\x04\x01\x02\x04\x12\x030\x04D\"P\x20used\x20to\
\x20distinguish\x20between\x20various\x20address\x20formats\x20(non-segw\
it,\x20segwit,\x20etc.)\n\n\x0c\n\x05\x04\x01\x02\x04\x04\x12\x030\x04\
\x0c\n\x0c\n\x05\x04\x01\x02\x04\x06\x12\x030\r\x1c\n\x0c\n\x05\x04\x01\
\x02\x04\x01\x12\x030\x1d(\n\x0c\n\x05\x04\x01\x02\x04\x03\x12\x030+,\n\
\x0c\n\x05\x04\x01\x02\x04\x08\x12\x030-C\n\x0c\n\x05\x04\x01\x02\x04\
\x07\x12\x0306B\nT\n\x02\x04\x02\x12\x047\0:\x01\x1aH*\n\x20Response:\
\x20Contains\x20public\x20key\x20derived\x20from\x20device\x20private\
\x20seed\n\x20@end\n\n\n\n\x03\x04\x02\x01\x12\x037\x08\x11\n\x20\n\x04\
\x04\x02\x02\0\x12\x038\x04;\"\x13\x20BIP32\x20public\x20node\n\n\x0c\n\
\x05\x04\x02\x02\0\x04\x12\x038\x04\x0c\n\x0c\n\x05\x04\x02\x02\0\x06\
\x12\x038\r1\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03826\n\x0c\n\x05\x04\
\x02\x02\0\x03\x12\x0389:\n-\n\x04\x04\x02\x02\x01\x12\x039\x04\x1d\"\
\x20\x20serialized\x20form\x20of\x20public\x20node\n\n\x0c\n\x05\x04\x02\
\x02\x01\x04\x12\x039\x04\x0c\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x039\r\
\x13\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x039\x14\x18\n\x0c\n\x05\x04\
\x02\x02\x01\x03\x12\x039\x1b\x1c\nu\n\x02\x04\x03\x12\x04B\0H\x01\x1ai*\
\n\x20Request:\x20Ask\x20device\x20for\x20address\x20corresponding\x20to\
\x20address_n\x20path\n\x20@start\n\x20@next\x20Address\n\x20@next\x20Fa\
ilure\n\n\n\n\x03\x04\x03\x01\x12\x03B\x08\x12\n=\n\x04\x04\x03\x02\0\
\x12\x03C\x04\"\"0\x20BIP-32\x20path\x20to\x20derive\x20the\x20key\x20fr\
om\x20master\x20node\n\n\x0c\n\x05\x04\x03\x02\0\x04\x12\x03C\x04\x0c\n\
\x0c\n\x05\x04\x03\x02\0\x05\x12\x03C\r\x13\n\x0c\n\x05\x04\x03\x02\0\
\x01\x12\x03C\x14\x1d\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03C\x20!\n\x1a\
\n\x04\x04\x03\x02\x01\x12\x03D\x046\"\r\x20coin\x20to\x20use\n\n\x0c\n\
\x05\x04\x03\x02\x01\x04\x12\x03D\x04\x0c\n\x0c\n\x05\x04\x03\x02\x01\
\x05\x12\x03D\r\x13\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03D\x14\x1d\n\
\x0c\n\x05\x04\x03\x02\x01\x03\x12\x03D\x20!\n\x0c\n\x05\x04\x03\x02\x01\
\x08\x12\x03D\"5\n\x0c\n\x05\x04\x03\x02\x01\x07\x12\x03D+4\nC\n\x04\x04\
\x03\x02\x02\x12\x03E\x04#\"6\x20optionally\x20show\x20on\x20display\x20\
before\x20sending\x20the\x20result\n\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\
\x03E\x04\x0c\n\x0c\n\x05\x04\x03\x02\x02\x05\x12\x03E\r\x11\n\x0c\n\x05\
\x04\x03\x02\x02\x01\x12\x03E\x12\x1e\n\x0c\n\x05\x04\x03\x02\x02\x03\
\x12\x03E!\"\n:\n\x04\x04\x03\x02\x03\x12\x03F\x043\"-\x20filled\x20if\
\x20we\x20are\x20showing\x20a\x20multisig\x20address\n\n\x0c\n\x05\x04\
\x03\x02\x03\x04\x12\x03F\x04\x0c\n\x0c\n\x05\x04\x03\x02\x03\x06\x12\
\x03F\r%\n\x0c\n\x05\x04\x03\x02\x03\x01\x12\x03F&.\n\x0c\n\x05\x04\x03\
\x02\x03\x03\x12\x03F12\n]\n\x04\x04\x03\x02\x04\x12\x03G\x04D\"P\x20use\
d\x20to\x20distinguish\x20between\x20various\x20address\x20formats\x20(n\
on-segwit,\x20segwit,\x20etc.)\n\n\x0c\n\x05\x04\x03\x02\x04\x04\x12\x03\
G\x04\x0c\n\x0c\n\x05\x04\x03\x02\x04\x06\x12\x03G\r\x1c\n\x0c\n\x05\x04\
\x03\x02\x04\x01\x12\x03G\x1d(\n\x0c\n\x05\x04\x03\x02\x04\x03\x12\x03G+\
,\n\x0c\n\x05\x04\x03\x02\x04\x08\x12\x03G-C\n\x0c\n\x05\x04\x03\x02\x04\
\x07\x12\x03G6B\nQ\n\x02\x04\x04\x12\x04N\0P\x01\x1aE*\n\x20Response:\
\x20Contains\x20address\x20derived\x20from\x20device\x20private\x20seed\
\n\x20@end\n\n\n\n\x03\x04\x04\x01\x12\x03N\x08\x0f\n.\n\x04\x04\x04\x02\
\0\x12\x03O\x04\x20\"!\x20Coin\x20address\x20in\x20Base58\x20encoding\n\
\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x03O\x04\x0c\n\x0c\n\x05\x04\x04\x02\
\0\x05\x12\x03O\r\x13\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03O\x14\x1b\n\
\x0c\n\x05\x04\x04\x02\0\x03\x12\x03O\x1e\x1f\nb\n\x02\x04\x05\x12\x04X\
\0]\x01\x1aV*\n\x20Request:\x20Ask\x20device\x20to\x20sign\x20message\n\
\x20@start\n\x20@next\x20MessageSignature\n\x20@next\x20Failure\n\n\n\n\
\x03\x04\x05\x01\x12\x03X\x08\x13\n=\n\x04\x04\x05\x02\0\x12\x03Y\x04\"\
\"0\x20BIP-32\x20path\x20to\x20derive\x20the\x20key\x20from\x20master\
\x20node\n\n\x0c\n\x05\x04\x05\x02\0\x04\x12\x03Y\x04\x0c\n\x0c\n\x05\
\x04\x05\x02\0\x05\x12\x03Y\r\x13\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03Y\
\x14\x1d\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03Y\x20!\n#\n\x04\x04\x05\
\x02\x01\x12\x03Z\x04\x1f\"\x16\x20message\x20to\x20be\x20signed\n\n\x0c\
\n\x05\x04\x05\x02\x01\x04\x12\x03Z\x04\x0c\n\x0c\n\x05\x04\x05\x02\x01\
\x05\x12\x03Z\r\x12\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03Z\x13\x1a\n\
\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03Z\x1d\x1e\n&\n\x04\x04\x05\x02\x02\
\x12\x03[\x046\"\x19\x20coin\x20to\x20use\x20for\x20signing\n\n\x0c\n\
\x05\x04\x05\x02\x02\x04\x12\x03[\x04\x0c\n\x0c\n\x05\x04\x05\x02\x02\
\x05\x12\x03[\r\x13\n\x0c\n\x05\x04\x05\x02\x02\x01\x12\x03[\x14\x1d\n\
\x0c\n\x05\x04\x05\x02\x02\x03\x12\x03[\x20!\n\x0c\n\x05\x04\x05\x02\x02\
\x08\x12\x03[\"5\n\x0c\n\x05\x04\x05\x02\x02\x07\x12\x03[+4\n]\n\x04\x04\
\x05\x02\x03\x12\x03\\\x04D\"P\x20used\x20to\x20distinguish\x20between\
\x20various\x20address\x20formats\x20(non-segwit,\x20segwit,\x20etc.)\n\
\n\x0c\n\x05\x04\x05\x02\x03\x04\x12\x03\\\x04\x0c\n\x0c\n\x05\x04\x05\
\x02\x03\x06\x12\x03\\\r\x1c\n\x0c\n\x05\x04\x05\x02\x03\x01\x12\x03\\\
\x1d(\n\x0c\n\x05\x04\x05\x02\x03\x03\x12\x03\\+,\n\x0c\n\x05\x04\x05\
\x02\x03\x08\x12\x03\\-C\n\x0c\n\x05\x04\x05\x02\x03\x07\x12\x03\\6B\n.\
\n\x02\x04\x06\x12\x04c\0f\x01\x1a\"*\n\x20Response:\x20Signed\x20messag\
e\n\x20@end\n\n\n\n\x03\x04\x06\x01\x12\x03c\x08\x18\n/\n\x04\x04\x06\
\x02\0\x12\x03d\x04\x20\"\"\x20address\x20used\x20to\x20sign\x20the\x20m\
essage\n\n\x0c\n\x05\x04\x06\x02\0\x04\x12\x03d\x04\x0c\n\x0c\n\x05\x04\
\x06\x02\0\x05\x12\x03d\r\x13\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03d\x14\
\x1b\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03d\x1e\x1f\n'\n\x04\x04\x06\x02\
\x01\x12\x03e\x04!\"\x1a\x20signature\x20of\x20the\x20message\n\n\x0c\n\
\x05\x04\x06\x02\x01\x04\x12\x03e\x04\x0c\n\x0c\n\x05\x04\x06\x02\x01\
\x05\x12\x03e\r\x12\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03e\x13\x1c\n\
\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03e\x1f\x20\n[\n\x02\x04\x07\x12\x04\
n\0s\x01\x1aO*\n\x20Request:\x20Ask\x20device\x20to\x20verify\x20message\
\n\x20@start\n\x20@next\x20Success\n\x20@next\x20Failure\n\n\n\n\x03\x04\
\x07\x01\x12\x03n\x08\x15\n\x20\n\x04\x04\x07\x02\0\x12\x03o\x04\x20\"\
\x13\x20address\x20to\x20verify\n\n\x0c\n\x05\x04\x07\x02\0\x04\x12\x03o\
\x04\x0c\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03o\r\x13\n\x0c\n\x05\x04\
\x07\x02\0\x01\x12\x03o\x14\x1b\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03o\
\x1e\x1f\n\"\n\x04\x04\x07\x02\x01\x12\x03p\x04!\"\x15\x20signature\x20t\
o\x20verify\n\n\x0c\n\x05\x04\x07\x02\x01\x04\x12\x03p\x04\x0c\n\x0c\n\
\x05\x04\x07\x02\x01\x05\x12\x03p\r\x12\n\x0c\n\x05\x04\x07\x02\x01\x01\
\x12\x03p\x13\x1c\n\x0c\n\x05\x04\x07\x02\x01\x03\x12\x03p\x1f\x20\n\x20\
\n\x04\x04\x07\x02\x02\x12\x03q\x04\x1f\"\x13\x20message\x20to\x20verify\
\n\n\x0c\n\x05\x04\x07\x02\x02\x04\x12\x03q\x04\x0c\n\x0c\n\x05\x04\x07\
\x02\x02\x05\x12\x03q\r\x12\n\x0c\n\x05\x04\x07\x02\x02\x01\x12\x03q\x13\
\x1a\n\x0c\n\x05\x04\x07\x02\x02\x03\x12\x03q\x1d\x1e\n(\n\x04\x04\x07\
\x02\x03\x12\x03r\x046\"\x1b\x20coin\x20to\x20use\x20for\x20verifying\n\
\n\x0c\n\x05\x04\x07\x02\x03\x04\x12\x03r\x04\x0c\n\x0c\n\x05\x04\x07\
\x02\x03\x05\x12\x03r\r\x13\n\x0c\n\x05\x04\x07\x02\x03\x01\x12\x03r\x14\
\x1d\n\x0c\n\x05\x04\x07\x02\x03\x03\x12\x03r\x20!\n\x0c\n\x05\x04\x07\
\x02\x03\x08\x12\x03r\"5\n\x0c\n\x05\x04\x07\x02\x03\x07\x12\x03r+4\n`\n\
\x02\x04\x08\x12\x05{\0\x83\x01\x01\x1aS*\n\x20Request:\x20Ask\x20device\
\x20to\x20sign\x20transaction\n\x20@start\n\x20@next\x20TxRequest\n\x20@\
next\x20Failure\n\n\n\n\x03\x04\x08\x01\x12\x03{\x08\x0e\n,\n\x04\x04\
\x08\x02\0\x12\x03|\x04&\"\x1f\x20number\x20of\x20transaction\x20outputs\
\n\n\x0c\n\x05\x04\x08\x02\0\x04\x12\x03|\x04\x0c\n\x0c\n\x05\x04\x08\
\x02\0\x05\x12\x03|\r\x13\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x03|\x14!\n\
\x0c\n\x05\x04\x08\x02\0\x03\x12\x03|$%\n+\n\x04\x04\x08\x02\x01\x12\x03\
}\x04%\"\x1e\x20number\x20of\x20transaction\x20inputs\n\n\x0c\n\x05\x04\
\x08\x02\x01\x04\x12\x03}\x04\x0c\n\x0c\n\x05\x04\x08\x02\x01\x05\x12\
\x03}\r\x13\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\x03}\x14\x20\n\x0c\n\x05\
\x04\x08\x02\x01\x03\x12\x03}#$\n\x1a\n\x04\x04\x08\x02\x02\x12\x03~\x04\
6\"\r\x20coin\x20to\x20use\n\n\x0c\n\x05\x04\x08\x02\x02\x04\x12\x03~\
\x04\x0c\n\x0c\n\x05\x04\x08\x02\x02\x05\x12\x03~\r\x13\n\x0c\n\x05\x04\
\x08\x02\x02\x01\x12\x03~\x14\x1d\n\x0c\n\x05\x04\x08\x02\x02\x03\x12\
\x03~\x20!\n\x0c\n\x05\x04\x08\x02\x02\x08\x12\x03~\"5\n\x0c\n\x05\x04\
\x08\x02\x02\x07\x12\x03~+4\n\"\n\x04\x04\x08\x02\x03\x12\x03\x7f\x04,\"\
\x15\x20transaction\x20version\n\n\x0c\n\x05\x04\x08\x02\x03\x04\x12\x03\
\x7f\x04\x0c\n\x0c\n\x05\x04\x08\x02\x03\x05\x12\x03\x7f\r\x13\n\x0c\n\
\x05\x04\x08\x02\x03\x01\x12\x03\x7f\x14\x1b\n\x0c\n\x05\x04\x08\x02\x03\
\x03\x12\x03\x7f\x1e\x1f\n\x0c\n\x05\x04\x08\x02\x03\x08\x12\x03\x7f\x20\
+\n\x0c\n\x05\x04\x08\x02\x03\x07\x12\x03\x7f)*\n%\n\x04\x04\x08\x02\x04\
\x12\x04\x80\x01\x04.\"\x17\x20transaction\x20lock_time\n\n\r\n\x05\x04\
\x08\x02\x04\x04\x12\x04\x80\x01\x04\x0c\n\r\n\x05\x04\x08\x02\x04\x05\
\x12\x04\x80\x01\r\x13\n\r\n\x05\x04\x08\x02\x04\x01\x12\x04\x80\x01\x14\
\x1d\n\r\n\x05\x04\x08\x02\x04\x03\x12\x04\x80\x01\x20!\n\r\n\x05\x04\
\x08\x02\x04\x08\x12\x04\x80\x01\"-\n\r\n\x05\x04\x08\x02\x04\x07\x12\
\x04\x80\x01+,\n)\n\x04\x04\x08\x02\x05\x12\x04\x81\x01\x04\x1f\"\x1b\
\x20only\x20for\x20Decred\x20and\x20Zcash\n\n\r\n\x05\x04\x08\x02\x05\
\x04\x12\x04\x81\x01\x04\x0c\n\r\n\x05\x04\x08\x02\x05\x05\x12\x04\x81\
\x01\r\x13\n\r\n\x05\x04\x08\x02\x05\x01\x12\x04\x81\x01\x14\x1a\n\r\n\
\x05\x04\x08\x02\x05\x03\x12\x04\x81\x01\x1d\x1e\n\x1e\n\x04\x04\x08\x02\
\x06\x12\x04\x82\x01\x04#\"\x10\x20only\x20for\x20Zcash\n\n\r\n\x05\x04\
\x08\x02\x06\x04\x12\x04\x82\x01\x04\x0c\n\r\n\x05\x04\x08\x02\x06\x05\
\x12\x04\x82\x01\r\x11\n\r\n\x05\x04\x08\x02\x06\x01\x12\x04\x82\x01\x12\
\x1e\n\r\n\x05\x04\x08\x02\x06\x03\x12\x04\x82\x01!\"\n\xbf\x02\n\x02\
\x04\t\x12\x06\x8c\x01\0\xab\x01\x01\x1a\xb0\x02*\n\x20Response:\x20Devi\
ce\x20asks\x20for\x20information\x20for\x20signing\x20transaction\x20or\
\x20returns\x20the\x20last\x20result\n\x20If\x20request_index\x20is\x20s\
et,\x20device\x20awaits\x20TxAck\x20message\x20(with\x20fields\x20filled\
\x20in\x20according\x20to\x20request_type)\n\x20If\x20signature_index\
\x20is\x20set,\x20'signature'\x20contains\x20signed\x20input\x20of\x20si\
gnature_index's\x20input\n\x20@end\n\x20@next\x20TxAck\n\n\x0b\n\x03\x04\
\t\x01\x12\x04\x8c\x01\x08\x11\n7\n\x04\x04\t\x02\0\x12\x04\x8d\x01\x04*\
\")\x20what\x20should\x20be\x20filled\x20in\x20TxAck\x20message?\n\n\r\n\
\x05\x04\t\x02\0\x04\x12\x04\x8d\x01\x04\x0c\n\r\n\x05\x04\t\x02\0\x06\
\x12\x04\x8d\x01\r\x18\n\r\n\x05\x04\t\x02\0\x01\x12\x04\x8d\x01\x19%\n\
\r\n\x05\x04\t\x02\0\x03\x12\x04\x8d\x01()\n&\n\x04\x04\t\x02\x01\x12\
\x04\x8e\x01\x04.\"\x18\x20request\x20for\x20tx\x20details\n\n\r\n\x05\
\x04\t\x02\x01\x04\x12\x04\x8e\x01\x04\x0c\n\r\n\x05\x04\t\x02\x01\x06\
\x12\x04\x8e\x01\r!\n\r\n\x05\x04\t\x02\x01\x01\x12\x04\x8e\x01\")\n\r\n\
\x05\x04\t\x02\x01\x03\x12\x04\x8e\x01,-\n4\n\x04\x04\t\x02\x02\x12\x04\
\x8f\x01\x044\"&\x20serialized\x20data\x20and\x20request\x20for\x20next\
\n\n\r\n\x05\x04\t\x02\x02\x04\x12\x04\x8f\x01\x04\x0c\n\r\n\x05\x04\t\
\x02\x02\x06\x12\x04\x8f\x01\r$\n\r\n\x05\x04\t\x02\x02\x01\x12\x04\x8f\
\x01%/\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\x8f\x0123\nO\n\x04\x04\t\x04\
\0\x12\x06\x93\x01\x04\x99\x01\x05\x1a?*\n\x20Type\x20of\x20information\
\x20required\x20by\x20transaction\x20signing\x20process\n\n\r\n\x05\x04\
\t\x04\0\x01\x12\x04\x93\x01\t\x14\n\x0e\n\x06\x04\t\x04\0\x02\0\x12\x04\
\x94\x01\x08\x14\n\x0f\n\x07\x04\t\x04\0\x02\0\x01\x12\x04\x94\x01\x08\
\x0f\n\x0f\n\x07\x04\t\x04\0\x02\0\x02\x12\x04\x94\x01\x12\x13\n\x0e\n\
\x06\x04\t\x04\0\x02\x01\x12\x04\x95\x01\x08\x15\n\x0f\n\x07\x04\t\x04\0\
\x02\x01\x01\x12\x04\x95\x01\x08\x10\n\x0f\n\x07\x04\t\x04\0\x02\x01\x02\
\x12\x04\x95\x01\x13\x14\n\x0e\n\x06\x04\t\x04\0\x02\x02\x12\x04\x96\x01\
\x08\x13\n\x0f\n\x07\x04\t\x04\0\x02\x02\x01\x12\x04\x96\x01\x08\x0e\n\
\x0f\n\x07\x04\t\x04\0\x02\x02\x02\x12\x04\x96\x01\x11\x12\n\x0e\n\x06\
\x04\t\x04\0\x02\x03\x12\x04\x97\x01\x08\x17\n\x0f\n\x07\x04\t\x04\0\x02\
\x03\x01\x12\x04\x97\x01\x08\x12\n\x0f\n\x07\x04\t\x04\0\x02\x03\x02\x12\
\x04\x97\x01\x15\x16\n\x0e\n\x06\x04\t\x04\0\x02\x04\x12\x04\x98\x01\x08\
\x18\n\x0f\n\x07\x04\t\x04\0\x02\x04\x01\x12\x04\x98\x01\x08\x13\n\x0f\n\
\x07\x04\t\x04\0\x02\x04\x02\x12\x04\x98\x01\x16\x17\n:\n\x04\x04\t\x03\
\0\x12\x06\x9d\x01\x04\xa2\x01\x05\x1a**\n\x20Structure\x20representing\
\x20request\x20details\n\n\r\n\x05\x04\t\x03\0\x01\x12\x04\x9d\x01\x0c\
\x20\n@\n\x06\x04\t\x03\0\x02\0\x12\x04\x9e\x01\x08*\"0\x20device\x20exp\
ects\x20TxAck\x20message\x20from\x20the\x20computer\n\n\x0f\n\x07\x04\t\
\x03\0\x02\0\x04\x12\x04\x9e\x01\x08\x10\n\x0f\n\x07\x04\t\x03\0\x02\0\
\x05\x12\x04\x9e\x01\x11\x17\n\x0f\n\x07\x04\t\x03\0\x02\0\x01\x12\x04\
\x9e\x01\x18%\n\x0f\n\x07\x04\t\x03\0\x02\0\x03\x12\x04\x9e\x01()\n2\n\
\x06\x04\t\x03\0\x02\x01\x12\x04\x9f\x01\x08#\"\"\x20tx_hash\x20of\x20re\
quested\x20transaction\n\n\x0f\n\x07\x04\t\x03\0\x02\x01\x04\x12\x04\x9f\
\x01\x08\x10\n\x0f\n\x07\x04\t\x03\0\x02\x01\x05\x12\x04\x9f\x01\x11\x16\
\n\x0f\n\x07\x04\t\x03\0\x02\x01\x01\x12\x04\x9f\x01\x17\x1e\n\x0f\n\x07\
\x04\t\x03\0\x02\x01\x03\x12\x04\x9f\x01!\"\n0\n\x06\x04\t\x03\0\x02\x02\
\x12\x04\xa0\x01\x08+\"\x20\x20length\x20of\x20requested\x20extra\x20dat\
a\n\n\x0f\n\x07\x04\t\x03\0\x02\x02\x04\x12\x04\xa0\x01\x08\x10\n\x0f\n\
\x07\x04\t\x03\0\x02\x02\x05\x12\x04\xa0\x01\x11\x17\n\x0f\n\x07\x04\t\
\x03\0\x02\x02\x01\x12\x04\xa0\x01\x18&\n\x0f\n\x07\x04\t\x03\0\x02\x02\
\x03\x12\x04\xa0\x01)*\n0\n\x06\x04\t\x03\0\x02\x03\x12\x04\xa1\x01\x08.\
\"\x20\x20offset\x20of\x20requested\x20extra\x20data\n\n\x0f\n\x07\x04\t\
\x03\0\x02\x03\x04\x12\x04\xa1\x01\x08\x10\n\x0f\n\x07\x04\t\x03\0\x02\
\x03\x05\x12\x04\xa1\x01\x11\x17\n\x0f\n\x07\x04\t\x03\0\x02\x03\x01\x12\
\x04\xa1\x01\x18)\n\x0f\n\x07\x04\t\x03\0\x02\x03\x03\x12\x04\xa1\x01,-\
\n:\n\x04\x04\t\x03\x01\x12\x06\xa6\x01\x04\xaa\x01\x05\x1a**\n\x20Struc\
ture\x20representing\x20serialized\x20data\n\n\r\n\x05\x04\t\x03\x01\x01\
\x12\x04\xa6\x01\x0c#\nG\n\x06\x04\t\x03\x01\x02\0\x12\x04\xa7\x01\x08,\
\"7\x20'signature'\x20field\x20contains\x20signed\x20input\x20of\x20this\
\x20index\n\n\x0f\n\x07\x04\t\x03\x01\x02\0\x04\x12\x04\xa7\x01\x08\x10\
\n\x0f\n\x07\x04\t\x03\x01\x02\0\x05\x12\x04\xa7\x01\x11\x17\n\x0f\n\x07\
\x04\t\x03\x01\x02\0\x01\x12\x04\xa7\x01\x18'\n\x0f\n\x07\x04\t\x03\x01\
\x02\0\x03\x12\x04\xa7\x01*+\n8\n\x06\x04\t\x03\x01\x02\x01\x12\x04\xa8\
\x01\x08%\"(\x20signature\x20of\x20the\x20signature_index\x20input\n\n\
\x0f\n\x07\x04\t\x03\x01\x02\x01\x04\x12\x04\xa8\x01\x08\x10\n\x0f\n\x07\
\x04\t\x03\x01\x02\x01\x05\x12\x04\xa8\x01\x11\x16\n\x0f\n\x07\x04\t\x03\
\x01\x02\x01\x01\x12\x04\xa8\x01\x17\x20\n\x0f\n\x07\x04\t\x03\x01\x02\
\x01\x03\x12\x04\xa8\x01#$\n;\n\x06\x04\t\x03\x01\x02\x02\x12\x04\xa9\
\x01\x08)\"+\x20part\x20of\x20serialized\x20and\x20signed\x20transaction\
\n\n\x0f\n\x07\x04\t\x03\x01\x02\x02\x04\x12\x04\xa9\x01\x08\x10\n\x0f\n\
\x07\x04\t\x03\x01\x02\x02\x05\x12\x04\xa9\x01\x11\x16\n\x0f\n\x07\x04\t\
\x03\x01\x02\x02\x01\x12\x04\xa9\x01\x17$\n\x0f\n\x07\x04\t\x03\x01\x02\
\x02\x03\x12\x04\xa9\x01'(\nE\n\x02\x04\n\x12\x06\xb1\x01\0\xf2\x01\x01\
\x1a7*\n\x20Request:\x20Reported\x20transaction\x20data\n\x20@next\x20Tx\
Request\n\n\x0b\n\x03\x04\n\x01\x12\x04\xb1\x01\x08\r\n\x0c\n\x04\x04\n\
\x02\0\x12\x04\xb2\x01\x04$\n\r\n\x05\x04\n\x02\0\x04\x12\x04\xb2\x01\
\x04\x0c\n\r\n\x05\x04\n\x02\0\x06\x12\x04\xb2\x01\r\x1c\n\r\n\x05\x04\n\
\x02\0\x01\x12\x04\xb2\x01\x1d\x1f\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xb2\
\x01\"#\n6\n\x04\x04\n\x03\0\x12\x06\xb6\x01\x04\xf1\x01\x05\x1a&*\n\x20\
Structure\x20representing\x20transaction\n\n\r\n\x05\x04\n\x03\0\x01\x12\
\x04\xb6\x01\x0c\x1b\n\x0e\n\x06\x04\n\x03\0\x02\0\x12\x04\xb7\x01\x08$\
\n\x0f\n\x07\x04\n\x03\0\x02\0\x04\x12\x04\xb7\x01\x08\x10\n\x0f\n\x07\
\x04\n\x03\0\x02\0\x05\x12\x04\xb7\x01\x11\x17\n\x0f\n\x07\x04\n\x03\0\
\x02\0\x01\x12\x04\xb7\x01\x18\x1f\n\x0f\n\x07\x04\n\x03\0\x02\0\x03\x12\
\x04\xb7\x01\"#\n\x0e\n\x06\x04\n\x03\0\x02\x01\x12\x04\xb8\x01\x08(\n\
\x0f\n\x07\x04\n\x03\0\x02\x01\x04\x12\x04\xb8\x01\x08\x10\n\x0f\n\x07\
\x04\n\x03\0\x02\x01\x06\x12\x04\xb8\x01\x11\x1c\n\x0f\n\x07\x04\n\x03\0\
\x02\x01\x01\x12\x04\xb8\x01\x1d#\n\x0f\n\x07\x04\n\x03\0\x02\x01\x03\
\x12\x04\xb8\x01&'\n\x0e\n\x06\x04\n\x03\0\x02\x02\x12\x04\xb9\x01\x081\
\n\x0f\n\x07\x04\n\x03\0\x02\x02\x04\x12\x04\xb9\x01\x08\x10\n\x0f\n\x07\
\x04\n\x03\0\x02\x02\x06\x12\x04\xb9\x01\x11\x20\n\x0f\n\x07\x04\n\x03\0\
\x02\x02\x01\x12\x04\xb9\x01!,\n\x0f\n\x07\x04\n\x03\0\x02\x02\x03\x12\
\x04\xb9\x01/0\n\x0e\n\x06\x04\n\x03\0\x02\x03\x12\x04\xba\x01\x08&\n\
\x0f\n\x07\x04\n\x03\0\x02\x03\x04\x12\x04\xba\x01\x08\x10\n\x0f\n\x07\
\x04\n\x03\0\x02\x03\x05\x12\x04\xba\x01\x11\x17\n\x0f\n\x07\x04\n\x03\0\
\x02\x03\x01\x12\x04\xba\x01\x18!\n\x0f\n\x07\x04\n\x03\0\x02\x03\x03\
\x12\x04\xba\x01$%\n\x0e\n\x06\x04\n\x03\0\x02\x04\x12\x04\xbb\x01\x08*\
\n\x0f\n\x07\x04\n\x03\0\x02\x04\x04\x12\x04\xbb\x01\x08\x10\n\x0f\n\x07\
\x04\n\x03\0\x02\x04\x06\x12\x04\xbb\x01\x11\x1d\n\x0f\n\x07\x04\n\x03\0\
\x02\x04\x01\x12\x04\xbb\x01\x1e%\n\x0f\n\x07\x04\n\x03\0\x02\x04\x03\
\x12\x04\xbb\x01()\n\x0e\n\x06\x04\n\x03\0\x02\x05\x12\x04\xbc\x01\x08'\
\n\x0f\n\x07\x04\n\x03\0\x02\x05\x04\x12\x04\xbc\x01\x08\x10\n\x0f\n\x07\
\x04\n\x03\0\x02\x05\x05\x12\x04\xbc\x01\x11\x17\n\x0f\n\x07\x04\n\x03\0\
\x02\x05\x01\x12\x04\xbc\x01\x18\"\n\x0f\n\x07\x04\n\x03\0\x02\x05\x03\
\x12\x04\xbc\x01%&\n\x0e\n\x06\x04\n\x03\0\x02\x06\x12\x04\xbd\x01\x08(\
\n\x0f\n\x07\x04\n\x03\0\x02\x06\x04\x12\x04\xbd\x01\x08\x10\n\x0f\n\x07\
\x04\n\x03\0\x02\x06\x05\x12\x04\xbd\x01\x11\x17\n\x0f\n\x07\x04\n\x03\0\
\x02\x06\x01\x12\x04\xbd\x01\x18#\n\x0f\n\x07\x04\n\x03\0\x02\x06\x03\
\x12\x04\xbd\x01&'\n\x20\n\x06\x04\n\x03\0\x02\x07\x12\x04\xbe\x01\x08&\
\"\x10\x20only\x20for\x20Zcash\n\n\x0f\n\x07\x04\n\x03\0\x02\x07\x04\x12\
\x04\xbe\x01\x08\x10\n\x0f\n\x07\x04\n\x03\0\x02\x07\x05\x12\x04\xbe\x01\
\x11\x16\n\x0f\n\x07\x04\n\x03\0\x02\x07\x01\x12\x04\xbe\x01\x17!\n\x0f\
\n\x07\x04\n\x03\0\x02\x07\x03\x12\x04\xbe\x01$%\n\x20\n\x06\x04\n\x03\0\
\x02\x08\x12\x04\xbf\x01\x08+\"\x10\x20only\x20for\x20Zcash\n\n\x0f\n\
\x07\x04\n\x03\0\x02\x08\x04\x12\x04\xbf\x01\x08\x10\n\x0f\n\x07\x04\n\
\x03\0\x02\x08\x05\x12\x04\xbf\x01\x11\x17\n\x0f\n\x07\x04\n\x03\0\x02\
\x08\x01\x12\x04\xbf\x01\x18&\n\x0f\n\x07\x04\n\x03\0\x02\x08\x03\x12\
\x04\xbf\x01)*\n+\n\x06\x04\n\x03\0\x02\t\x12\x04\xc0\x01\x08$\"\x1b\x20\
only\x20for\x20Decred\x20and\x20Zcash\n\n\x0f\n\x07\x04\n\x03\0\x02\t\
\x04\x12\x04\xc0\x01\x08\x10\n\x0f\n\x07\x04\n\x03\0\x02\t\x05\x12\x04\
\xc0\x01\x11\x17\n\x0f\n\x07\x04\n\x03\0\x02\t\x01\x12\x04\xc0\x01\x18\
\x1e\n\x0f\n\x07\x04\n\x03\0\x02\t\x03\x12\x04\xc0\x01!#\n\x20\n\x06\x04\
\n\x03\0\x02\n\x12\x04\xc1\x01\x08(\"\x10\x20only\x20for\x20Zcash\n\n\
\x0f\n\x07\x04\n\x03\0\x02\n\x04\x12\x04\xc1\x01\x08\x10\n\x0f\n\x07\x04\
\n\x03\0\x02\n\x05\x12\x04\xc1\x01\x11\x15\n\x0f\n\x07\x04\n\x03\0\x02\n\
\x01\x12\x04\xc1\x01\x16\"\n\x0f\n\x07\x04\n\x03\0\x02\n\x03\x12\x04\xc1\
\x01%'\n>\n\x06\x04\n\x03\0\x03\0\x12\x06\xc5\x01\x08\xd2\x01\t\x1a,*\n\
\x20Structure\x20representing\x20transaction\x20input\n\n\x0f\n\x07\x04\
\n\x03\0\x03\0\x01\x12\x04\xc5\x01\x10\x1b\nB\n\x08\x04\n\x03\0\x03\0\
\x02\0\x12\x04\xc6\x01\x0c*\"0\x20BIP-32\x20path\x20to\x20derive\x20the\
\x20key\x20from\x20master\x20node\n\n\x11\n\t\x04\n\x03\0\x03\0\x02\0\
\x04\x12\x04\xc6\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\0\x02\0\x05\x12\
\x04\xc6\x01\x15\x1b\n\x11\n\t\x04\n\x03\0\x03\0\x02\0\x01\x12\x04\xc6\
\x01\x1c%\n\x11\n\t\x04\n\x03\0\x03\0\x02\0\x03\x12\x04\xc6\x01()\nN\n\
\x08\x04\n\x03\0\x03\0\x02\x01\x12\x04\xc7\x01\x0c)\"<\x20hash\x20of\x20\
previous\x20transaction\x20output\x20to\x20spend\x20by\x20this\x20input\
\n\n\x11\n\t\x04\n\x03\0\x03\0\x02\x01\x04\x12\x04\xc7\x01\x0c\x14\n\x11\
\n\t\x04\n\x03\0\x03\0\x02\x01\x05\x12\x04\xc7\x01\x15\x1a\n\x11\n\t\x04\
\n\x03\0\x03\0\x02\x01\x01\x12\x04\xc7\x01\x1b$\n\x11\n\t\x04\n\x03\0\
\x03\0\x02\x01\x03\x12\x04\xc7\x01'(\n5\n\x08\x04\n\x03\0\x03\0\x02\x02\
\x12\x04\xc8\x01\x0c+\"#\x20index\x20of\x20previous\x20output\x20to\x20s\
pend\n\n\x11\n\t\x04\n\x03\0\x03\0\x02\x02\x04\x12\x04\xc8\x01\x0c\x14\n\
\x11\n\t\x04\n\x03\0\x03\0\x02\x02\x05\x12\x04\xc8\x01\x15\x1b\n\x11\n\t\
\x04\n\x03\0\x03\0\x02\x02\x01\x12\x04\xc8\x01\x1c&\n\x11\n\t\x04\n\x03\
\0\x03\0\x02\x02\x03\x12\x04\xc8\x01)*\n:\n\x08\x04\n\x03\0\x03\0\x02\
\x03\x12\x04\xc9\x01\x0c*\"(\x20script\x20signature,\x20unset\x20for\x20\
tx\x20to\x20sign\n\n\x11\n\t\x04\n\x03\0\x03\0\x02\x03\x04\x12\x04\xc9\
\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\0\x02\x03\x05\x12\x04\xc9\x01\x15\
\x1a\n\x11\n\t\x04\n\x03\0\x03\0\x02\x03\x01\x12\x04\xc9\x01\x1b%\n\x11\
\n\t\x04\n\x03\0\x03\0\x02\x03\x03\x12\x04\xc9\x01()\n1\n\x08\x04\n\x03\
\0\x03\0\x02\x04\x12\x04\xca\x01\x0c>\"\x1f\x20sequence\x20(default=0xff\
ffffff)\n\n\x11\n\t\x04\n\x03\0\x03\0\x02\x04\x04\x12\x04\xca\x01\x0c\
\x14\n\x11\n\t\x04\n\x03\0\x03\0\x02\x04\x05\x12\x04\xca\x01\x15\x1b\n\
\x11\n\t\x04\n\x03\0\x03\0\x02\x04\x01\x12\x04\xca\x01\x1c$\n\x11\n\t\
\x04\n\x03\0\x03\0\x02\x04\x03\x12\x04\xca\x01'(\n\x11\n\t\x04\n\x03\0\
\x03\0\x02\x04\x08\x12\x04\xca\x01)=\n\x11\n\t\x04\n\x03\0\x03\0\x02\x04\
\x07\x12\x04\xca\x012<\n4\n\x08\x04\n\x03\0\x03\0\x02\x05\x12\x04\xcb\
\x01\x0cL\"\"\x20defines\x20template\x20of\x20input\x20script\n\n\x11\n\
\t\x04\n\x03\0\x03\0\x02\x05\x04\x12\x04\xcb\x01\x0c\x14\n\x11\n\t\x04\n\
\x03\0\x03\0\x02\x05\x06\x12\x04\xcb\x01\x15$\n\x11\n\t\x04\n\x03\0\x03\
\0\x02\x05\x01\x12\x04\xcb\x01%0\n\x11\n\t\x04\n\x03\0\x03\0\x02\x05\x03\
\x12\x04\xcb\x0134\n\x11\n\t\x04\n\x03\0\x03\0\x02\x05\x08\x12\x04\xcb\
\x015K\n\x11\n\t\x04\n\x03\0\x03\0\x02\x05\x07\x12\x04\xcb\x01>J\nA\n\
\x08\x04\n\x03\0\x03\0\x02\x06\x12\x04\xcc\x01\x0c;\"/\x20Filled\x20if\
\x20input\x20is\x20going\x20to\x20spend\x20multisig\x20tx\n\n\x11\n\t\
\x04\n\x03\0\x03\0\x02\x06\x04\x12\x04\xcc\x01\x0c\x14\n\x11\n\t\x04\n\
\x03\0\x03\0\x02\x06\x06\x12\x04\xcc\x01\x15-\n\x11\n\t\x04\n\x03\0\x03\
\0\x02\x06\x01\x12\x04\xcc\x01.6\n\x11\n\t\x04\n\x03\0\x03\0\x02\x06\x03\
\x12\x04\xcc\x019:\nK\n\x08\x04\n\x03\0\x03\0\x02\x07\x12\x04\xcd\x01\
\x0c'\"9\x20amount\x20of\x20previous\x20transaction\x20output\x20(for\
\x20segwit\x20only)\n\n\x11\n\t\x04\n\x03\0\x03\0\x02\x07\x04\x12\x04\
\xcd\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\0\x02\x07\x05\x12\x04\xcd\x01\
\x15\x1b\n\x11\n\t\x04\n\x03\0\x03\0\x02\x07\x01\x12\x04\xcd\x01\x1c\"\n\
\x11\n\t\x04\n\x03\0\x03\0\x02\x07\x03\x12\x04\xcd\x01%&\n\x10\n\x08\x04\
\n\x03\0\x03\0\x02\x08\x12\x04\xce\x01\x0c,\n\x11\n\t\x04\n\x03\0\x03\0\
\x02\x08\x04\x12\x04\xce\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\0\x02\x08\
\x05\x12\x04\xce\x01\x15\x1b\n\x11\n\t\x04\n\x03\0\x03\0\x02\x08\x01\x12\
\x04\xce\x01\x1c'\n\x11\n\t\x04\n\x03\0\x03\0\x02\x08\x03\x12\x04\xce\
\x01*+\n\x10\n\x08\x04\n\x03\0\x03\0\x02\t\x12\x04\xcf\x01\x0c7\n\x11\n\
\t\x04\n\x03\0\x03\0\x02\t\x04\x12\x04\xcf\x01\x0c\x14\n\x11\n\t\x04\n\
\x03\0\x03\0\x02\t\x05\x12\x04\xcf\x01\x15\x1b\n\x11\n\t\x04\n\x03\0\x03\
\0\x02\t\x01\x12\x04\xcf\x01\x1c1\n\x11\n\t\x04\n\x03\0\x03\0\x02\t\x03\
\x12\x04\xcf\x0146\nY\n\x08\x04\n\x03\0\x03\0\x02\n\x12\x04\xd0\x01\x0c7\
\"G\x20block\x20hash\x20of\x20previous\x20transaction\x20output\x20(for\
\x20bip115\x20implementation)\n\n\x11\n\t\x04\n\x03\0\x03\0\x02\n\x04\
\x12\x04\xd0\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\0\x02\n\x05\x12\x04\
\xd0\x01\x15\x1a\n\x11\n\t\x04\n\x03\0\x03\0\x02\n\x01\x12\x04\xd0\x01\
\x1b1\n\x11\n\t\x04\n\x03\0\x03\0\x02\n\x03\x12\x04\xd0\x0146\n[\n\x08\
\x04\n\x03\0\x03\0\x02\x0b\x12\x04\xd1\x01\x0c:\"I\x20block\x20height\
\x20of\x20previous\x20transaction\x20output\x20(for\x20bip115\x20impleme\
ntation)\n\n\x11\n\t\x04\n\x03\0\x03\0\x02\x0b\x04\x12\x04\xd1\x01\x0c\
\x14\n\x11\n\t\x04\n\x03\0\x03\0\x02\x0b\x05\x12\x04\xd1\x01\x15\x1b\n\
\x11\n\t\x04\n\x03\0\x03\0\x02\x0b\x01\x12\x04\xd1\x01\x1c4\n\x11\n\t\
\x04\n\x03\0\x03\0\x02\x0b\x03\x12\x04\xd1\x0179\nH\n\x06\x04\n\x03\0\
\x03\x01\x12\x06\xd6\x01\x08\xda\x01\t\x1a6*\n\x20Structure\x20represent\
ing\x20compiled\x20transaction\x20output\n\n\x0f\n\x07\x04\n\x03\0\x03\
\x01\x01\x12\x04\xd6\x01\x10\x1f\n\x10\n\x08\x04\n\x03\0\x03\x01\x02\0\
\x12\x04\xd7\x01\x0c'\n\x11\n\t\x04\n\x03\0\x03\x01\x02\0\x04\x12\x04\
\xd7\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\x01\x02\0\x05\x12\x04\xd7\x01\
\x15\x1b\n\x11\n\t\x04\n\x03\0\x03\x01\x02\0\x01\x12\x04\xd7\x01\x1c\"\n\
\x11\n\t\x04\n\x03\0\x03\x01\x02\0\x03\x12\x04\xd7\x01%&\n\x10\n\x08\x04\
\n\x03\0\x03\x01\x02\x01\x12\x04\xd8\x01\x0c-\n\x11\n\t\x04\n\x03\0\x03\
\x01\x02\x01\x04\x12\x04\xd8\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\x01\
\x02\x01\x05\x12\x04\xd8\x01\x15\x1a\n\x11\n\t\x04\n\x03\0\x03\x01\x02\
\x01\x01\x12\x04\xd8\x01\x1b(\n\x11\n\t\x04\n\x03\0\x03\x01\x02\x01\x03\
\x12\x04\xd8\x01+,\n\x10\n\x08\x04\n\x03\0\x03\x01\x02\x02\x12\x04\xd9\
\x01\x0c6\n\x11\n\t\x04\n\x03\0\x03\x01\x02\x02\x04\x12\x04\xd9\x01\x0c\
\x14\n\x11\n\t\x04\n\x03\0\x03\x01\x02\x02\x05\x12\x04\xd9\x01\x15\x1b\n\
\x11\n\t\x04\n\x03\0\x03\x01\x02\x02\x01\x12\x04\xd9\x01\x1c1\n\x11\n\t\
\x04\n\x03\0\x03\x01\x02\x02\x03\x12\x04\xd9\x0145\n?\n\x06\x04\n\x03\0\
\x03\x02\x12\x06\xde\x01\x08\xf0\x01\t\x1a-*\n\x20Structure\x20represent\
ing\x20transaction\x20output\n\n\x0f\n\x07\x04\n\x03\0\x03\x02\x01\x12\
\x04\xde\x01\x10\x1c\n:\n\x08\x04\n\x03\0\x03\x02\x02\0\x12\x04\xdf\x01\
\x0c(\"(\x20target\x20coin\x20address\x20in\x20Base58\x20encoding\n\n\
\x11\n\t\x04\n\x03\0\x03\x02\x02\0\x04\x12\x04\xdf\x01\x0c\x14\n\x11\n\t\
\x04\n\x03\0\x03\x02\x02\0\x05\x12\x04\xdf\x01\x15\x1b\n\x11\n\t\x04\n\
\x03\0\x03\x02\x02\0\x01\x12\x04\xdf\x01\x1c#\n\x11\n\t\x04\n\x03\0\x03\
\x02\x02\0\x03\x12\x04\xdf\x01&'\nf\n\x08\x04\n\x03\0\x03\x02\x02\x01\
\x12\x04\xe0\x01\x0c*\"T\x20BIP-32\x20path\x20to\x20derive\x20the\x20key\
\x20from\x20master\x20node;\x20has\x20higher\x20priority\x20than\x20\"ad\
dress\"\n\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x01\x04\x12\x04\xe0\x01\x0c\
\x14\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x01\x05\x12\x04\xe0\x01\x15\x1b\n\
\x11\n\t\x04\n\x03\0\x03\x02\x02\x01\x01\x12\x04\xe0\x01\x1c%\n\x11\n\t\
\x04\n\x03\0\x03\x02\x02\x01\x03\x12\x04\xe0\x01()\n/\n\x08\x04\n\x03\0\
\x03\x02\x02\x02\x12\x04\xe1\x01\x0c'\"\x1d\x20amount\x20to\x20spend\x20\
in\x20satoshis\n\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x02\x04\x12\x04\xe1\
\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x02\x05\x12\x04\xe1\x01\
\x15\x1b\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x02\x01\x12\x04\xe1\x01\x1c\"\
\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x02\x03\x12\x04\xe1\x01%&\n&\n\x08\
\x04\n\x03\0\x03\x02\x02\x03\x12\x04\xe2\x01\x0c6\"\x14\x20output\x20scr\
ipt\x20type\n\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x03\x04\x12\x04\xe2\x01\
\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x03\x06\x12\x04\xe2\x01\x15%\
\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x03\x01\x12\x04\xe2\x01&1\n\x11\n\t\
\x04\n\x03\0\x03\x02\x02\x03\x03\x12\x04\xe2\x0145\nO\n\x08\x04\n\x03\0\
\x03\x02\x02\x04\x12\x04\xe3\x01\x0c;\"=\x20defines\x20multisig\x20addre\
ss;\x20script_type\x20must\x20be\x20PAYTOMULTISIG\n\n\x11\n\t\x04\n\x03\
\0\x03\x02\x02\x04\x04\x12\x04\xe3\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\
\x02\x02\x04\x06\x12\x04\xe3\x01\x15-\n\x11\n\t\x04\n\x03\0\x03\x02\x02\
\x04\x01\x12\x04\xe3\x01.6\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x04\x03\x12\
\x04\xe3\x019:\n_\n\x08\x04\n\x03\0\x03\x02\x02\x05\x12\x04\xe4\x01\x0c.\
\"M\x20defines\x20op_return\x20data;\x20script_type\x20must\x20be\x20PAY\
TOOPRETURN,\x20amount\x20must\x20be\x200\n\n\x11\n\t\x04\n\x03\0\x03\x02\
\x02\x05\x04\x12\x04\xe4\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\x02\x02\
\x05\x05\x12\x04\xe4\x01\x15\x1a\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x05\
\x01\x12\x04\xe4\x01\x1b)\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x05\x03\x12\
\x04\xe4\x01,-\n\x10\n\x08\x04\n\x03\0\x03\x02\x02\x06\x12\x04\xe5\x01\
\x0c6\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x06\x04\x12\x04\xe5\x01\x0c\x14\
\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x06\x05\x12\x04\xe5\x01\x15\x1b\n\x11\
\n\t\x04\n\x03\0\x03\x02\x02\x06\x01\x12\x04\xe5\x01\x1c1\n\x11\n\t\x04\
\n\x03\0\x03\x02\x02\x06\x03\x12\x04\xe5\x0145\nn\n\x08\x04\n\x03\0\x03\
\x02\x02\x07\x12\x04\xe6\x01\x0c1\"\\\x20block\x20hash\x20of\x20existing\
\x20block\x20(recommended\x20current_block\x20-\x20300)\x20(for\x20bip11\
5\x20implementation)\n\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x07\x04\x12\x04\
\xe6\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x07\x05\x12\x04\xe6\
\x01\x15\x1a\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x07\x01\x12\x04\xe6\x01\
\x1b,\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x07\x03\x12\x04\xe6\x01/0\np\n\
\x08\x04\n\x03\0\x03\x02\x02\x08\x12\x04\xe7\x01\x0c4\"^\x20block\x20hei\
ght\x20of\x20existing\x20block\x20(recommended\x20current_block\x20-\x20\
300)\x20(for\x20bip115\x20implementation)\n\n\x11\n\t\x04\n\x03\0\x03\
\x02\x02\x08\x04\x12\x04\xe7\x01\x0c\x14\n\x11\n\t\x04\n\x03\0\x03\x02\
\x02\x08\x05\x12\x04\xe7\x01\x15\x1b\n\x11\n\t\x04\n\x03\0\x03\x02\x02\
\x08\x01\x12\x04\xe7\x01\x1c/\n\x11\n\t\x04\n\x03\0\x03\x02\x02\x08\x03\
\x12\x04\xe7\x0123\n\x12\n\x08\x04\n\x03\0\x03\x02\x04\0\x12\x06\xe8\x01\
\x0c\xef\x01\r\n\x11\n\t\x04\n\x03\0\x03\x02\x04\0\x01\x12\x04\xe8\x01\
\x11!\nE\n\n\x04\n\x03\0\x03\x02\x04\0\x02\0\x12\x04\xe9\x01\x10!\"1\x20\
used\x20for\x20all\x20addresses\x20(bitcoin,\x20p2sh,\x20witness)\n\n\
\x13\n\x0b\x04\n\x03\0\x03\x02\x04\0\x02\0\x01\x12\x04\xe9\x01\x10\x1c\n\
\x13\n\x0b\x04\n\x03\0\x03\x02\x04\0\x02\0\x02\x12\x04\xe9\x01\x1f\x20\n\
A\n\n\x04\n\x03\0\x03\x02\x04\0\x02\x01\x12\x04\xea\x01\x10$\"-\x20p2sh\
\x20address\x20(deprecated;\x20use\x20PAYTOADDRESS)\n\n\x13\n\x0b\x04\n\
\x03\0\x03\x02\x04\0\x02\x01\x01\x12\x04\xea\x01\x10\x1f\n\x13\n\x0b\x04\
\n\x03\0\x03\x02\x04\0\x02\x01\x02\x12\x04\xea\x01\"#\n,\n\n\x04\n\x03\0\
\x03\x02\x04\0\x02\x02\x12\x04\xeb\x01\x10\"\"\x18\x20only\x20for\x20cha\
nge\x20output\n\n\x13\n\x0b\x04\n\x03\0\x03\x02\x04\0\x02\x02\x01\x12\
\x04\xeb\x01\x10\x1d\n\x13\n\x0b\x04\n\x03\0\x03\x02\x04\0\x02\x02\x02\
\x12\x04\xeb\x01\x20!\n\x1f\n\n\x04\n\x03\0\x03\x02\x04\0\x02\x03\x12\
\x04\xec\x01\x10\"\"\x0b\x20op_return\n\n\x13\n\x0b\x04\n\x03\0\x03\x02\
\x04\0\x02\x03\x01\x12\x04\xec\x01\x10\x1d\n\x13\n\x0b\x04\n\x03\0\x03\
\x02\x04\0\x02\x03\x02\x12\x04\xec\x01\x20!\n,\n\n\x04\n\x03\0\x03\x02\
\x04\0\x02\x04\x12\x04\xed\x01\x10!\"\x18\x20only\x20for\x20change\x20ou\
tput\n\n\x13\n\x0b\x04\n\x03\0\x03\x02\x04\0\x02\x04\x01\x12\x04\xed\x01\
\x10\x1c\n\x13\n\x0b\x04\n\x03\0\x03\x02\x04\0\x02\x04\x02\x12\x04\xed\
\x01\x1f\x20\n,\n\n\x04\n\x03\0\x03\x02\x04\0\x02\x05\x12\x04\xee\x01\
\x10%\"\x18\x20only\x20for\x20change\x20output\n\n\x13\n\x0b\x04\n\x03\0\
\x03\x02\x04\0\x02\x05\x01\x12\x04\xee\x01\x10\x20\n\x13\n\x0b\x04\n\x03\
\0\x03\x02\x04\0\x02\x05\x02\x12\x04\xee\x01#$\
";
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()
})
}