#![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 nodes: ::protobuf::RepeatedField<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 {
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);
}
pub fn get_nodes(&self) -> &[super::messages_common::HDNodeType] {
&self.nodes
}
pub fn clear_nodes(&mut self) {
self.nodes.clear();
}
pub fn set_nodes(&mut self, v: ::protobuf::RepeatedField<super::messages_common::HDNodeType>) {
self.nodes = v;
}
pub fn mut_nodes(&mut self) -> &mut ::protobuf::RepeatedField<super::messages_common::HDNodeType> {
&mut self.nodes
}
pub fn take_nodes(&mut self) -> ::protobuf::RepeatedField<super::messages_common::HDNodeType> {
::std::mem::replace(&mut self.nodes, ::protobuf::RepeatedField::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 {
fn is_initialized(&self) -> bool {
if self.m.is_none() {
return false;
}
for v in &self.pubkeys {
if !v.is_initialized() {
return false;
}
};
for v in &self.nodes {
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);
},
4 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.nodes)?;
},
5 => {
::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;
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);
}
for value in &self.nodes {
let len = value.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(5, *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<()> {
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)?;
}
for v in &self.nodes {
os.write_tag(4, ::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(5, *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 },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::messages_common::HDNodeType>>(
"nodes",
|m: &MultisigRedeemScriptType| { &m.nodes },
|m: &mut MultisigRedeemScriptType| { &mut m.nodes },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"address_n",
|m: &MultisigRedeemScriptType| { &m.address_n },
|m: &mut MultisigRedeemScriptType| { &mut m.address_n },
));
::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.nodes.clear();
self.address_n.clear();
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>,
ignore_xpub_magic: ::std::option::Option<bool>,
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);
}
pub fn get_ignore_xpub_magic(&self) -> bool {
self.ignore_xpub_magic.unwrap_or(false)
}
pub fn clear_ignore_xpub_magic(&mut self) {
self.ignore_xpub_magic = ::std::option::Option::None;
}
pub fn has_ignore_xpub_magic(&self) -> bool {
self.ignore_xpub_magic.is_some()
}
pub fn set_ignore_xpub_magic(&mut self, v: bool) {
self.ignore_xpub_magic = ::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)?
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.ignore_xpub_magic = ::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.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);
}
if let Some(v) = self.ignore_xpub_magic {
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<()> {
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))?;
}
if let Some(v) = self.ignore_xpub_magic {
os.write_bool(6, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> 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 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"ignore_xpub_magic",
|m: &GetPublicKey| { &m.ignore_xpub_magic },
|m: &mut GetPublicKey| { &mut m.ignore_xpub_magic },
));
::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.ignore_xpub_magic = ::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>,
root_fingerprint: ::std::option::Option<u32>,
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())
}
pub fn get_root_fingerprint(&self) -> u32 {
self.root_fingerprint.unwrap_or(0)
}
pub fn clear_root_fingerprint(&mut self) {
self.root_fingerprint = ::std::option::Option::None;
}
pub fn has_root_fingerprint(&self) -> bool {
self.root_fingerprint.is_some()
}
pub fn set_root_fingerprint(&mut self, v: u32) {
self.root_fingerprint = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for PublicKey {
fn is_initialized(&self) -> bool {
if self.node.is_none() {
return false;
}
if self.xpub.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)?;
},
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.root_fingerprint = ::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.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);
}
if let Some(v) = self.root_fingerprint {
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(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)?;
}
if let Some(v) = self.root_fingerprint {
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() -> 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 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"root_fingerprint",
|m: &PublicKey| { &m.root_fingerprint },
|m: &mut PublicKey| { &mut m.root_fingerprint },
));
::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.root_fingerprint = ::std::option::Option::None;
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>,
ignore_xpub_magic: ::std::option::Option<bool>,
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);
}
pub fn get_ignore_xpub_magic(&self) -> bool {
self.ignore_xpub_magic.unwrap_or(false)
}
pub fn clear_ignore_xpub_magic(&mut self) {
self.ignore_xpub_magic = ::std::option::Option::None;
}
pub fn has_ignore_xpub_magic(&self) -> bool {
self.ignore_xpub_magic.is_some()
}
pub fn set_ignore_xpub_magic(&mut self, v: bool) {
self.ignore_xpub_magic = ::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)?
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.ignore_xpub_magic = ::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.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);
}
if let Some(v) = self.ignore_xpub_magic {
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<()> {
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))?;
}
if let Some(v) = self.ignore_xpub_magic {
os.write_bool(6, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> 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 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"ignore_xpub_magic",
|m: &GetAddress| { &m.ignore_xpub_magic },
|m: &mut GetAddress| { &mut m.ignore_xpub_magic },
));
::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.ignore_xpub_magic = ::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 GetOwnershipId {
pub address_n: ::std::vec::Vec<u32>,
coin_name: ::protobuf::SingularField<::std::string::String>,
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 GetOwnershipId {
fn default() -> &'a GetOwnershipId {
<GetOwnershipId as ::protobuf::Message>::default_instance()
}
}
impl GetOwnershipId {
pub fn new() -> GetOwnershipId {
::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_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 GetOwnershipId {
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 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.multisig)?;
},
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.coin_name.as_ref() {
my_size += ::protobuf::rt::string_size(2, &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.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.coin_name.as_ref() {
os.write_string(2, &v)?;
}
if let Some(ref v) = self.multisig.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)?;
}
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() -> GetOwnershipId {
GetOwnershipId::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: &GetOwnershipId| { &m.address_n },
|m: &mut GetOwnershipId| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"coin_name",
|m: &GetOwnershipId| { &m.coin_name },
|m: &mut GetOwnershipId| { &mut m.coin_name },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MultisigRedeemScriptType>>(
"multisig",
|m: &GetOwnershipId| { &m.multisig },
|m: &mut GetOwnershipId| { &mut m.multisig },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<InputScriptType>>(
"script_type",
|m: &GetOwnershipId| { &m.script_type },
|m: &mut GetOwnershipId| { &mut m.script_type },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<GetOwnershipId>(
"GetOwnershipId",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static GetOwnershipId {
static instance: ::protobuf::rt::LazyV2<GetOwnershipId> = ::protobuf::rt::LazyV2::INIT;
instance.get(GetOwnershipId::new)
}
}
impl ::protobuf::Clear for GetOwnershipId {
fn clear(&mut self) {
self.address_n.clear();
self.coin_name.clear();
self.multisig.clear();
self.script_type = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for GetOwnershipId {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GetOwnershipId {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct OwnershipId {
ownership_id: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a OwnershipId {
fn default() -> &'a OwnershipId {
<OwnershipId as ::protobuf::Message>::default_instance()
}
}
impl OwnershipId {
pub fn new() -> OwnershipId {
::std::default::Default::default()
}
pub fn get_ownership_id(&self) -> &[u8] {
match self.ownership_id.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_ownership_id(&mut self) {
self.ownership_id.clear();
}
pub fn has_ownership_id(&self) -> bool {
self.ownership_id.is_some()
}
pub fn set_ownership_id(&mut self, v: ::std::vec::Vec<u8>) {
self.ownership_id = ::protobuf::SingularField::some(v);
}
pub fn mut_ownership_id(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.ownership_id.is_none() {
self.ownership_id.set_default();
}
self.ownership_id.as_mut().unwrap()
}
pub fn take_ownership_id(&mut self) -> ::std::vec::Vec<u8> {
self.ownership_id.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for OwnershipId {
fn is_initialized(&self) -> bool {
if self.ownership_id.is_none() {
return false;
}
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.ownership_id)?;
},
_ => {
::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.ownership_id.as_ref() {
my_size += ::protobuf::rt::bytes_size(1, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.ownership_id.as_ref() {
os.write_bytes(1, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> OwnershipId {
OwnershipId::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"ownership_id",
|m: &OwnershipId| { &m.ownership_id },
|m: &mut OwnershipId| { &mut m.ownership_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<OwnershipId>(
"OwnershipId",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static OwnershipId {
static instance: ::protobuf::rt::LazyV2<OwnershipId> = ::protobuf::rt::LazyV2::INIT;
instance.get(OwnershipId::new)
}
}
impl ::protobuf::Clear for OwnershipId {
fn clear(&mut self) {
self.ownership_id.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for OwnershipId {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for OwnershipId {
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>,
no_script_type: ::std::option::Option<bool>,
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);
}
pub fn get_no_script_type(&self) -> bool {
self.no_script_type.unwrap_or(false)
}
pub fn clear_no_script_type(&mut self) {
self.no_script_type = ::std::option::Option::None;
}
pub fn has_no_script_type(&self) -> bool {
self.no_script_type.is_some()
}
pub fn set_no_script_type(&mut self, v: bool) {
self.no_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)?
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.no_script_type = ::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.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);
}
if let Some(v) = self.no_script_type {
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<()> {
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))?;
}
if let Some(v) = self.no_script_type {
os.write_bool(5, 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 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"no_script_type",
|m: &SignMessage| { &m.no_script_type },
|m: &mut SignMessage| { &mut m.no_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.no_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 {
if self.address.is_none() {
return false;
}
if self.signature.is_none() {
return false;
}
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.address)?;
},
2 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.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 {
if self.address.is_none() {
return false;
}
if self.signature.is_none() {
return false;
}
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_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>,
version_group_id: ::std::option::Option<u32>,
timestamp: ::std::option::Option<u32>,
branch_id: ::std::option::Option<u32>,
amount_unit: ::std::option::Option<AmountUnit>,
decred_staking_ticket: ::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);
}
pub fn get_version_group_id(&self) -> u32 {
self.version_group_id.unwrap_or(0)
}
pub fn clear_version_group_id(&mut self) {
self.version_group_id = ::std::option::Option::None;
}
pub fn has_version_group_id(&self) -> bool {
self.version_group_id.is_some()
}
pub fn set_version_group_id(&mut self, v: u32) {
self.version_group_id = ::std::option::Option::Some(v);
}
pub fn get_timestamp(&self) -> u32 {
self.timestamp.unwrap_or(0)
}
pub fn clear_timestamp(&mut self) {
self.timestamp = ::std::option::Option::None;
}
pub fn has_timestamp(&self) -> bool {
self.timestamp.is_some()
}
pub fn set_timestamp(&mut self, v: u32) {
self.timestamp = ::std::option::Option::Some(v);
}
pub fn get_branch_id(&self) -> u32 {
self.branch_id.unwrap_or(0)
}
pub fn clear_branch_id(&mut self) {
self.branch_id = ::std::option::Option::None;
}
pub fn has_branch_id(&self) -> bool {
self.branch_id.is_some()
}
pub fn set_branch_id(&mut self, v: u32) {
self.branch_id = ::std::option::Option::Some(v);
}
pub fn get_amount_unit(&self) -> AmountUnit {
self.amount_unit.unwrap_or(AmountUnit::BITCOIN)
}
pub fn clear_amount_unit(&mut self) {
self.amount_unit = ::std::option::Option::None;
}
pub fn has_amount_unit(&self) -> bool {
self.amount_unit.is_some()
}
pub fn set_amount_unit(&mut self, v: AmountUnit) {
self.amount_unit = ::std::option::Option::Some(v);
}
pub fn get_decred_staking_ticket(&self) -> bool {
self.decred_staking_ticket.unwrap_or(false)
}
pub fn clear_decred_staking_ticket(&mut self) {
self.decred_staking_ticket = ::std::option::Option::None;
}
pub fn has_decred_staking_ticket(&self) -> bool {
self.decred_staking_ticket.is_some()
}
pub fn set_decred_staking_ticket(&mut self, v: bool) {
self.decred_staking_ticket = ::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);
},
8 => {
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_group_id = ::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.timestamp = ::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.branch_id = ::std::option::Option::Some(tmp);
},
11 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.amount_unit, 11, &mut self.unknown_fields)?
},
12 => {
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.decred_staking_ticket = ::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;
}
if let Some(v) = self.version_group_id {
my_size += ::protobuf::rt::value_size(8, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.timestamp {
my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.branch_id {
my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.amount_unit {
my_size += ::protobuf::rt::enum_size(11, v);
}
if let Some(v) = self.decred_staking_ticket {
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)?;
}
if let Some(v) = self.version_group_id {
os.write_uint32(8, v)?;
}
if let Some(v) = self.timestamp {
os.write_uint32(9, v)?;
}
if let Some(v) = self.branch_id {
os.write_uint32(10, v)?;
}
if let Some(v) = self.amount_unit {
os.write_enum(11, ::protobuf::ProtobufEnum::value(&v))?;
}
if let Some(v) = self.decred_staking_ticket {
os.write_bool(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() -> 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 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"version_group_id",
|m: &SignTx| { &m.version_group_id },
|m: &mut SignTx| { &mut m.version_group_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"timestamp",
|m: &SignTx| { &m.timestamp },
|m: &mut SignTx| { &mut m.timestamp },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"branch_id",
|m: &SignTx| { &m.branch_id },
|m: &mut SignTx| { &mut m.branch_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<AmountUnit>>(
"amount_unit",
|m: &SignTx| { &m.amount_unit },
|m: &mut SignTx| { &mut m.amount_unit },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"decred_staking_ticket",
|m: &SignTx| { &m.decred_staking_ticket },
|m: &mut SignTx| { &mut m.decred_staking_ticket },
));
::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.version_group_id = ::std::option::Option::None;
self.timestamp = ::std::option::Option::None;
self.branch_id = ::std::option::Option::None;
self.amount_unit = ::std::option::Option::None;
self.decred_staking_ticket = ::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,
TXORIGINPUT = 5,
TXORIGOUTPUT = 6,
}
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),
5 => ::std::option::Option::Some(TxRequest_RequestType::TXORIGINPUT),
6 => ::std::option::Option::Some(TxRequest_RequestType::TXORIGOUTPUT),
_ => ::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,
TxRequest_RequestType::TXORIGINPUT,
TxRequest_RequestType::TXORIGOUTPUT,
];
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>,
version_group_id: ::std::option::Option<u32>,
timestamp: ::std::option::Option<u32>,
branch_id: ::std::option::Option<u32>,
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);
}
pub fn get_version_group_id(&self) -> u32 {
self.version_group_id.unwrap_or(0)
}
pub fn clear_version_group_id(&mut self) {
self.version_group_id = ::std::option::Option::None;
}
pub fn has_version_group_id(&self) -> bool {
self.version_group_id.is_some()
}
pub fn set_version_group_id(&mut self, v: u32) {
self.version_group_id = ::std::option::Option::Some(v);
}
pub fn get_timestamp(&self) -> u32 {
self.timestamp.unwrap_or(0)
}
pub fn clear_timestamp(&mut self) {
self.timestamp = ::std::option::Option::None;
}
pub fn has_timestamp(&self) -> bool {
self.timestamp.is_some()
}
pub fn set_timestamp(&mut self, v: u32) {
self.timestamp = ::std::option::Option::Some(v);
}
pub fn get_branch_id(&self) -> u32 {
self.branch_id.unwrap_or(0)
}
pub fn clear_branch_id(&mut self) {
self.branch_id = ::std::option::Option::None;
}
pub fn has_branch_id(&self) -> bool {
self.branch_id.is_some()
}
pub fn set_branch_id(&mut self, v: u32) {
self.branch_id = ::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);
},
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.version_group_id = ::std::option::Option::Some(tmp);
},
13 => {
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.timestamp = ::std::option::Option::Some(tmp);
},
14 => {
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.branch_id = ::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;
}
if let Some(v) = self.version_group_id {
my_size += ::protobuf::rt::value_size(12, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.timestamp {
my_size += ::protobuf::rt::value_size(13, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.branch_id {
my_size += ::protobuf::rt::value_size(14, 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.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)?;
}
if let Some(v) = self.version_group_id {
os.write_uint32(12, v)?;
}
if let Some(v) = self.timestamp {
os.write_uint32(13, v)?;
}
if let Some(v) = self.branch_id {
os.write_uint32(14, 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 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"version_group_id",
|m: &TxAck_TransactionType| { &m.version_group_id },
|m: &mut TxAck_TransactionType| { &mut m.version_group_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"timestamp",
|m: &TxAck_TransactionType| { &m.timestamp },
|m: &mut TxAck_TransactionType| { &mut m.timestamp },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"branch_id",
|m: &TxAck_TransactionType| { &m.branch_id },
|m: &mut TxAck_TransactionType| { &mut m.branch_id },
));
::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.version_group_id = ::std::option::Option::None;
self.timestamp = ::std::option::Option::None;
self.branch_id = ::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>,
witness: ::protobuf::SingularField<::std::vec::Vec<u8>>,
ownership_proof: ::protobuf::SingularField<::std::vec::Vec<u8>>,
commitment_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
orig_hash: ::protobuf::SingularField<::std::vec::Vec<u8>>,
orig_index: ::std::option::Option<u32>,
decred_staking_spend: ::std::option::Option<DecredStakingSpendType>,
script_pubkey: ::protobuf::SingularField<::std::vec::Vec<u8>>,
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_witness(&self) -> &[u8] {
match self.witness.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_witness(&mut self) {
self.witness.clear();
}
pub fn has_witness(&self) -> bool {
self.witness.is_some()
}
pub fn set_witness(&mut self, v: ::std::vec::Vec<u8>) {
self.witness = ::protobuf::SingularField::some(v);
}
pub fn mut_witness(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.witness.is_none() {
self.witness.set_default();
}
self.witness.as_mut().unwrap()
}
pub fn take_witness(&mut self) -> ::std::vec::Vec<u8> {
self.witness.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_ownership_proof(&self) -> &[u8] {
match self.ownership_proof.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_ownership_proof(&mut self) {
self.ownership_proof.clear();
}
pub fn has_ownership_proof(&self) -> bool {
self.ownership_proof.is_some()
}
pub fn set_ownership_proof(&mut self, v: ::std::vec::Vec<u8>) {
self.ownership_proof = ::protobuf::SingularField::some(v);
}
pub fn mut_ownership_proof(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.ownership_proof.is_none() {
self.ownership_proof.set_default();
}
self.ownership_proof.as_mut().unwrap()
}
pub fn take_ownership_proof(&mut self) -> ::std::vec::Vec<u8> {
self.ownership_proof.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_commitment_data(&self) -> &[u8] {
match self.commitment_data.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_commitment_data(&mut self) {
self.commitment_data.clear();
}
pub fn has_commitment_data(&self) -> bool {
self.commitment_data.is_some()
}
pub fn set_commitment_data(&mut self, v: ::std::vec::Vec<u8>) {
self.commitment_data = ::protobuf::SingularField::some(v);
}
pub fn mut_commitment_data(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.commitment_data.is_none() {
self.commitment_data.set_default();
}
self.commitment_data.as_mut().unwrap()
}
pub fn take_commitment_data(&mut self) -> ::std::vec::Vec<u8> {
self.commitment_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_orig_hash(&self) -> &[u8] {
match self.orig_hash.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_orig_hash(&mut self) {
self.orig_hash.clear();
}
pub fn has_orig_hash(&self) -> bool {
self.orig_hash.is_some()
}
pub fn set_orig_hash(&mut self, v: ::std::vec::Vec<u8>) {
self.orig_hash = ::protobuf::SingularField::some(v);
}
pub fn mut_orig_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.orig_hash.is_none() {
self.orig_hash.set_default();
}
self.orig_hash.as_mut().unwrap()
}
pub fn take_orig_hash(&mut self) -> ::std::vec::Vec<u8> {
self.orig_hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_orig_index(&self) -> u32 {
self.orig_index.unwrap_or(0)
}
pub fn clear_orig_index(&mut self) {
self.orig_index = ::std::option::Option::None;
}
pub fn has_orig_index(&self) -> bool {
self.orig_index.is_some()
}
pub fn set_orig_index(&mut self, v: u32) {
self.orig_index = ::std::option::Option::Some(v);
}
pub fn get_decred_staking_spend(&self) -> DecredStakingSpendType {
self.decred_staking_spend.unwrap_or(DecredStakingSpendType::SSGen)
}
pub fn clear_decred_staking_spend(&mut self) {
self.decred_staking_spend = ::std::option::Option::None;
}
pub fn has_decred_staking_spend(&self) -> bool {
self.decred_staking_spend.is_some()
}
pub fn set_decred_staking_spend(&mut self, v: DecredStakingSpendType) {
self.decred_staking_spend = ::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())
}
}
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);
},
13 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.witness)?;
},
14 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.ownership_proof)?;
},
15 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.commitment_data)?;
},
16 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.orig_hash)?;
},
17 => {
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.orig_index = ::std::option::Option::Some(tmp);
},
18 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.decred_staking_spend, 18, &mut self.unknown_fields)?
},
19 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.script_pubkey)?;
},
_ => {
::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(ref v) = self.witness.as_ref() {
my_size += ::protobuf::rt::bytes_size(13, &v);
}
if let Some(ref v) = self.ownership_proof.as_ref() {
my_size += ::protobuf::rt::bytes_size(14, &v);
}
if let Some(ref v) = self.commitment_data.as_ref() {
my_size += ::protobuf::rt::bytes_size(15, &v);
}
if let Some(ref v) = self.orig_hash.as_ref() {
my_size += ::protobuf::rt::bytes_size(16, &v);
}
if let Some(v) = self.orig_index {
my_size += ::protobuf::rt::value_size(17, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.decred_staking_spend {
my_size += ::protobuf::rt::enum_size(18, v);
}
if let Some(ref v) = self.script_pubkey.as_ref() {
my_size += ::protobuf::rt::bytes_size(19, &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.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(ref v) = self.witness.as_ref() {
os.write_bytes(13, &v)?;
}
if let Some(ref v) = self.ownership_proof.as_ref() {
os.write_bytes(14, &v)?;
}
if let Some(ref v) = self.commitment_data.as_ref() {
os.write_bytes(15, &v)?;
}
if let Some(ref v) = self.orig_hash.as_ref() {
os.write_bytes(16, &v)?;
}
if let Some(v) = self.orig_index {
os.write_uint32(17, v)?;
}
if let Some(v) = self.decred_staking_spend {
os.write_enum(18, ::protobuf::ProtobufEnum::value(&v))?;
}
if let Some(ref v) = self.script_pubkey.as_ref() {
os.write_bytes(19, &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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"witness",
|m: &TxAck_TransactionType_TxInputType| { &m.witness },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.witness },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"ownership_proof",
|m: &TxAck_TransactionType_TxInputType| { &m.ownership_proof },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.ownership_proof },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"commitment_data",
|m: &TxAck_TransactionType_TxInputType| { &m.commitment_data },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.commitment_data },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"orig_hash",
|m: &TxAck_TransactionType_TxInputType| { &m.orig_hash },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.orig_hash },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"orig_index",
|m: &TxAck_TransactionType_TxInputType| { &m.orig_index },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.orig_index },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<DecredStakingSpendType>>(
"decred_staking_spend",
|m: &TxAck_TransactionType_TxInputType| { &m.decred_staking_spend },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.decred_staking_spend },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"script_pubkey",
|m: &TxAck_TransactionType_TxInputType| { &m.script_pubkey },
|m: &mut TxAck_TransactionType_TxInputType| { &mut m.script_pubkey },
));
::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.witness.clear();
self.ownership_proof.clear();
self.commitment_data.clear();
self.orig_hash.clear();
self.orig_index = ::std::option::Option::None;
self.decred_staking_spend = ::std::option::Option::None;
self.script_pubkey.clear();
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<OutputScriptType>,
pub multisig: ::protobuf::SingularPtrField<MultisigRedeemScriptType>,
op_return_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
orig_hash: ::protobuf::SingularField<::std::vec::Vec<u8>>,
orig_index: ::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) -> OutputScriptType {
self.script_type.unwrap_or(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: 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_orig_hash(&self) -> &[u8] {
match self.orig_hash.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_orig_hash(&mut self) {
self.orig_hash.clear();
}
pub fn has_orig_hash(&self) -> bool {
self.orig_hash.is_some()
}
pub fn set_orig_hash(&mut self, v: ::std::vec::Vec<u8>) {
self.orig_hash = ::protobuf::SingularField::some(v);
}
pub fn mut_orig_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.orig_hash.is_none() {
self.orig_hash.set_default();
}
self.orig_hash.as_mut().unwrap()
}
pub fn take_orig_hash(&mut self) -> ::std::vec::Vec<u8> {
self.orig_hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_orig_index(&self) -> u32 {
self.orig_index.unwrap_or(0)
}
pub fn clear_orig_index(&mut self) {
self.orig_index = ::std::option::Option::None;
}
pub fn has_orig_index(&self) -> bool {
self.orig_index.is_some()
}
pub fn set_orig_index(&mut self, v: u32) {
self.orig_index = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TxAck_TransactionType_TxOutputType {
fn is_initialized(&self) -> bool {
if self.amount.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)?;
},
10 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.orig_hash)?;
},
11 => {
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.orig_index = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[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(ref v) = self.orig_hash.as_ref() {
my_size += ::protobuf::rt::bytes_size(10, &v);
}
if let Some(v) = self.orig_index {
my_size += ::protobuf::rt::value_size(11, 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(ref v) = self.orig_hash.as_ref() {
os.write_bytes(10, &v)?;
}
if let Some(v) = self.orig_index {
os.write_uint32(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_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<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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"orig_hash",
|m: &TxAck_TransactionType_TxOutputType| { &m.orig_hash },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.orig_hash },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"orig_index",
|m: &TxAck_TransactionType_TxOutputType| { &m.orig_index },
|m: &mut TxAck_TransactionType_TxOutputType| { &mut m.orig_index },
));
::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.orig_hash.clear();
self.orig_index = ::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(PartialEq,Clone,Default)]
pub struct TxInput {
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>,
witness: ::protobuf::SingularField<::std::vec::Vec<u8>>,
ownership_proof: ::protobuf::SingularField<::std::vec::Vec<u8>>,
commitment_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
orig_hash: ::protobuf::SingularField<::std::vec::Vec<u8>>,
orig_index: ::std::option::Option<u32>,
decred_staking_spend: ::std::option::Option<DecredStakingSpendType>,
script_pubkey: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxInput {
fn default() -> &'a TxInput {
<TxInput as ::protobuf::Message>::default_instance()
}
}
impl TxInput {
pub fn new() -> TxInput {
::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_witness(&self) -> &[u8] {
match self.witness.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_witness(&mut self) {
self.witness.clear();
}
pub fn has_witness(&self) -> bool {
self.witness.is_some()
}
pub fn set_witness(&mut self, v: ::std::vec::Vec<u8>) {
self.witness = ::protobuf::SingularField::some(v);
}
pub fn mut_witness(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.witness.is_none() {
self.witness.set_default();
}
self.witness.as_mut().unwrap()
}
pub fn take_witness(&mut self) -> ::std::vec::Vec<u8> {
self.witness.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_ownership_proof(&self) -> &[u8] {
match self.ownership_proof.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_ownership_proof(&mut self) {
self.ownership_proof.clear();
}
pub fn has_ownership_proof(&self) -> bool {
self.ownership_proof.is_some()
}
pub fn set_ownership_proof(&mut self, v: ::std::vec::Vec<u8>) {
self.ownership_proof = ::protobuf::SingularField::some(v);
}
pub fn mut_ownership_proof(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.ownership_proof.is_none() {
self.ownership_proof.set_default();
}
self.ownership_proof.as_mut().unwrap()
}
pub fn take_ownership_proof(&mut self) -> ::std::vec::Vec<u8> {
self.ownership_proof.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_commitment_data(&self) -> &[u8] {
match self.commitment_data.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_commitment_data(&mut self) {
self.commitment_data.clear();
}
pub fn has_commitment_data(&self) -> bool {
self.commitment_data.is_some()
}
pub fn set_commitment_data(&mut self, v: ::std::vec::Vec<u8>) {
self.commitment_data = ::protobuf::SingularField::some(v);
}
pub fn mut_commitment_data(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.commitment_data.is_none() {
self.commitment_data.set_default();
}
self.commitment_data.as_mut().unwrap()
}
pub fn take_commitment_data(&mut self) -> ::std::vec::Vec<u8> {
self.commitment_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_orig_hash(&self) -> &[u8] {
match self.orig_hash.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_orig_hash(&mut self) {
self.orig_hash.clear();
}
pub fn has_orig_hash(&self) -> bool {
self.orig_hash.is_some()
}
pub fn set_orig_hash(&mut self, v: ::std::vec::Vec<u8>) {
self.orig_hash = ::protobuf::SingularField::some(v);
}
pub fn mut_orig_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.orig_hash.is_none() {
self.orig_hash.set_default();
}
self.orig_hash.as_mut().unwrap()
}
pub fn take_orig_hash(&mut self) -> ::std::vec::Vec<u8> {
self.orig_hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_orig_index(&self) -> u32 {
self.orig_index.unwrap_or(0)
}
pub fn clear_orig_index(&mut self) {
self.orig_index = ::std::option::Option::None;
}
pub fn has_orig_index(&self) -> bool {
self.orig_index.is_some()
}
pub fn set_orig_index(&mut self, v: u32) {
self.orig_index = ::std::option::Option::Some(v);
}
pub fn get_decred_staking_spend(&self) -> DecredStakingSpendType {
self.decred_staking_spend.unwrap_or(DecredStakingSpendType::SSGen)
}
pub fn clear_decred_staking_spend(&mut self) {
self.decred_staking_spend = ::std::option::Option::None;
}
pub fn has_decred_staking_spend(&self) -> bool {
self.decred_staking_spend.is_some()
}
pub fn set_decred_staking_spend(&mut self, v: DecredStakingSpendType) {
self.decred_staking_spend = ::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())
}
}
impl ::protobuf::Message for TxInput {
fn is_initialized(&self) -> bool {
if self.prev_hash.is_none() {
return false;
}
if self.prev_index.is_none() {
return false;
}
if self.amount.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);
},
13 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.witness)?;
},
14 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.ownership_proof)?;
},
15 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.commitment_data)?;
},
16 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.orig_hash)?;
},
17 => {
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.orig_index = ::std::option::Option::Some(tmp);
},
18 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.decred_staking_spend, 18, &mut self.unknown_fields)?
},
19 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.script_pubkey)?;
},
_ => {
::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(ref v) = self.witness.as_ref() {
my_size += ::protobuf::rt::bytes_size(13, &v);
}
if let Some(ref v) = self.ownership_proof.as_ref() {
my_size += ::protobuf::rt::bytes_size(14, &v);
}
if let Some(ref v) = self.commitment_data.as_ref() {
my_size += ::protobuf::rt::bytes_size(15, &v);
}
if let Some(ref v) = self.orig_hash.as_ref() {
my_size += ::protobuf::rt::bytes_size(16, &v);
}
if let Some(v) = self.orig_index {
my_size += ::protobuf::rt::value_size(17, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.decred_staking_spend {
my_size += ::protobuf::rt::enum_size(18, v);
}
if let Some(ref v) = self.script_pubkey.as_ref() {
my_size += ::protobuf::rt::bytes_size(19, &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.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(ref v) = self.witness.as_ref() {
os.write_bytes(13, &v)?;
}
if let Some(ref v) = self.ownership_proof.as_ref() {
os.write_bytes(14, &v)?;
}
if let Some(ref v) = self.commitment_data.as_ref() {
os.write_bytes(15, &v)?;
}
if let Some(ref v) = self.orig_hash.as_ref() {
os.write_bytes(16, &v)?;
}
if let Some(v) = self.orig_index {
os.write_uint32(17, v)?;
}
if let Some(v) = self.decred_staking_spend {
os.write_enum(18, ::protobuf::ProtobufEnum::value(&v))?;
}
if let Some(ref v) = self.script_pubkey.as_ref() {
os.write_bytes(19, &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() -> TxInput {
TxInput::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: &TxInput| { &m.address_n },
|m: &mut TxInput| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"prev_hash",
|m: &TxInput| { &m.prev_hash },
|m: &mut TxInput| { &mut m.prev_hash },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"prev_index",
|m: &TxInput| { &m.prev_index },
|m: &mut TxInput| { &mut m.prev_index },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"script_sig",
|m: &TxInput| { &m.script_sig },
|m: &mut TxInput| { &mut m.script_sig },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"sequence",
|m: &TxInput| { &m.sequence },
|m: &mut TxInput| { &mut m.sequence },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<InputScriptType>>(
"script_type",
|m: &TxInput| { &m.script_type },
|m: &mut TxInput| { &mut m.script_type },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MultisigRedeemScriptType>>(
"multisig",
|m: &TxInput| { &m.multisig },
|m: &mut TxInput| { &mut m.multisig },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"amount",
|m: &TxInput| { &m.amount },
|m: &mut TxInput| { &mut m.amount },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"decred_tree",
|m: &TxInput| { &m.decred_tree },
|m: &mut TxInput| { &mut m.decred_tree },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"witness",
|m: &TxInput| { &m.witness },
|m: &mut TxInput| { &mut m.witness },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"ownership_proof",
|m: &TxInput| { &m.ownership_proof },
|m: &mut TxInput| { &mut m.ownership_proof },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"commitment_data",
|m: &TxInput| { &m.commitment_data },
|m: &mut TxInput| { &mut m.commitment_data },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"orig_hash",
|m: &TxInput| { &m.orig_hash },
|m: &mut TxInput| { &mut m.orig_hash },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"orig_index",
|m: &TxInput| { &m.orig_index },
|m: &mut TxInput| { &mut m.orig_index },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<DecredStakingSpendType>>(
"decred_staking_spend",
|m: &TxInput| { &m.decred_staking_spend },
|m: &mut TxInput| { &mut m.decred_staking_spend },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"script_pubkey",
|m: &TxInput| { &m.script_pubkey },
|m: &mut TxInput| { &mut m.script_pubkey },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxInput>(
"TxInput",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxInput {
static instance: ::protobuf::rt::LazyV2<TxInput> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxInput::new)
}
}
impl ::protobuf::Clear for TxInput {
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.witness.clear();
self.ownership_proof.clear();
self.commitment_data.clear();
self.orig_hash.clear();
self.orig_index = ::std::option::Option::None;
self.decred_staking_spend = ::std::option::Option::None;
self.script_pubkey.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxInput {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxInput {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxOutput {
address: ::protobuf::SingularField<::std::string::String>,
pub address_n: ::std::vec::Vec<u32>,
amount: ::std::option::Option<u64>,
script_type: ::std::option::Option<OutputScriptType>,
pub multisig: ::protobuf::SingularPtrField<MultisigRedeemScriptType>,
op_return_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
orig_hash: ::protobuf::SingularField<::std::vec::Vec<u8>>,
orig_index: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxOutput {
fn default() -> &'a TxOutput {
<TxOutput as ::protobuf::Message>::default_instance()
}
}
impl TxOutput {
pub fn new() -> TxOutput {
::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) -> OutputScriptType {
self.script_type.unwrap_or(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: 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_orig_hash(&self) -> &[u8] {
match self.orig_hash.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_orig_hash(&mut self) {
self.orig_hash.clear();
}
pub fn has_orig_hash(&self) -> bool {
self.orig_hash.is_some()
}
pub fn set_orig_hash(&mut self, v: ::std::vec::Vec<u8>) {
self.orig_hash = ::protobuf::SingularField::some(v);
}
pub fn mut_orig_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.orig_hash.is_none() {
self.orig_hash.set_default();
}
self.orig_hash.as_mut().unwrap()
}
pub fn take_orig_hash(&mut self) -> ::std::vec::Vec<u8> {
self.orig_hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_orig_index(&self) -> u32 {
self.orig_index.unwrap_or(0)
}
pub fn clear_orig_index(&mut self) {
self.orig_index = ::std::option::Option::None;
}
pub fn has_orig_index(&self) -> bool {
self.orig_index.is_some()
}
pub fn set_orig_index(&mut self, v: u32) {
self.orig_index = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TxOutput {
fn is_initialized(&self) -> bool {
if self.amount.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)?;
},
10 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.orig_hash)?;
},
11 => {
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.orig_index = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[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(ref v) = self.orig_hash.as_ref() {
my_size += ::protobuf::rt::bytes_size(10, &v);
}
if let Some(v) = self.orig_index {
my_size += ::protobuf::rt::value_size(11, 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(ref v) = self.orig_hash.as_ref() {
os.write_bytes(10, &v)?;
}
if let Some(v) = self.orig_index {
os.write_uint32(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() -> TxOutput {
TxOutput::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: &TxOutput| { &m.address },
|m: &mut TxOutput| { &mut m.address },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"address_n",
|m: &TxOutput| { &m.address_n },
|m: &mut TxOutput| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"amount",
|m: &TxOutput| { &m.amount },
|m: &mut TxOutput| { &mut m.amount },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<OutputScriptType>>(
"script_type",
|m: &TxOutput| { &m.script_type },
|m: &mut TxOutput| { &mut m.script_type },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MultisigRedeemScriptType>>(
"multisig",
|m: &TxOutput| { &m.multisig },
|m: &mut TxOutput| { &mut m.multisig },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"op_return_data",
|m: &TxOutput| { &m.op_return_data },
|m: &mut TxOutput| { &mut m.op_return_data },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"orig_hash",
|m: &TxOutput| { &m.orig_hash },
|m: &mut TxOutput| { &mut m.orig_hash },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"orig_index",
|m: &TxOutput| { &m.orig_index },
|m: &mut TxOutput| { &mut m.orig_index },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxOutput>(
"TxOutput",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxOutput {
static instance: ::protobuf::rt::LazyV2<TxOutput> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxOutput::new)
}
}
impl ::protobuf::Clear for TxOutput {
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.orig_hash.clear();
self.orig_index = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxOutput {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxOutput {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PrevTx {
version: ::std::option::Option<u32>,
lock_time: ::std::option::Option<u32>,
inputs_count: ::std::option::Option<u32>,
outputs_count: ::std::option::Option<u32>,
extra_data_len: ::std::option::Option<u32>,
expiry: ::std::option::Option<u32>,
version_group_id: ::std::option::Option<u32>,
timestamp: ::std::option::Option<u32>,
branch_id: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PrevTx {
fn default() -> &'a PrevTx {
<PrevTx as ::protobuf::Message>::default_instance()
}
}
impl PrevTx {
pub fn new() -> PrevTx {
::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_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_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_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_extra_data_len(&self) -> u32 {
self.extra_data_len.unwrap_or(0u32)
}
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_version_group_id(&self) -> u32 {
self.version_group_id.unwrap_or(0)
}
pub fn clear_version_group_id(&mut self) {
self.version_group_id = ::std::option::Option::None;
}
pub fn has_version_group_id(&self) -> bool {
self.version_group_id.is_some()
}
pub fn set_version_group_id(&mut self, v: u32) {
self.version_group_id = ::std::option::Option::Some(v);
}
pub fn get_timestamp(&self) -> u32 {
self.timestamp.unwrap_or(0)
}
pub fn clear_timestamp(&mut self) {
self.timestamp = ::std::option::Option::None;
}
pub fn has_timestamp(&self) -> bool {
self.timestamp.is_some()
}
pub fn set_timestamp(&mut self, v: u32) {
self.timestamp = ::std::option::Option::Some(v);
}
pub fn get_branch_id(&self) -> u32 {
self.branch_id.unwrap_or(0)
}
pub fn clear_branch_id(&mut self) {
self.branch_id = ::std::option::Option::None;
}
pub fn has_branch_id(&self) -> bool {
self.branch_id.is_some()
}
pub fn set_branch_id(&mut self, v: u32) {
self.branch_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for PrevTx {
fn is_initialized(&self) -> bool {
if self.version.is_none() {
return false;
}
if self.lock_time.is_none() {
return false;
}
if self.inputs_count.is_none() {
return false;
}
if self.outputs_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.version = ::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.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.inputs_count = ::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_count = ::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.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);
},
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.version_group_id = ::std::option::Option::Some(tmp);
},
13 => {
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.timestamp = ::std::option::Option::Some(tmp);
},
14 => {
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.branch_id = ::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);
}
if let Some(v) = self.lock_time {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.inputs_count {
my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.outputs_count {
my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
}
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.version_group_id {
my_size += ::protobuf::rt::value_size(12, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.timestamp {
my_size += ::protobuf::rt::value_size(13, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.branch_id {
my_size += ::protobuf::rt::value_size(14, 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.version {
os.write_uint32(1, v)?;
}
if let Some(v) = self.lock_time {
os.write_uint32(4, v)?;
}
if let Some(v) = self.inputs_count {
os.write_uint32(6, v)?;
}
if let Some(v) = self.outputs_count {
os.write_uint32(7, 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.version_group_id {
os.write_uint32(12, v)?;
}
if let Some(v) = self.timestamp {
os.write_uint32(13, v)?;
}
if let Some(v) = self.branch_id {
os.write_uint32(14, 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() -> PrevTx {
PrevTx::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: &PrevTx| { &m.version },
|m: &mut PrevTx| { &mut m.version },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"lock_time",
|m: &PrevTx| { &m.lock_time },
|m: &mut PrevTx| { &mut m.lock_time },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"inputs_count",
|m: &PrevTx| { &m.inputs_count },
|m: &mut PrevTx| { &mut m.inputs_count },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"outputs_count",
|m: &PrevTx| { &m.outputs_count },
|m: &mut PrevTx| { &mut m.outputs_count },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"extra_data_len",
|m: &PrevTx| { &m.extra_data_len },
|m: &mut PrevTx| { &mut m.extra_data_len },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"expiry",
|m: &PrevTx| { &m.expiry },
|m: &mut PrevTx| { &mut m.expiry },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"version_group_id",
|m: &PrevTx| { &m.version_group_id },
|m: &mut PrevTx| { &mut m.version_group_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"timestamp",
|m: &PrevTx| { &m.timestamp },
|m: &mut PrevTx| { &mut m.timestamp },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"branch_id",
|m: &PrevTx| { &m.branch_id },
|m: &mut PrevTx| { &mut m.branch_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<PrevTx>(
"PrevTx",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static PrevTx {
static instance: ::protobuf::rt::LazyV2<PrevTx> = ::protobuf::rt::LazyV2::INIT;
instance.get(PrevTx::new)
}
}
impl ::protobuf::Clear for PrevTx {
fn clear(&mut self) {
self.version = ::std::option::Option::None;
self.lock_time = ::std::option::Option::None;
self.inputs_count = ::std::option::Option::None;
self.outputs_count = ::std::option::Option::None;
self.extra_data_len = ::std::option::Option::None;
self.expiry = ::std::option::Option::None;
self.version_group_id = ::std::option::Option::None;
self.timestamp = ::std::option::Option::None;
self.branch_id = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for PrevTx {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PrevTx {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PrevInput {
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>,
decred_tree: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PrevInput {
fn default() -> &'a PrevInput {
<PrevInput as ::protobuf::Message>::default_instance()
}
}
impl PrevInput {
pub fn new() -> PrevInput {
::std::default::Default::default()
}
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(0)
}
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_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);
}
}
impl ::protobuf::Message for PrevInput {
fn is_initialized(&self) -> bool {
if self.prev_hash.is_none() {
return false;
}
if self.prev_index.is_none() {
return false;
}
if self.script_sig.is_none() {
return false;
}
if self.sequence.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 {
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);
},
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);
},
_ => {
::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.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.decred_tree {
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.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.decred_tree {
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() -> PrevInput {
PrevInput::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"prev_hash",
|m: &PrevInput| { &m.prev_hash },
|m: &mut PrevInput| { &mut m.prev_hash },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"prev_index",
|m: &PrevInput| { &m.prev_index },
|m: &mut PrevInput| { &mut m.prev_index },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"script_sig",
|m: &PrevInput| { &m.script_sig },
|m: &mut PrevInput| { &mut m.script_sig },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"sequence",
|m: &PrevInput| { &m.sequence },
|m: &mut PrevInput| { &mut m.sequence },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"decred_tree",
|m: &PrevInput| { &m.decred_tree },
|m: &mut PrevInput| { &mut m.decred_tree },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<PrevInput>(
"PrevInput",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static PrevInput {
static instance: ::protobuf::rt::LazyV2<PrevInput> = ::protobuf::rt::LazyV2::INIT;
instance.get(PrevInput::new)
}
}
impl ::protobuf::Clear for PrevInput {
fn clear(&mut self) {
self.prev_hash.clear();
self.prev_index = ::std::option::Option::None;
self.script_sig.clear();
self.sequence = ::std::option::Option::None;
self.decred_tree = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for PrevInput {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PrevInput {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PrevOutput {
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 PrevOutput {
fn default() -> &'a PrevOutput {
<PrevOutput as ::protobuf::Message>::default_instance()
}
}
impl PrevOutput {
pub fn new() -> PrevOutput {
::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 PrevOutput {
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() -> PrevOutput {
PrevOutput::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: &PrevOutput| { &m.amount },
|m: &mut PrevOutput| { &mut m.amount },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"script_pubkey",
|m: &PrevOutput| { &m.script_pubkey },
|m: &mut PrevOutput| { &mut m.script_pubkey },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"decred_script_version",
|m: &PrevOutput| { &m.decred_script_version },
|m: &mut PrevOutput| { &mut m.decred_script_version },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<PrevOutput>(
"PrevOutput",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static PrevOutput {
static instance: ::protobuf::rt::LazyV2<PrevOutput> = ::protobuf::rt::LazyV2::INIT;
instance.get(PrevOutput::new)
}
}
impl ::protobuf::Clear for PrevOutput {
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 PrevOutput {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PrevOutput {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckInput {
pub tx: ::protobuf::SingularPtrField<TxAckInput_TxAckInputWrapper>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckInput {
fn default() -> &'a TxAckInput {
<TxAckInput as ::protobuf::Message>::default_instance()
}
}
impl TxAckInput {
pub fn new() -> TxAckInput {
::std::default::Default::default()
}
pub fn get_tx(&self) -> &TxAckInput_TxAckInputWrapper {
self.tx.as_ref().unwrap_or_else(|| <TxAckInput_TxAckInputWrapper 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: TxAckInput_TxAckInputWrapper) {
self.tx = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_tx(&mut self) -> &mut TxAckInput_TxAckInputWrapper {
if self.tx.is_none() {
self.tx.set_default();
}
self.tx.as_mut().unwrap()
}
pub fn take_tx(&mut self) -> TxAckInput_TxAckInputWrapper {
self.tx.take().unwrap_or_else(|| TxAckInput_TxAckInputWrapper::new())
}
}
impl ::protobuf::Message for TxAckInput {
fn is_initialized(&self) -> bool {
if self.tx.is_none() {
return false;
}
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() -> TxAckInput {
TxAckInput::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<TxAckInput_TxAckInputWrapper>>(
"tx",
|m: &TxAckInput| { &m.tx },
|m: &mut TxAckInput| { &mut m.tx },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckInput>(
"TxAckInput",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckInput {
static instance: ::protobuf::rt::LazyV2<TxAckInput> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckInput::new)
}
}
impl ::protobuf::Clear for TxAckInput {
fn clear(&mut self) {
self.tx.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckInput {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckInput {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckInput_TxAckInputWrapper {
pub input: ::protobuf::SingularPtrField<TxInput>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckInput_TxAckInputWrapper {
fn default() -> &'a TxAckInput_TxAckInputWrapper {
<TxAckInput_TxAckInputWrapper as ::protobuf::Message>::default_instance()
}
}
impl TxAckInput_TxAckInputWrapper {
pub fn new() -> TxAckInput_TxAckInputWrapper {
::std::default::Default::default()
}
pub fn get_input(&self) -> &TxInput {
self.input.as_ref().unwrap_or_else(|| <TxInput as ::protobuf::Message>::default_instance())
}
pub fn clear_input(&mut self) {
self.input.clear();
}
pub fn has_input(&self) -> bool {
self.input.is_some()
}
pub fn set_input(&mut self, v: TxInput) {
self.input = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_input(&mut self) -> &mut TxInput {
if self.input.is_none() {
self.input.set_default();
}
self.input.as_mut().unwrap()
}
pub fn take_input(&mut self) -> TxInput {
self.input.take().unwrap_or_else(|| TxInput::new())
}
}
impl ::protobuf::Message for TxAckInput_TxAckInputWrapper {
fn is_initialized(&self) -> bool {
if self.input.is_none() {
return false;
}
for v in &self.input {
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 {
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.input)?;
},
_ => {
::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.input.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.input.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)?;
}
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() -> TxAckInput_TxAckInputWrapper {
TxAckInput_TxAckInputWrapper::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<TxInput>>(
"input",
|m: &TxAckInput_TxAckInputWrapper| { &m.input },
|m: &mut TxAckInput_TxAckInputWrapper| { &mut m.input },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckInput_TxAckInputWrapper>(
"TxAckInput.TxAckInputWrapper",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckInput_TxAckInputWrapper {
static instance: ::protobuf::rt::LazyV2<TxAckInput_TxAckInputWrapper> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckInput_TxAckInputWrapper::new)
}
}
impl ::protobuf::Clear for TxAckInput_TxAckInputWrapper {
fn clear(&mut self) {
self.input.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckInput_TxAckInputWrapper {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckInput_TxAckInputWrapper {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckOutput {
pub tx: ::protobuf::SingularPtrField<TxAckOutput_TxAckOutputWrapper>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckOutput {
fn default() -> &'a TxAckOutput {
<TxAckOutput as ::protobuf::Message>::default_instance()
}
}
impl TxAckOutput {
pub fn new() -> TxAckOutput {
::std::default::Default::default()
}
pub fn get_tx(&self) -> &TxAckOutput_TxAckOutputWrapper {
self.tx.as_ref().unwrap_or_else(|| <TxAckOutput_TxAckOutputWrapper 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: TxAckOutput_TxAckOutputWrapper) {
self.tx = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_tx(&mut self) -> &mut TxAckOutput_TxAckOutputWrapper {
if self.tx.is_none() {
self.tx.set_default();
}
self.tx.as_mut().unwrap()
}
pub fn take_tx(&mut self) -> TxAckOutput_TxAckOutputWrapper {
self.tx.take().unwrap_or_else(|| TxAckOutput_TxAckOutputWrapper::new())
}
}
impl ::protobuf::Message for TxAckOutput {
fn is_initialized(&self) -> bool {
if self.tx.is_none() {
return false;
}
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() -> TxAckOutput {
TxAckOutput::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<TxAckOutput_TxAckOutputWrapper>>(
"tx",
|m: &TxAckOutput| { &m.tx },
|m: &mut TxAckOutput| { &mut m.tx },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckOutput>(
"TxAckOutput",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckOutput {
static instance: ::protobuf::rt::LazyV2<TxAckOutput> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckOutput::new)
}
}
impl ::protobuf::Clear for TxAckOutput {
fn clear(&mut self) {
self.tx.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckOutput {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckOutput {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckOutput_TxAckOutputWrapper {
pub output: ::protobuf::SingularPtrField<TxOutput>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckOutput_TxAckOutputWrapper {
fn default() -> &'a TxAckOutput_TxAckOutputWrapper {
<TxAckOutput_TxAckOutputWrapper as ::protobuf::Message>::default_instance()
}
}
impl TxAckOutput_TxAckOutputWrapper {
pub fn new() -> TxAckOutput_TxAckOutputWrapper {
::std::default::Default::default()
}
pub fn get_output(&self) -> &TxOutput {
self.output.as_ref().unwrap_or_else(|| <TxOutput as ::protobuf::Message>::default_instance())
}
pub fn clear_output(&mut self) {
self.output.clear();
}
pub fn has_output(&self) -> bool {
self.output.is_some()
}
pub fn set_output(&mut self, v: TxOutput) {
self.output = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_output(&mut self) -> &mut TxOutput {
if self.output.is_none() {
self.output.set_default();
}
self.output.as_mut().unwrap()
}
pub fn take_output(&mut self) -> TxOutput {
self.output.take().unwrap_or_else(|| TxOutput::new())
}
}
impl ::protobuf::Message for TxAckOutput_TxAckOutputWrapper {
fn is_initialized(&self) -> bool {
if self.output.is_none() {
return false;
}
for v in &self.output {
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 {
5 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.output)?;
},
_ => {
::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.output.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.output.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)?;
}
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() -> TxAckOutput_TxAckOutputWrapper {
TxAckOutput_TxAckOutputWrapper::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<TxOutput>>(
"output",
|m: &TxAckOutput_TxAckOutputWrapper| { &m.output },
|m: &mut TxAckOutput_TxAckOutputWrapper| { &mut m.output },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckOutput_TxAckOutputWrapper>(
"TxAckOutput.TxAckOutputWrapper",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckOutput_TxAckOutputWrapper {
static instance: ::protobuf::rt::LazyV2<TxAckOutput_TxAckOutputWrapper> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckOutput_TxAckOutputWrapper::new)
}
}
impl ::protobuf::Clear for TxAckOutput_TxAckOutputWrapper {
fn clear(&mut self) {
self.output.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckOutput_TxAckOutputWrapper {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckOutput_TxAckOutputWrapper {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckPrevMeta {
pub tx: ::protobuf::SingularPtrField<PrevTx>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckPrevMeta {
fn default() -> &'a TxAckPrevMeta {
<TxAckPrevMeta as ::protobuf::Message>::default_instance()
}
}
impl TxAckPrevMeta {
pub fn new() -> TxAckPrevMeta {
::std::default::Default::default()
}
pub fn get_tx(&self) -> &PrevTx {
self.tx.as_ref().unwrap_or_else(|| <PrevTx 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: PrevTx) {
self.tx = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_tx(&mut self) -> &mut PrevTx {
if self.tx.is_none() {
self.tx.set_default();
}
self.tx.as_mut().unwrap()
}
pub fn take_tx(&mut self) -> PrevTx {
self.tx.take().unwrap_or_else(|| PrevTx::new())
}
}
impl ::protobuf::Message for TxAckPrevMeta {
fn is_initialized(&self) -> bool {
if self.tx.is_none() {
return false;
}
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() -> TxAckPrevMeta {
TxAckPrevMeta::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<PrevTx>>(
"tx",
|m: &TxAckPrevMeta| { &m.tx },
|m: &mut TxAckPrevMeta| { &mut m.tx },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckPrevMeta>(
"TxAckPrevMeta",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckPrevMeta {
static instance: ::protobuf::rt::LazyV2<TxAckPrevMeta> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckPrevMeta::new)
}
}
impl ::protobuf::Clear for TxAckPrevMeta {
fn clear(&mut self) {
self.tx.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckPrevMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckPrevMeta {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckPrevInput {
pub tx: ::protobuf::SingularPtrField<TxAckPrevInput_TxAckPrevInputWrapper>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckPrevInput {
fn default() -> &'a TxAckPrevInput {
<TxAckPrevInput as ::protobuf::Message>::default_instance()
}
}
impl TxAckPrevInput {
pub fn new() -> TxAckPrevInput {
::std::default::Default::default()
}
pub fn get_tx(&self) -> &TxAckPrevInput_TxAckPrevInputWrapper {
self.tx.as_ref().unwrap_or_else(|| <TxAckPrevInput_TxAckPrevInputWrapper 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: TxAckPrevInput_TxAckPrevInputWrapper) {
self.tx = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_tx(&mut self) -> &mut TxAckPrevInput_TxAckPrevInputWrapper {
if self.tx.is_none() {
self.tx.set_default();
}
self.tx.as_mut().unwrap()
}
pub fn take_tx(&mut self) -> TxAckPrevInput_TxAckPrevInputWrapper {
self.tx.take().unwrap_or_else(|| TxAckPrevInput_TxAckPrevInputWrapper::new())
}
}
impl ::protobuf::Message for TxAckPrevInput {
fn is_initialized(&self) -> bool {
if self.tx.is_none() {
return false;
}
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() -> TxAckPrevInput {
TxAckPrevInput::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<TxAckPrevInput_TxAckPrevInputWrapper>>(
"tx",
|m: &TxAckPrevInput| { &m.tx },
|m: &mut TxAckPrevInput| { &mut m.tx },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckPrevInput>(
"TxAckPrevInput",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckPrevInput {
static instance: ::protobuf::rt::LazyV2<TxAckPrevInput> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckPrevInput::new)
}
}
impl ::protobuf::Clear for TxAckPrevInput {
fn clear(&mut self) {
self.tx.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckPrevInput {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckPrevInput {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckPrevInput_TxAckPrevInputWrapper {
pub input: ::protobuf::SingularPtrField<PrevInput>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckPrevInput_TxAckPrevInputWrapper {
fn default() -> &'a TxAckPrevInput_TxAckPrevInputWrapper {
<TxAckPrevInput_TxAckPrevInputWrapper as ::protobuf::Message>::default_instance()
}
}
impl TxAckPrevInput_TxAckPrevInputWrapper {
pub fn new() -> TxAckPrevInput_TxAckPrevInputWrapper {
::std::default::Default::default()
}
pub fn get_input(&self) -> &PrevInput {
self.input.as_ref().unwrap_or_else(|| <PrevInput as ::protobuf::Message>::default_instance())
}
pub fn clear_input(&mut self) {
self.input.clear();
}
pub fn has_input(&self) -> bool {
self.input.is_some()
}
pub fn set_input(&mut self, v: PrevInput) {
self.input = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_input(&mut self) -> &mut PrevInput {
if self.input.is_none() {
self.input.set_default();
}
self.input.as_mut().unwrap()
}
pub fn take_input(&mut self) -> PrevInput {
self.input.take().unwrap_or_else(|| PrevInput::new())
}
}
impl ::protobuf::Message for TxAckPrevInput_TxAckPrevInputWrapper {
fn is_initialized(&self) -> bool {
if self.input.is_none() {
return false;
}
for v in &self.input {
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 {
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.input)?;
},
_ => {
::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.input.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.input.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)?;
}
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() -> TxAckPrevInput_TxAckPrevInputWrapper {
TxAckPrevInput_TxAckPrevInputWrapper::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<PrevInput>>(
"input",
|m: &TxAckPrevInput_TxAckPrevInputWrapper| { &m.input },
|m: &mut TxAckPrevInput_TxAckPrevInputWrapper| { &mut m.input },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckPrevInput_TxAckPrevInputWrapper>(
"TxAckPrevInput.TxAckPrevInputWrapper",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckPrevInput_TxAckPrevInputWrapper {
static instance: ::protobuf::rt::LazyV2<TxAckPrevInput_TxAckPrevInputWrapper> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckPrevInput_TxAckPrevInputWrapper::new)
}
}
impl ::protobuf::Clear for TxAckPrevInput_TxAckPrevInputWrapper {
fn clear(&mut self) {
self.input.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckPrevInput_TxAckPrevInputWrapper {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckPrevInput_TxAckPrevInputWrapper {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckPrevOutput {
pub tx: ::protobuf::SingularPtrField<TxAckPrevOutput_TxAckPrevOutputWrapper>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckPrevOutput {
fn default() -> &'a TxAckPrevOutput {
<TxAckPrevOutput as ::protobuf::Message>::default_instance()
}
}
impl TxAckPrevOutput {
pub fn new() -> TxAckPrevOutput {
::std::default::Default::default()
}
pub fn get_tx(&self) -> &TxAckPrevOutput_TxAckPrevOutputWrapper {
self.tx.as_ref().unwrap_or_else(|| <TxAckPrevOutput_TxAckPrevOutputWrapper 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: TxAckPrevOutput_TxAckPrevOutputWrapper) {
self.tx = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_tx(&mut self) -> &mut TxAckPrevOutput_TxAckPrevOutputWrapper {
if self.tx.is_none() {
self.tx.set_default();
}
self.tx.as_mut().unwrap()
}
pub fn take_tx(&mut self) -> TxAckPrevOutput_TxAckPrevOutputWrapper {
self.tx.take().unwrap_or_else(|| TxAckPrevOutput_TxAckPrevOutputWrapper::new())
}
}
impl ::protobuf::Message for TxAckPrevOutput {
fn is_initialized(&self) -> bool {
if self.tx.is_none() {
return false;
}
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() -> TxAckPrevOutput {
TxAckPrevOutput::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<TxAckPrevOutput_TxAckPrevOutputWrapper>>(
"tx",
|m: &TxAckPrevOutput| { &m.tx },
|m: &mut TxAckPrevOutput| { &mut m.tx },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckPrevOutput>(
"TxAckPrevOutput",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckPrevOutput {
static instance: ::protobuf::rt::LazyV2<TxAckPrevOutput> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckPrevOutput::new)
}
}
impl ::protobuf::Clear for TxAckPrevOutput {
fn clear(&mut self) {
self.tx.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckPrevOutput {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckPrevOutput {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckPrevOutput_TxAckPrevOutputWrapper {
pub output: ::protobuf::SingularPtrField<PrevOutput>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckPrevOutput_TxAckPrevOutputWrapper {
fn default() -> &'a TxAckPrevOutput_TxAckPrevOutputWrapper {
<TxAckPrevOutput_TxAckPrevOutputWrapper as ::protobuf::Message>::default_instance()
}
}
impl TxAckPrevOutput_TxAckPrevOutputWrapper {
pub fn new() -> TxAckPrevOutput_TxAckPrevOutputWrapper {
::std::default::Default::default()
}
pub fn get_output(&self) -> &PrevOutput {
self.output.as_ref().unwrap_or_else(|| <PrevOutput as ::protobuf::Message>::default_instance())
}
pub fn clear_output(&mut self) {
self.output.clear();
}
pub fn has_output(&self) -> bool {
self.output.is_some()
}
pub fn set_output(&mut self, v: PrevOutput) {
self.output = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_output(&mut self) -> &mut PrevOutput {
if self.output.is_none() {
self.output.set_default();
}
self.output.as_mut().unwrap()
}
pub fn take_output(&mut self) -> PrevOutput {
self.output.take().unwrap_or_else(|| PrevOutput::new())
}
}
impl ::protobuf::Message for TxAckPrevOutput_TxAckPrevOutputWrapper {
fn is_initialized(&self) -> bool {
if self.output.is_none() {
return false;
}
for v in &self.output {
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 {
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.output)?;
},
_ => {
::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.output.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.output.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() -> TxAckPrevOutput_TxAckPrevOutputWrapper {
TxAckPrevOutput_TxAckPrevOutputWrapper::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<PrevOutput>>(
"output",
|m: &TxAckPrevOutput_TxAckPrevOutputWrapper| { &m.output },
|m: &mut TxAckPrevOutput_TxAckPrevOutputWrapper| { &mut m.output },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckPrevOutput_TxAckPrevOutputWrapper>(
"TxAckPrevOutput.TxAckPrevOutputWrapper",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckPrevOutput_TxAckPrevOutputWrapper {
static instance: ::protobuf::rt::LazyV2<TxAckPrevOutput_TxAckPrevOutputWrapper> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckPrevOutput_TxAckPrevOutputWrapper::new)
}
}
impl ::protobuf::Clear for TxAckPrevOutput_TxAckPrevOutputWrapper {
fn clear(&mut self) {
self.output.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckPrevOutput_TxAckPrevOutputWrapper {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckPrevOutput_TxAckPrevOutputWrapper {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckPrevExtraData {
pub tx: ::protobuf::SingularPtrField<TxAckPrevExtraData_TxAckPrevExtraDataWrapper>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckPrevExtraData {
fn default() -> &'a TxAckPrevExtraData {
<TxAckPrevExtraData as ::protobuf::Message>::default_instance()
}
}
impl TxAckPrevExtraData {
pub fn new() -> TxAckPrevExtraData {
::std::default::Default::default()
}
pub fn get_tx(&self) -> &TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
self.tx.as_ref().unwrap_or_else(|| <TxAckPrevExtraData_TxAckPrevExtraDataWrapper 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: TxAckPrevExtraData_TxAckPrevExtraDataWrapper) {
self.tx = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_tx(&mut self) -> &mut TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
if self.tx.is_none() {
self.tx.set_default();
}
self.tx.as_mut().unwrap()
}
pub fn take_tx(&mut self) -> TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
self.tx.take().unwrap_or_else(|| TxAckPrevExtraData_TxAckPrevExtraDataWrapper::new())
}
}
impl ::protobuf::Message for TxAckPrevExtraData {
fn is_initialized(&self) -> bool {
if self.tx.is_none() {
return false;
}
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() -> TxAckPrevExtraData {
TxAckPrevExtraData::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<TxAckPrevExtraData_TxAckPrevExtraDataWrapper>>(
"tx",
|m: &TxAckPrevExtraData| { &m.tx },
|m: &mut TxAckPrevExtraData| { &mut m.tx },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckPrevExtraData>(
"TxAckPrevExtraData",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckPrevExtraData {
static instance: ::protobuf::rt::LazyV2<TxAckPrevExtraData> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckPrevExtraData::new)
}
}
impl ::protobuf::Clear for TxAckPrevExtraData {
fn clear(&mut self) {
self.tx.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckPrevExtraData {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckPrevExtraData {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
extra_data_chunk: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
fn default() -> &'a TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
<TxAckPrevExtraData_TxAckPrevExtraDataWrapper as ::protobuf::Message>::default_instance()
}
}
impl TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
pub fn new() -> TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
::std::default::Default::default()
}
pub fn get_extra_data_chunk(&self) -> &[u8] {
match self.extra_data_chunk.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_extra_data_chunk(&mut self) {
self.extra_data_chunk.clear();
}
pub fn has_extra_data_chunk(&self) -> bool {
self.extra_data_chunk.is_some()
}
pub fn set_extra_data_chunk(&mut self, v: ::std::vec::Vec<u8>) {
self.extra_data_chunk = ::protobuf::SingularField::some(v);
}
pub fn mut_extra_data_chunk(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.extra_data_chunk.is_none() {
self.extra_data_chunk.set_default();
}
self.extra_data_chunk.as_mut().unwrap()
}
pub fn take_extra_data_chunk(&mut self) -> ::std::vec::Vec<u8> {
self.extra_data_chunk.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
fn is_initialized(&self) -> bool {
if self.extra_data_chunk.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 {
8 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.extra_data_chunk)?;
},
_ => {
::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.extra_data_chunk.as_ref() {
my_size += ::protobuf::rt::bytes_size(8, &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.extra_data_chunk.as_ref() {
os.write_bytes(8, &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() -> TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
TxAckPrevExtraData_TxAckPrevExtraDataWrapper::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"extra_data_chunk",
|m: &TxAckPrevExtraData_TxAckPrevExtraDataWrapper| { &m.extra_data_chunk },
|m: &mut TxAckPrevExtraData_TxAckPrevExtraDataWrapper| { &mut m.extra_data_chunk },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TxAckPrevExtraData_TxAckPrevExtraDataWrapper>(
"TxAckPrevExtraData.TxAckPrevExtraDataWrapper",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
static instance: ::protobuf::rt::LazyV2<TxAckPrevExtraData_TxAckPrevExtraDataWrapper> = ::protobuf::rt::LazyV2::INIT;
instance.get(TxAckPrevExtraData_TxAckPrevExtraDataWrapper::new)
}
}
impl ::protobuf::Clear for TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
fn clear(&mut self) {
self.extra_data_chunk.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxAckPrevExtraData_TxAckPrevExtraDataWrapper {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct GetOwnershipProof {
pub address_n: ::std::vec::Vec<u32>,
coin_name: ::protobuf::SingularField<::std::string::String>,
script_type: ::std::option::Option<InputScriptType>,
pub multisig: ::protobuf::SingularPtrField<MultisigRedeemScriptType>,
user_confirmation: ::std::option::Option<bool>,
pub ownership_ids: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
commitment_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a GetOwnershipProof {
fn default() -> &'a GetOwnershipProof {
<GetOwnershipProof as ::protobuf::Message>::default_instance()
}
}
impl GetOwnershipProof {
pub fn new() -> GetOwnershipProof {
::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_script_type(&self) -> InputScriptType {
self.script_type.unwrap_or(InputScriptType::SPENDWITNESS)
}
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_user_confirmation(&self) -> bool {
self.user_confirmation.unwrap_or(false)
}
pub fn clear_user_confirmation(&mut self) {
self.user_confirmation = ::std::option::Option::None;
}
pub fn has_user_confirmation(&self) -> bool {
self.user_confirmation.is_some()
}
pub fn set_user_confirmation(&mut self, v: bool) {
self.user_confirmation = ::std::option::Option::Some(v);
}
pub fn get_ownership_ids(&self) -> &[::std::vec::Vec<u8>] {
&self.ownership_ids
}
pub fn clear_ownership_ids(&mut self) {
self.ownership_ids.clear();
}
pub fn set_ownership_ids(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.ownership_ids = v;
}
pub fn mut_ownership_ids(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.ownership_ids
}
pub fn take_ownership_ids(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.ownership_ids, ::protobuf::RepeatedField::new())
}
pub fn get_commitment_data(&self) -> &[u8] {
match self.commitment_data.as_ref() {
Some(v) => &v,
None => b"",
}
}
pub fn clear_commitment_data(&mut self) {
self.commitment_data.clear();
}
pub fn has_commitment_data(&self) -> bool {
self.commitment_data.is_some()
}
pub fn set_commitment_data(&mut self, v: ::std::vec::Vec<u8>) {
self.commitment_data = ::protobuf::SingularField::some(v);
}
pub fn mut_commitment_data(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.commitment_data.is_none() {
self.commitment_data.set_default();
}
self.commitment_data.as_mut().unwrap()
}
pub fn take_commitment_data(&mut self) -> ::std::vec::Vec<u8> {
self.commitment_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for GetOwnershipProof {
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 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.script_type, 3, &mut self.unknown_fields)?
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.multisig)?;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.user_confirmation = ::std::option::Option::Some(tmp);
},
6 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.ownership_ids)?;
},
7 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.commitment_data)?;
},
_ => {
::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.script_type {
my_size += ::protobuf::rt::enum_size(3, 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.user_confirmation {
my_size += 2;
}
for value in &self.ownership_ids {
my_size += ::protobuf::rt::bytes_size(6, &value);
};
if let Some(ref v) = self.commitment_data.as_ref() {
my_size += ::protobuf::rt::bytes_size(7, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
for v in &self.address_n {
os.write_uint32(1, *v)?;
};
if let Some(ref v) = self.coin_name.as_ref() {
os.write_string(2, &v)?;
}
if let Some(v) = self.script_type {
os.write_enum(3, ::protobuf::ProtobufEnum::value(&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.user_confirmation {
os.write_bool(5, v)?;
}
for v in &self.ownership_ids {
os.write_bytes(6, &v)?;
};
if let Some(ref v) = self.commitment_data.as_ref() {
os.write_bytes(7, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> GetOwnershipProof {
GetOwnershipProof::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: &GetOwnershipProof| { &m.address_n },
|m: &mut GetOwnershipProof| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"coin_name",
|m: &GetOwnershipProof| { &m.coin_name },
|m: &mut GetOwnershipProof| { &mut m.coin_name },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<InputScriptType>>(
"script_type",
|m: &GetOwnershipProof| { &m.script_type },
|m: &mut GetOwnershipProof| { &mut m.script_type },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MultisigRedeemScriptType>>(
"multisig",
|m: &GetOwnershipProof| { &m.multisig },
|m: &mut GetOwnershipProof| { &mut m.multisig },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"user_confirmation",
|m: &GetOwnershipProof| { &m.user_confirmation },
|m: &mut GetOwnershipProof| { &mut m.user_confirmation },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"ownership_ids",
|m: &GetOwnershipProof| { &m.ownership_ids },
|m: &mut GetOwnershipProof| { &mut m.ownership_ids },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"commitment_data",
|m: &GetOwnershipProof| { &m.commitment_data },
|m: &mut GetOwnershipProof| { &mut m.commitment_data },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<GetOwnershipProof>(
"GetOwnershipProof",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static GetOwnershipProof {
static instance: ::protobuf::rt::LazyV2<GetOwnershipProof> = ::protobuf::rt::LazyV2::INIT;
instance.get(GetOwnershipProof::new)
}
}
impl ::protobuf::Clear for GetOwnershipProof {
fn clear(&mut self) {
self.address_n.clear();
self.coin_name.clear();
self.script_type = ::std::option::Option::None;
self.multisig.clear();
self.user_confirmation = ::std::option::Option::None;
self.ownership_ids.clear();
self.commitment_data.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for GetOwnershipProof {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GetOwnershipProof {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct OwnershipProof {
ownership_proof: ::protobuf::SingularField<::std::vec::Vec<u8>>,
signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a OwnershipProof {
fn default() -> &'a OwnershipProof {
<OwnershipProof as ::protobuf::Message>::default_instance()
}
}
impl OwnershipProof {
pub fn new() -> OwnershipProof {
::std::default::Default::default()
}
pub fn get_ownership_proof(&self) -> &[u8] {
match self.ownership_proof.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_ownership_proof(&mut self) {
self.ownership_proof.clear();
}
pub fn has_ownership_proof(&self) -> bool {
self.ownership_proof.is_some()
}
pub fn set_ownership_proof(&mut self, v: ::std::vec::Vec<u8>) {
self.ownership_proof = ::protobuf::SingularField::some(v);
}
pub fn mut_ownership_proof(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.ownership_proof.is_none() {
self.ownership_proof.set_default();
}
self.ownership_proof.as_mut().unwrap()
}
pub fn take_ownership_proof(&mut self) -> ::std::vec::Vec<u8> {
self.ownership_proof.take().unwrap_or_else(|| ::std::vec::Vec::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 OwnershipProof {
fn is_initialized(&self) -> bool {
if self.ownership_proof.is_none() {
return false;
}
if self.signature.is_none() {
return false;
}
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.ownership_proof)?;
},
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.ownership_proof.as_ref() {
my_size += ::protobuf::rt::bytes_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.ownership_proof.as_ref() {
os.write_bytes(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() -> OwnershipProof {
OwnershipProof::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"ownership_proof",
|m: &OwnershipProof| { &m.ownership_proof },
|m: &mut OwnershipProof| { &mut m.ownership_proof },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"signature",
|m: &OwnershipProof| { &m.signature },
|m: &mut OwnershipProof| { &mut m.signature },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<OwnershipProof>(
"OwnershipProof",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static OwnershipProof {
static instance: ::protobuf::rt::LazyV2<OwnershipProof> = ::protobuf::rt::LazyV2::INIT;
instance.get(OwnershipProof::new)
}
}
impl ::protobuf::Clear for OwnershipProof {
fn clear(&mut self) {
self.ownership_proof.clear();
self.signature.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for OwnershipProof {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for OwnershipProof {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct AuthorizeCoinJoin {
coordinator: ::protobuf::SingularField<::std::string::String>,
max_total_fee: ::std::option::Option<u64>,
fee_per_anonymity: ::std::option::Option<u32>,
pub address_n: ::std::vec::Vec<u32>,
coin_name: ::protobuf::SingularField<::std::string::String>,
script_type: ::std::option::Option<InputScriptType>,
amount_unit: ::std::option::Option<AmountUnit>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a AuthorizeCoinJoin {
fn default() -> &'a AuthorizeCoinJoin {
<AuthorizeCoinJoin as ::protobuf::Message>::default_instance()
}
}
impl AuthorizeCoinJoin {
pub fn new() -> AuthorizeCoinJoin {
::std::default::Default::default()
}
pub fn get_coordinator(&self) -> &str {
match self.coordinator.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_coordinator(&mut self) {
self.coordinator.clear();
}
pub fn has_coordinator(&self) -> bool {
self.coordinator.is_some()
}
pub fn set_coordinator(&mut self, v: ::std::string::String) {
self.coordinator = ::protobuf::SingularField::some(v);
}
pub fn mut_coordinator(&mut self) -> &mut ::std::string::String {
if self.coordinator.is_none() {
self.coordinator.set_default();
}
self.coordinator.as_mut().unwrap()
}
pub fn take_coordinator(&mut self) -> ::std::string::String {
self.coordinator.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_max_total_fee(&self) -> u64 {
self.max_total_fee.unwrap_or(0)
}
pub fn clear_max_total_fee(&mut self) {
self.max_total_fee = ::std::option::Option::None;
}
pub fn has_max_total_fee(&self) -> bool {
self.max_total_fee.is_some()
}
pub fn set_max_total_fee(&mut self, v: u64) {
self.max_total_fee = ::std::option::Option::Some(v);
}
pub fn get_fee_per_anonymity(&self) -> u32 {
self.fee_per_anonymity.unwrap_or(0u32)
}
pub fn clear_fee_per_anonymity(&mut self) {
self.fee_per_anonymity = ::std::option::Option::None;
}
pub fn has_fee_per_anonymity(&self) -> bool {
self.fee_per_anonymity.is_some()
}
pub fn set_fee_per_anonymity(&mut self, v: u32) {
self.fee_per_anonymity = ::std::option::Option::Some(v);
}
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_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_amount_unit(&self) -> AmountUnit {
self.amount_unit.unwrap_or(AmountUnit::BITCOIN)
}
pub fn clear_amount_unit(&mut self) {
self.amount_unit = ::std::option::Option::None;
}
pub fn has_amount_unit(&self) -> bool {
self.amount_unit.is_some()
}
pub fn set_amount_unit(&mut self, v: AmountUnit) {
self.amount_unit = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for AuthorizeCoinJoin {
fn is_initialized(&self) -> bool {
if self.coordinator.is_none() {
return false;
}
if self.max_total_fee.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.coordinator)?;
},
2 => {
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.max_total_fee = ::std::option::Option::Some(tmp);
},
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.fee_per_anonymity = ::std::option::Option::Some(tmp);
},
4 => {
::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.address_n)?;
},
5 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.coin_name)?;
},
6 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.script_type, 6, &mut self.unknown_fields)?
},
11 => {
::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.amount_unit, 11, &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;
if let Some(ref v) = self.coordinator.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
if let Some(v) = self.max_total_fee {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.fee_per_anonymity {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.address_n {
my_size += ::protobuf::rt::value_size(4, *value, ::protobuf::wire_format::WireTypeVarint);
};
if let Some(ref v) = self.coin_name.as_ref() {
my_size += ::protobuf::rt::string_size(5, &v);
}
if let Some(v) = self.script_type {
my_size += ::protobuf::rt::enum_size(6, v);
}
if let Some(v) = self.amount_unit {
my_size += ::protobuf::rt::enum_size(11, 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.coordinator.as_ref() {
os.write_string(1, &v)?;
}
if let Some(v) = self.max_total_fee {
os.write_uint64(2, v)?;
}
if let Some(v) = self.fee_per_anonymity {
os.write_uint32(3, v)?;
}
for v in &self.address_n {
os.write_uint32(4, *v)?;
};
if let Some(ref v) = self.coin_name.as_ref() {
os.write_string(5, &v)?;
}
if let Some(v) = self.script_type {
os.write_enum(6, ::protobuf::ProtobufEnum::value(&v))?;
}
if let Some(v) = self.amount_unit {
os.write_enum(11, ::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() -> AuthorizeCoinJoin {
AuthorizeCoinJoin::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>(
"coordinator",
|m: &AuthorizeCoinJoin| { &m.coordinator },
|m: &mut AuthorizeCoinJoin| { &mut m.coordinator },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"max_total_fee",
|m: &AuthorizeCoinJoin| { &m.max_total_fee },
|m: &mut AuthorizeCoinJoin| { &mut m.max_total_fee },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"fee_per_anonymity",
|m: &AuthorizeCoinJoin| { &m.fee_per_anonymity },
|m: &mut AuthorizeCoinJoin| { &mut m.fee_per_anonymity },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"address_n",
|m: &AuthorizeCoinJoin| { &m.address_n },
|m: &mut AuthorizeCoinJoin| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"coin_name",
|m: &AuthorizeCoinJoin| { &m.coin_name },
|m: &mut AuthorizeCoinJoin| { &mut m.coin_name },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<InputScriptType>>(
"script_type",
|m: &AuthorizeCoinJoin| { &m.script_type },
|m: &mut AuthorizeCoinJoin| { &mut m.script_type },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<AmountUnit>>(
"amount_unit",
|m: &AuthorizeCoinJoin| { &m.amount_unit },
|m: &mut AuthorizeCoinJoin| { &mut m.amount_unit },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<AuthorizeCoinJoin>(
"AuthorizeCoinJoin",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static AuthorizeCoinJoin {
static instance: ::protobuf::rt::LazyV2<AuthorizeCoinJoin> = ::protobuf::rt::LazyV2::INIT;
instance.get(AuthorizeCoinJoin::new)
}
}
impl ::protobuf::Clear for AuthorizeCoinJoin {
fn clear(&mut self) {
self.coordinator.clear();
self.max_total_fee = ::std::option::Option::None;
self.fee_per_anonymity = ::std::option::Option::None;
self.address_n.clear();
self.coin_name.clear();
self.script_type = ::std::option::Option::None;
self.amount_unit = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for AuthorizeCoinJoin {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for AuthorizeCoinJoin {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum InputScriptType {
SPENDADDRESS = 0,
SPENDMULTISIG = 1,
EXTERNAL = 2,
SPENDWITNESS = 3,
SPENDP2SHWITNESS = 4,
SPENDTAPROOT = 5,
}
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),
5 => ::std::option::Option::Some(InputScriptType::SPENDTAPROOT),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [InputScriptType] = &[
InputScriptType::SPENDADDRESS,
InputScriptType::SPENDMULTISIG,
InputScriptType::EXTERNAL,
InputScriptType::SPENDWITNESS,
InputScriptType::SPENDP2SHWITNESS,
InputScriptType::SPENDTAPROOT,
];
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))
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum OutputScriptType {
PAYTOADDRESS = 0,
PAYTOSCRIPTHASH = 1,
PAYTOMULTISIG = 2,
PAYTOOPRETURN = 3,
PAYTOWITNESS = 4,
PAYTOP2SHWITNESS = 5,
PAYTOTAPROOT = 6,
}
impl ::protobuf::ProtobufEnum for OutputScriptType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<OutputScriptType> {
match value {
0 => ::std::option::Option::Some(OutputScriptType::PAYTOADDRESS),
1 => ::std::option::Option::Some(OutputScriptType::PAYTOSCRIPTHASH),
2 => ::std::option::Option::Some(OutputScriptType::PAYTOMULTISIG),
3 => ::std::option::Option::Some(OutputScriptType::PAYTOOPRETURN),
4 => ::std::option::Option::Some(OutputScriptType::PAYTOWITNESS),
5 => ::std::option::Option::Some(OutputScriptType::PAYTOP2SHWITNESS),
6 => ::std::option::Option::Some(OutputScriptType::PAYTOTAPROOT),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [OutputScriptType] = &[
OutputScriptType::PAYTOADDRESS,
OutputScriptType::PAYTOSCRIPTHASH,
OutputScriptType::PAYTOMULTISIG,
OutputScriptType::PAYTOOPRETURN,
OutputScriptType::PAYTOWITNESS,
OutputScriptType::PAYTOP2SHWITNESS,
OutputScriptType::PAYTOTAPROOT,
];
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::<OutputScriptType>("OutputScriptType", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for OutputScriptType {
}
impl ::std::default::Default for OutputScriptType {
fn default() -> Self {
OutputScriptType::PAYTOADDRESS
}
}
impl ::protobuf::reflect::ProtobufValue for OutputScriptType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum DecredStakingSpendType {
SSGen = 0,
SSRTX = 1,
}
impl ::protobuf::ProtobufEnum for DecredStakingSpendType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<DecredStakingSpendType> {
match value {
0 => ::std::option::Option::Some(DecredStakingSpendType::SSGen),
1 => ::std::option::Option::Some(DecredStakingSpendType::SSRTX),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [DecredStakingSpendType] = &[
DecredStakingSpendType::SSGen,
DecredStakingSpendType::SSRTX,
];
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::<DecredStakingSpendType>("DecredStakingSpendType", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for DecredStakingSpendType {
}
impl ::std::default::Default for DecredStakingSpendType {
fn default() -> Self {
DecredStakingSpendType::SSGen
}
}
impl ::protobuf::reflect::ProtobufValue for DecredStakingSpendType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum AmountUnit {
BITCOIN = 0,
MILLIBITCOIN = 1,
MICROBITCOIN = 2,
SATOSHI = 3,
}
impl ::protobuf::ProtobufEnum for AmountUnit {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<AmountUnit> {
match value {
0 => ::std::option::Option::Some(AmountUnit::BITCOIN),
1 => ::std::option::Option::Some(AmountUnit::MILLIBITCOIN),
2 => ::std::option::Option::Some(AmountUnit::MICROBITCOIN),
3 => ::std::option::Option::Some(AmountUnit::SATOSHI),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [AmountUnit] = &[
AmountUnit::BITCOIN,
AmountUnit::MILLIBITCOIN,
AmountUnit::MICROBITCOIN,
AmountUnit::SATOSHI,
];
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::<AmountUnit>("AmountUnit", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for AmountUnit {
}
impl ::std::default::Default for AmountUnit {
fn default() -> Self {
AmountUnit::BITCOIN
}
}
impl ::protobuf::reflect::ProtobufValue for AmountUnit {
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\x0eme\
ssages.proto\x1a\x15messages-common.proto\"\xeb\x02\n\x18MultisigRedeemS\
criptType\x12]\n\x07pubkeys\x18\x01\x20\x03(\x0b2C.hw.trezor.messages.bi\
tcoin.MultisigRedeemScriptType.HDNodePathTypeR\x07pubkeys\x12\x1e\n\nsig\
natures\x18\x02\x20\x03(\x0cR\nsignatures\x12\x0c\n\x01m\x18\x03\x20\x02\
(\rR\x01m\x12;\n\x05nodes\x18\x04\x20\x03(\x0b2%.hw.trezor.messages.comm\
on.HDNodeTypeR\x05nodes\x12\x1b\n\taddress_n\x18\x05\x20\x03(\rR\x08addr\
essN\x1ah\n\x0eHDNodePathType\x129\n\x04node\x18\x01\x20\x02(\x0b2%.hw.t\
rezor.messages.common.HDNodeTypeR\x04node\x12\x1b\n\taddress_n\x18\x02\
\x20\x03(\rR\x08addressN\"\xa6\x02\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\
\x0bshowDisplay\x12$\n\tcoin_name\x18\x04\x20\x01(\t:\x07BitcoinR\x08coi\
nName\x12Z\n\x0bscript_type\x18\x05\x20\x01(\x0e2+.hw.trezor.messages.bi\
tcoin.InputScriptType:\x0cSPENDADDRESSR\nscriptType\x12*\n\x11ignore_xpu\
b_magic\x18\x06\x20\x01(\x08R\x0fignoreXpubMagic\"\x85\x01\n\tPublicKey\
\x129\n\x04node\x18\x01\x20\x02(\x0b2%.hw.trezor.messages.common.HDNodeT\
ypeR\x04node\x12\x12\n\x04xpub\x18\x02\x20\x02(\tR\x04xpub\x12)\n\x10roo\
t_fingerprint\x18\x03\x20\x01(\rR\x0frootFingerprint\"\xcc\x02\n\nGetAdd\
ress\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12$\n\tcoin_n\
ame\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\x12*\n\x11ignore_xpub_mag\
ic\x18\x06\x20\x01(\x08R\x0fignoreXpubMagic\"#\n\x07Address\x12\x18\n\
\x07address\x18\x01\x20\x02(\tR\x07address\"\x81\x02\n\x0eGetOwnershipId\
\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12$\n\tcoin_name\
\x18\x02\x20\x01(\t:\x07BitcoinR\x08coinName\x12P\n\x08multisig\x18\x03\
\x20\x01(\x0b24.hw.trezor.messages.bitcoin.MultisigRedeemScriptTypeR\x08\
multisig\x12Z\n\x0bscript_type\x18\x04\x20\x01(\x0e2+.hw.trezor.messages\
.bitcoin.InputScriptType:\x0cSPENDADDRESSR\nscriptType\"0\n\x0bOwnership\
Id\x12!\n\x0cownership_id\x18\x01\x20\x02(\x0cR\x0bownershipId\"\xec\x01\
\n\x0bSignMessage\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\
\x12\x18\n\x07message\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+.hw.trezor.messages.bitcoin.InputScriptType:\x0cSPEND\
ADDRESSR\nscriptType\x12$\n\x0eno_script_type\x18\x05\x20\x01(\x08R\x0cn\
oScriptType\"J\n\x10MessageSignature\x12\x18\n\x07address\x18\x01\x20\
\x02(\tR\x07address\x12\x1c\n\tsignature\x18\x02\x20\x02(\x0cR\tsignatur\
e\"\x87\x01\n\rVerifyMessage\x12\x18\n\x07address\x18\x01\x20\x02(\tR\
\x07address\x12\x1c\n\tsignature\x18\x02\x20\x02(\x0cR\tsignature\x12\
\x18\n\x07message\x18\x03\x20\x02(\x0cR\x07message\x12$\n\tcoin_name\x18\
\x04\x20\x01(\t:\x07BitcoinR\x08coinName\"\xe5\x03\n\x06SignTx\x12#\n\ro\
utputs_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\x08coinName\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\x06expiry\x18\x06\x20\x01(\rR\x06expiry\x12&\n\x0coverwintere\
d\x18\x07\x20\x01(\x08R\x0coverwinteredB\x02\x18\x01\x12(\n\x10version_g\
roup_id\x18\x08\x20\x01(\rR\x0eversionGroupId\x12\x1c\n\ttimestamp\x18\t\
\x20\x01(\rR\ttimestamp\x12\x1b\n\tbranch_id\x18\n\x20\x01(\rR\x08branch\
Id\x12P\n\x0bamount_unit\x18\x0b\x20\x01(\x0e2&.hw.trezor.messages.bitco\
in.AmountUnit:\x07BITCOINR\namountUnit\x129\n\x15decred_staking_ticket\
\x18\x0c\x20\x01(\x08:\x05falseR\x13decredStakingTicket\"\xc1\x05\n\tTxR\
equest\x12T\n\x0crequest_type\x18\x01\x20\x01(\x0e21.hw.trezor.messages.\
bitcoin.TxRequest.RequestTypeR\x0brequestType\x12T\n\x07details\x18\x02\
\x20\x01(\x0b2:.hw.trezor.messages.bitcoin.TxRequest.TxRequestDetailsTyp\
eR\x07details\x12]\n\nserialized\x18\x03\x20\x01(\x0b2=.hw.trezor.messag\
es.bitcoin.TxRequest.TxRequestSerializedTypeR\nserialized\x1a\xa6\x01\n\
\x14TxRequestDetailsType\x12#\n\rrequest_index\x18\x01\x20\x01(\rR\x0cre\
questIndex\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_d\
ata_offset\x18\x04\x20\x01(\rR\x0fextraDataOffset\x1a\x85\x01\n\x17TxReq\
uestSerializedType\x12'\n\x0fsignature_index\x18\x01\x20\x01(\rR\x0esign\
atureIndex\x12\x1c\n\tsignature\x18\x02\x20\x01(\x0cR\tsignature\x12#\n\
\rserialized_tx\x18\x03\x20\x01(\x0cR\x0cserializedTx\"x\n\x0bRequestTyp\
e\x12\x0b\n\x07TXINPUT\x10\0\x12\x0c\n\x08TXOUTPUT\x10\x01\x12\n\n\x06TX\
META\x10\x02\x12\x0e\n\nTXFINISHED\x10\x03\x12\x0f\n\x0bTXEXTRADATA\x10\
\x04\x12\x0f\n\x0bTXORIGINPUT\x10\x05\x12\x10\n\x0cTXORIGOUTPUT\x10\x06\
\"\x98\x0f\n\x05TxAck\x12A\n\x02tx\x18\x01\x20\x01(\x0b21.hw.trezor.mess\
ages.bitcoin.TxAck.TransactionTypeR\x02tx\x1a\xc7\x0e\n\x0fTransactionTy\
pe\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\nbinOutpu\
ts\x12\x1b\n\tlock_time\x18\x04\x20\x01(\rR\x08lockTime\x12X\n\x07output\
s\x18\x05\x20\x03(\x0b2>.hw.trezor.messages.bitcoin.TxAck.TransactionTyp\
e.TxOutputTypeR\x07outputs\x12\x1d\n\ninputs_cnt\x18\x06\x20\x01(\rR\tin\
putsCnt\x12\x1f\n\x0boutputs_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\x0cextraDataLen\x12\x16\n\x06expiry\x18\n\x20\x01(\rR\
\x06expiry\x12&\n\x0coverwintered\x18\x0b\x20\x01(\x08R\x0coverwinteredB\
\x02\x18\x01\x12(\n\x10version_group_id\x18\x0c\x20\x01(\rR\x0eversionGr\
oupId\x12\x1c\n\ttimestamp\x18\r\x20\x01(\rR\ttimestamp\x12\x1b\n\tbranc\
h_id\x18\x0e\x20\x01(\rR\x08branchId\x1a\xc7\x05\n\x0bTxInputType\x12\
\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12\x1b\n\tprev_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\x08sequence\x12Z\n\
\x0bscript_type\x18\x06\x20\x01(\x0e2+.hw.trezor.messages.bitcoin.InputS\
criptType:\x0cSPENDADDRESSR\nscriptType\x12P\n\x08multisig\x18\x07\x20\
\x01(\x0b24.hw.trezor.messages.bitcoin.MultisigRedeemScriptTypeR\x08mult\
isig\x12\x16\n\x06amount\x18\x08\x20\x01(\x04R\x06amount\x12\x1f\n\x0bde\
cred_tree\x18\t\x20\x01(\rR\ndecredTree\x12\x18\n\x07witness\x18\r\x20\
\x01(\x0cR\x07witness\x12'\n\x0fownership_proof\x18\x0e\x20\x01(\x0cR\
\x0eownershipProof\x12'\n\x0fcommitment_data\x18\x0f\x20\x01(\x0cR\x0eco\
mmitmentData\x12\x1b\n\torig_hash\x18\x10\x20\x01(\x0cR\x08origHash\x12\
\x1d\n\norig_index\x18\x11\x20\x01(\rR\torigIndex\x12d\n\x14decred_staki\
ng_spend\x18\x12\x20\x01(\x0e22.hw.trezor.messages.bitcoin.DecredStaking\
SpendTypeR\x12decredStakingSpend\x12#\n\rscript_pubkey\x18\x13\x20\x01(\
\x0cR\x0cscriptPubkey\x1a\x82\x01\n\x0fTxOutputBinType\x12\x16\n\x06amou\
nt\x18\x01\x20\x02(\x04R\x06amount\x12#\n\rscript_pubkey\x18\x02\x20\x02\
(\x0cR\x0cscriptPubkey\x122\n\x15decred_script_version\x18\x03\x20\x01(\
\rR\x13decredScriptVersion\x1a\xee\x02\n\x0cTxOutputType\x12\x18\n\x07ad\
dress\x18\x01\x20\x01(\tR\x07address\x12\x1b\n\taddress_n\x18\x02\x20\
\x03(\rR\x08addressN\x12\x16\n\x06amount\x18\x03\x20\x02(\x04R\x06amount\
\x12[\n\x0bscript_type\x18\x04\x20\x01(\x0e2,.hw.trezor.messages.bitcoin\
.OutputScriptType:\x0cPAYTOADDRESSR\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\x0copReturnD\
ata\x12\x1b\n\torig_hash\x18\n\x20\x01(\x0cR\x08origHash\x12\x1d\n\norig\
_index\x18\x0b\x20\x01(\rR\torigIndex:\x02\x18\x01\"\xd5\x05\n\x07TxInpu\
t\x12\x1b\n\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12\x1b\n\tprev_h\
ash\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\tscriptS\
ig\x12&\n\x08sequence\x18\x05\x20\x01(\r:\n4294967295R\x08sequence\x12Z\
\n\x0bscript_type\x18\x06\x20\x01(\x0e2+.hw.trezor.messages.bitcoin.Inpu\
tScriptType:\x0cSPENDADDRESSR\nscriptType\x12P\n\x08multisig\x18\x07\x20\
\x01(\x0b24.hw.trezor.messages.bitcoin.MultisigRedeemScriptTypeR\x08mult\
isig\x12\x16\n\x06amount\x18\x08\x20\x02(\x04R\x06amount\x12\x1f\n\x0bde\
cred_tree\x18\t\x20\x01(\rR\ndecredTree\x12\x18\n\x07witness\x18\r\x20\
\x01(\x0cR\x07witness\x12'\n\x0fownership_proof\x18\x0e\x20\x01(\x0cR\
\x0eownershipProof\x12'\n\x0fcommitment_data\x18\x0f\x20\x01(\x0cR\x0eco\
mmitmentData\x12\x1b\n\torig_hash\x18\x10\x20\x01(\x0cR\x08origHash\x12\
\x1d\n\norig_index\x18\x11\x20\x01(\rR\torigIndex\x12d\n\x14decred_staki\
ng_spend\x18\x12\x20\x01(\x0e22.hw.trezor.messages.bitcoin.DecredStaking\
SpendTypeR\x12decredStakingSpend\x12#\n\rscript_pubkey\x18\x13\x20\x01(\
\x0cR\x0cscriptPubkeyJ\x04\x08\n\x10\x0bJ\x04\x08\x0b\x10\x0cJ\x04\x08\
\x0c\x10\r\"\xfc\x02\n\x08TxOutput\x12\x18\n\x07address\x18\x01\x20\x01(\
\tR\x07address\x12\x1b\n\taddress_n\x18\x02\x20\x03(\rR\x08addressN\x12\
\x16\n\x06amount\x18\x03\x20\x02(\x04R\x06amount\x12[\n\x0bscript_type\
\x18\x04\x20\x01(\x0e2,.hw.trezor.messages.bitcoin.OutputScriptType:\x0c\
PAYTOADDRESSR\nscriptType\x12P\n\x08multisig\x18\x05\x20\x01(\x0b24.hw.t\
rezor.messages.bitcoin.MultisigRedeemScriptTypeR\x08multisig\x12$\n\x0eo\
p_return_data\x18\x06\x20\x01(\x0cR\x0copReturnData\x12\x1b\n\torig_hash\
\x18\n\x20\x01(\x0cR\x08origHash\x12\x1d\n\norig_index\x18\x0b\x20\x01(\
\rR\torigIndexJ\x04\x08\x07\x10\x08J\x04\x08\x08\x10\tJ\x04\x08\t\x10\n\
\"\xcb\x02\n\x06PrevTx\x12\x18\n\x07version\x18\x01\x20\x02(\rR\x07versi\
on\x12\x1b\n\tlock_time\x18\x04\x20\x02(\rR\x08lockTime\x12!\n\x0cinputs\
_count\x18\x06\x20\x02(\rR\x0binputsCount\x12#\n\routputs_count\x18\x07\
\x20\x02(\rR\x0coutputsCount\x12'\n\x0eextra_data_len\x18\t\x20\x01(\r:\
\x010R\x0cextraDataLen\x12\x16\n\x06expiry\x18\n\x20\x01(\rR\x06expiry\
\x12(\n\x10version_group_id\x18\x0c\x20\x01(\rR\x0eversionGroupId\x12\
\x1c\n\ttimestamp\x18\r\x20\x01(\rR\ttimestamp\x12\x1b\n\tbranch_id\x18\
\x0e\x20\x01(\rR\x08branchIdJ\x04\x08\x02\x10\x03J\x04\x08\x03\x10\x04J\
\x04\x08\x05\x10\x06J\x04\x08\x08\x10\tJ\x04\x08\x0b\x10\x0c\"\xf7\x01\n\
\tPrevInput\x12\x1b\n\tprev_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\x02(\x0cR\tscriptSig\x12\x1a\n\x08sequence\x18\x05\x20\x02(\
\rR\x08sequence\x12\x1f\n\x0bdecred_tree\x18\t\x20\x01(\rR\ndecredTreeJ\
\x04\x08\x01\x10\x02J\x04\x08\x06\x10\x07J\x04\x08\x07\x10\x08J\x04\x08\
\x08\x10\tJ\x04\x08\n\x10\x0bJ\x04\x08\x0b\x10\x0cJ\x04\x08\x0c\x10\rJ\
\x04\x08\r\x10\x0eJ\x04\x08\x0e\x10\x0fJ\x04\x08\x0f\x10\x10J\x04\x08\
\x10\x10\x11J\x04\x08\x11\x10\x12J\x04\x08\x12\x10\x13J\x04\x08\x13\x10\
\x14\"}\n\nPrevOutput\x12\x16\n\x06amount\x18\x01\x20\x02(\x04R\x06amoun\
t\x12#\n\rscript_pubkey\x18\x02\x20\x02(\x0cR\x0cscriptPubkey\x122\n\x15\
decred_script_version\x18\x03\x20\x01(\rR\x13decredScriptVersion\"\xac\
\x01\n\nTxAckInput\x12H\n\x02tx\x18\x01\x20\x02(\x0b28.hw.trezor.message\
s.bitcoin.TxAckInput.TxAckInputWrapperR\x02tx\x1aN\n\x11TxAckInputWrappe\
r\x129\n\x05input\x18\x02\x20\x02(\x0b2#.hw.trezor.messages.bitcoin.TxIn\
putR\x05input:\x04\x90\xb2\x19\x16\"\xb3\x01\n\x0bTxAckOutput\x12J\n\x02\
tx\x18\x01\x20\x02(\x0b2:.hw.trezor.messages.bitcoin.TxAckOutput.TxAckOu\
tputWrapperR\x02tx\x1aR\n\x12TxAckOutputWrapper\x12<\n\x06output\x18\x05\
\x20\x02(\x0b2$.hw.trezor.messages.bitcoin.TxOutputR\x06output:\x04\x90\
\xb2\x19\x16\"I\n\rTxAckPrevMeta\x122\n\x02tx\x18\x01\x20\x02(\x0b2\".hw\
.trezor.messages.bitcoin.PrevTxR\x02tx:\x04\x90\xb2\x19\x16\"\xbe\x01\n\
\x0eTxAckPrevInput\x12P\n\x02tx\x18\x01\x20\x02(\x0b2@.hw.trezor.message\
s.bitcoin.TxAckPrevInput.TxAckPrevInputWrapperR\x02tx\x1aT\n\x15TxAckPre\
vInputWrapper\x12;\n\x05input\x18\x02\x20\x02(\x0b2%.hw.trezor.messages.\
bitcoin.PrevInputR\x05input:\x04\x90\xb2\x19\x16\"\xc5\x01\n\x0fTxAckPre\
vOutput\x12R\n\x02tx\x18\x01\x20\x02(\x0b2B.hw.trezor.messages.bitcoin.T\
xAckPrevOutput.TxAckPrevOutputWrapperR\x02tx\x1aX\n\x16TxAckPrevOutputWr\
apper\x12>\n\x06output\x18\x03\x20\x02(\x0b2&.hw.trezor.messages.bitcoin\
.PrevOutputR\x06output:\x04\x90\xb2\x19\x16\"\xbb\x01\n\x12TxAckPrevExtr\
aData\x12X\n\x02tx\x18\x01\x20\x02(\x0b2H.hw.trezor.messages.bitcoin.TxA\
ckPrevExtraData.TxAckPrevExtraDataWrapperR\x02tx\x1aE\n\x19TxAckPrevExtr\
aDataWrapper\x12(\n\x10extra_data_chunk\x18\x08\x20\x02(\x0cR\x0eextraDa\
taChunk:\x04\x90\xb2\x19\x16\"\x88\x03\n\x11GetOwnershipProof\x12\x1b\n\
\taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12$\n\tcoin_name\x18\x02\
\x20\x01(\t:\x07BitcoinR\x08coinName\x12Z\n\x0bscript_type\x18\x03\x20\
\x01(\x0e2+.hw.trezor.messages.bitcoin.InputScriptType:\x0cSPENDWITNESSR\
\nscriptType\x12P\n\x08multisig\x18\x04\x20\x01(\x0b24.hw.trezor.message\
s.bitcoin.MultisigRedeemScriptTypeR\x08multisig\x122\n\x11user_confirmat\
ion\x18\x05\x20\x01(\x08:\x05falseR\x10userConfirmation\x12#\n\rownershi\
p_ids\x18\x06\x20\x03(\x0cR\x0cownershipIds\x12)\n\x0fcommitment_data\
\x18\x07\x20\x01(\x0c:\0R\x0ecommitmentData\"W\n\x0eOwnershipProof\x12'\
\n\x0fownership_proof\x18\x01\x20\x02(\x0cR\x0eownershipProof\x12\x1c\n\
\tsignature\x18\x02\x20\x02(\x0cR\tsignature\"\xff\x02\n\x11AuthorizeCoi\
nJoin\x12\x20\n\x0bcoordinator\x18\x01\x20\x02(\tR\x0bcoordinator\x12\"\
\n\rmax_total_fee\x18\x02\x20\x02(\x04R\x0bmaxTotalFee\x12-\n\x11fee_per\
_anonymity\x18\x03\x20\x01(\r:\x010R\x0ffeePerAnonymity\x12\x1b\n\taddre\
ss_n\x18\x04\x20\x03(\rR\x08addressN\x12$\n\tcoin_name\x18\x05\x20\x01(\
\t:\x07BitcoinR\x08coinName\x12Z\n\x0bscript_type\x18\x06\x20\x01(\x0e2+\
.hw.trezor.messages.bitcoin.InputScriptType:\x0cSPENDADDRESSR\nscriptTyp\
e\x12P\n\x0bamount_unit\x18\x0b\x20\x01(\x0e2&.hw.trezor.messages.bitcoi\
n.AmountUnit:\x07BITCOINR\namountUnit:\x04\x88\xb2\x19\x01*~\n\x0fInputS\
criptType\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\x04\x12\x10\n\x0cSPENDTAPROOT\x10\x05*\
\x99\x01\n\x10OutputScriptType\x12\x10\n\x0cPAYTOADDRESS\x10\0\x12\x13\n\
\x0fPAYTOSCRIPTHASH\x10\x01\x12\x11\n\rPAYTOMULTISIG\x10\x02\x12\x11\n\r\
PAYTOOPRETURN\x10\x03\x12\x10\n\x0cPAYTOWITNESS\x10\x04\x12\x14\n\x10PAY\
TOP2SHWITNESS\x10\x05\x12\x10\n\x0cPAYTOTAPROOT\x10\x06*.\n\x16DecredSta\
kingSpendType\x12\t\n\x05SSGen\x10\0\x12\t\n\x05SSRTX\x10\x01*J\n\nAmoun\
tUnit\x12\x0b\n\x07BITCOIN\x10\0\x12\x10\n\x0cMILLIBITCOIN\x10\x01\x12\
\x10\n\x0cMICROBITCOIN\x10\x02\x12\x0b\n\x07SATOSHI\x10\x03B?\n#com.sato\
shilabs.trezor.lib.protobufB\x14TrezorMessageBitcoin\x80\xa6\x1d\x01J\
\xe6\xf2\x01\n\x07\x12\x05\0\0\xb7\x04\x01\n\x08\n\x01\x0c\x12\x03\0\0\
\x12\n\x08\n\x01\x02\x12\x03\x01\x08\"\n\x08\n\x01\x08\x12\x03\x04\0<\n.\
\n\x02\x08\x01\x12\x03\x04\0<\x1a#\x20Sugar\x20for\x20easier\x20handling\
\x20in\x20Java\n\n\x08\n\x01\x08\x12\x03\x05\05\n\t\n\x02\x08\x08\x12\
\x03\x05\05\n\x08\n\x01\x08\x12\x03\x07\0(\n\x0b\n\x04\x08\xe0\xd4\x03\
\x12\x03\x07\0(\n\t\n\x02\x03\0\x12\x03\t\x07\x17\n\t\n\x02\x03\x01\x12\
\x03\n\x07\x1e\nG\n\x02\x05\0\x12\x04\x0f\0\x16\x01\x1a;*\n\x20Type\x20o\
f\x20script\x20which\x20will\x20be\x20used\x20for\x20transaction\x20inpu\
t\n\n\n\n\x03\x05\0\x01\x12\x03\x0f\x05\x14\n%\n\x04\x05\0\x02\0\x12\x03\
\x10\x04\x15\"\x18\x20standard\x20P2PKH\x20address\n\n\x0c\n\x05\x05\0\
\x02\0\x01\x12\x03\x10\x04\x10\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03\x10\
\x13\x14\n$\n\x04\x05\0\x02\x01\x12\x03\x11\x04\x16\"\x17\x20P2SH\x20mul\
tisig\x20address\n\n\x0c\n\x05\x05\0\x02\x01\x01\x12\x03\x11\x04\x11\n\
\x0c\n\x05\x05\0\x02\x01\x02\x12\x03\x11\x14\x15\n6\n\x04\x05\0\x02\x02\
\x12\x03\x12\x04\x11\")\x20reserved\x20for\x20external\x20inputs\x20(coi\
njoin)\n\n\x0c\n\x05\x05\0\x02\x02\x01\x12\x03\x12\x04\x0c\n\x0c\n\x05\
\x05\0\x02\x02\x02\x12\x03\x12\x0f\x10\n\x1c\n\x04\x05\0\x02\x03\x12\x03\
\x13\x04\x15\"\x0f\x20native\x20SegWit\n\n\x0c\n\x05\x05\0\x02\x03\x01\
\x12\x03\x13\x04\x10\n\x0c\n\x05\x05\0\x02\x03\x02\x12\x03\x13\x13\x14\n\
5\n\x04\x05\0\x02\x04\x12\x03\x14\x04\x19\"(\x20SegWit\x20over\x20P2SH\
\x20(backward\x20compatible)\n\n\x0c\n\x05\x05\0\x02\x04\x01\x12\x03\x14\
\x04\x14\n\x0c\n\x05\x05\0\x02\x04\x02\x12\x03\x14\x17\x18\n\x16\n\x04\
\x05\0\x02\x05\x12\x03\x15\x04\x15\"\t\x20Taproot\n\n\x0c\n\x05\x05\0\
\x02\x05\x01\x12\x03\x15\x04\x10\n\x0c\n\x05\x05\0\x02\x05\x02\x12\x03\
\x15\x13\x14\nH\n\x02\x05\x01\x12\x04\x1b\0#\x01\x1a<*\n\x20Type\x20of\
\x20script\x20which\x20will\x20be\x20used\x20for\x20transaction\x20outpu\
t\n\n\n\n\x03\x05\x01\x01\x12\x03\x1b\x05\x15\n>\n\x04\x05\x01\x02\0\x12\
\x03\x1c\x04\x15\"1\x20used\x20for\x20all\x20addresses\x20(bitcoin,\x20p\
2sh,\x20witness)\n\n\x0c\n\x05\x05\x01\x02\0\x01\x12\x03\x1c\x04\x10\n\
\x0c\n\x05\x05\x01\x02\0\x02\x12\x03\x1c\x13\x14\n:\n\x04\x05\x01\x02\
\x01\x12\x03\x1d\x04\x18\"-\x20p2sh\x20address\x20(deprecated;\x20use\
\x20PAYTOADDRESS)\n\n\x0c\n\x05\x05\x01\x02\x01\x01\x12\x03\x1d\x04\x13\
\n\x0c\n\x05\x05\x01\x02\x01\x02\x12\x03\x1d\x16\x17\n%\n\x04\x05\x01\
\x02\x02\x12\x03\x1e\x04\x16\"\x18\x20only\x20for\x20change\x20output\n\
\n\x0c\n\x05\x05\x01\x02\x02\x01\x12\x03\x1e\x04\x11\n\x0c\n\x05\x05\x01\
\x02\x02\x02\x12\x03\x1e\x14\x15\n\x18\n\x04\x05\x01\x02\x03\x12\x03\x1f\
\x04\x16\"\x0b\x20op_return\n\n\x0c\n\x05\x05\x01\x02\x03\x01\x12\x03\
\x1f\x04\x11\n\x0c\n\x05\x05\x01\x02\x03\x02\x12\x03\x1f\x14\x15\n%\n\
\x04\x05\x01\x02\x04\x12\x03\x20\x04\x15\"\x18\x20only\x20for\x20change\
\x20output\n\n\x0c\n\x05\x05\x01\x02\x04\x01\x12\x03\x20\x04\x10\n\x0c\n\
\x05\x05\x01\x02\x04\x02\x12\x03\x20\x13\x14\n%\n\x04\x05\x01\x02\x05\
\x12\x03!\x04\x19\"\x18\x20only\x20for\x20change\x20output\n\n\x0c\n\x05\
\x05\x01\x02\x05\x01\x12\x03!\x04\x14\n\x0c\n\x05\x05\x01\x02\x05\x02\
\x12\x03!\x17\x18\n%\n\x04\x05\x01\x02\x06\x12\x03\"\x04\x15\"\x18\x20on\
ly\x20for\x20change\x20output\n\n\x0c\n\x05\x05\x01\x02\x06\x01\x12\x03\
\"\x04\x10\n\x0c\n\x05\x05\x01\x02\x06\x02\x12\x03\"\x13\x14\nT\n\x02\
\x05\x02\x12\x04(\0+\x01\x1aH*\n\x20Type\x20of\x20script\x20which\x20wil\
l\x20be\x20used\x20for\x20decred\x20stake\x20transaction\x20input\n\n\n\
\n\x03\x05\x02\x01\x12\x03(\x05\x1b\n\x0b\n\x04\x05\x02\x02\0\x12\x03)\
\x04\x0e\n\x0c\n\x05\x05\x02\x02\0\x01\x12\x03)\x04\t\n\x0c\n\x05\x05\
\x02\x02\0\x02\x12\x03)\x0c\r\n\x0b\n\x04\x05\x02\x02\x01\x12\x03*\x04\
\x0e\n\x0c\n\x05\x05\x02\x02\x01\x01\x12\x03*\x04\t\n\x0c\n\x05\x05\x02\
\x02\x01\x02\x12\x03*\x0c\r\nC\n\x02\x05\x03\x12\x040\05\x01\x1a7*\n\x20\
Unit\x20to\x20be\x20used\x20when\x20showing\x20amounts\x20on\x20the\x20d\
isplay\n\n\n\n\x03\x05\x03\x01\x12\x030\x05\x0f\n\x12\n\x04\x05\x03\x02\
\0\x12\x031\x04\x10\"\x05\x20BTC\n\n\x0c\n\x05\x05\x03\x02\0\x01\x12\x03\
1\x04\x0b\n\x0c\n\x05\x05\x03\x02\0\x02\x12\x031\x0e\x0f\n\x13\n\x04\x05\
\x03\x02\x01\x12\x032\x04\x15\"\x06\x20mBTC\n\n\x0c\n\x05\x05\x03\x02\
\x01\x01\x12\x032\x04\x10\n\x0c\n\x05\x05\x03\x02\x01\x02\x12\x032\x13\
\x14\n\x13\n\x04\x05\x03\x02\x02\x12\x033\x04\x15\"\x06\x20uBTC\n\n\x0c\
\n\x05\x05\x03\x02\x02\x01\x12\x033\x04\x10\n\x0c\n\x05\x05\x03\x02\x02\
\x02\x12\x033\x13\x14\n\x12\n\x04\x05\x03\x02\x03\x12\x034\x04\x10\"\x05\
\x20sat\n\n\x0c\n\x05\x05\x03\x02\x03\x01\x12\x034\x04\x0b\n\x0c\n\x05\
\x05\x03\x02\x03\x02\x12\x034\x0e\x0f\n;\n\x02\x04\0\x12\x04;\0H\x01\x1a\
/*\n\x20Type\x20of\x20redeem\x20script\x20used\x20in\x20input\n\x20@embe\
d\n\n\n\n\x03\x04\0\x01\x12\x03;\x08\x20\nG\n\x04\x04\0\x02\0\x12\x03<\
\x04(\":\x20pubkeys\x20from\x20multisig\x20address\x20(sorted\x20lexicog\
raphically)\n\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03<\x04\x0c\n\x0c\n\x05\
\x04\0\x02\0\x06\x12\x03<\r\x1b\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03<\x1c\
#\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03<&'\n=\n\x04\x04\0\x02\x01\x12\x03=\
\x04\"\"0\x20existing\x20signatures\x20for\x20partially\x20signed\x20inp\
ut\n\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03=\x04\x0c\n\x0c\n\x05\x04\0\
\x02\x01\x05\x12\x03=\r\x12\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03=\x13\
\x1d\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03=\x20!\nN\n\x04\x04\0\x02\x02\
\x12\x03>\x04\x1a\"A\x20\"m\"\x20from\x20n,\x20how\x20many\x20valid\x20s\
ignatures\x20is\x20necessary\x20for\x20spending\n\n\x0c\n\x05\x04\0\x02\
\x02\x04\x12\x03>\x04\x0c\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03>\r\x13\n\
\x0c\n\x05\x04\0\x02\x02\x01\x12\x03>\x14\x15\n\x0c\n\x05\x04\0\x02\x02\
\x03\x12\x03>\x18\x19\nZ\n\x04\x04\0\x02\x03\x12\x03?\x04)\"M\x20simplif\
ied\x20way\x20how\x20to\x20specify\x20pubkeys\x20if\x20they\x20share\x20\
the\x20same\x20address_n\x20path\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x03\
?\x04\x0c\n\x0c\n\x05\x04\0\x02\x03\x06\x12\x03?\r\x1e\n\x0c\n\x05\x04\0\
\x02\x03\x01\x12\x03?\x1f$\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03?'(\nY\n\
\x04\x04\0\x02\x04\x12\x03@\x04\"\"L\x20use\x20only\x20field\x201\x20or\
\x20fields\x204+5,\x20if\x20fields\x204+5\x20are\x20used,\x20field\x201\
\x20is\x20ignored\n\n\x0c\n\x05\x04\0\x02\x04\x04\x12\x03@\x04\x0c\n\x0c\
\n\x05\x04\0\x02\x04\x05\x12\x03@\r\x13\n\x0c\n\x05\x04\0\x02\x04\x01\
\x12\x03@\x14\x1d\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03@\x20!\n6\n\x04\
\x04\0\x03\0\x12\x04D\x04G\x05\x1a(*\n\x20Structure\x20representing\x20H\
DNode\x20+\x20Path\n\n\x0c\n\x05\x04\0\x03\0\x01\x12\x03D\x0c\x1a\n1\n\
\x06\x04\0\x03\0\x02\0\x12\x03E\x08,\"\"\x20BIP-32\x20node\x20in\x20dese\
rialized\x20form\n\n\x0e\n\x07\x04\0\x03\0\x02\0\x04\x12\x03E\x08\x10\n\
\x0e\n\x07\x04\0\x03\0\x02\0\x06\x12\x03E\x11\"\n\x0e\n\x07\x04\0\x03\0\
\x02\0\x01\x12\x03E#'\n\x0e\n\x07\x04\0\x03\0\x02\0\x03\x12\x03E*+\n8\n\
\x06\x04\0\x03\0\x02\x01\x12\x03F\x08&\")\x20BIP-32\x20path\x20to\x20der\
ive\x20the\x20key\x20from\x20node\n\n\x0e\n\x07\x04\0\x03\0\x02\x01\x04\
\x12\x03F\x08\x10\n\x0e\n\x07\x04\0\x03\0\x02\x01\x05\x12\x03F\x11\x17\n\
\x0e\n\x07\x04\0\x03\0\x02\x01\x01\x12\x03F\x18!\n\x0e\n\x07\x04\0\x03\0\
\x02\x01\x03\x12\x03F$%\nz\n\x02\x04\x01\x12\x04P\0W\x01\x1an*\n\x20Requ\
est:\x20Ask\x20device\x20for\x20public\x20key\x20corresponding\x20to\x20\
address_n\x20path\n\x20@start\n\x20@next\x20PublicKey\n\x20@next\x20Fail\
ure\n\n\n\n\x03\x04\x01\x01\x12\x03P\x08\x14\n=\n\x04\x04\x01\x02\0\x12\
\x03Q\x04\"\"0\x20BIP-32\x20path\x20to\x20derive\x20the\x20key\x20from\
\x20master\x20node\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03Q\x04\x0c\n\
\x0c\n\x05\x04\x01\x02\0\x05\x12\x03Q\r\x13\n\x0c\n\x05\x04\x01\x02\0\
\x01\x12\x03Q\x14\x1d\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03Q\x20!\n&\n\
\x04\x04\x01\x02\x01\x12\x03R\x04)\"\x19\x20ECDSA\x20curve\x20name\x20to\
\x20use\n\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03R\x04\x0c\n\x0c\n\x05\
\x04\x01\x02\x01\x05\x12\x03R\r\x13\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\
\x03R\x14$\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03R'(\nC\n\x04\x04\x01\
\x02\x02\x12\x03S\x04#\"6\x20optionally\x20show\x20on\x20display\x20befo\
re\x20sending\x20the\x20result\n\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03\
S\x04\x0c\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03S\r\x11\n\x0c\n\x05\x04\
\x01\x02\x02\x01\x12\x03S\x12\x1e\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\
\x03S!\"\n(\n\x04\x04\x01\x02\x03\x12\x03T\x046\"\x1b\x20coin\x20to\x20u\
se\x20for\x20verifying\n\n\x0c\n\x05\x04\x01\x02\x03\x04\x12\x03T\x04\
\x0c\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03T\r\x13\n\x0c\n\x05\x04\x01\
\x02\x03\x01\x12\x03T\x14\x1d\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03T\
\x20!\n\x0c\n\x05\x04\x01\x02\x03\x08\x12\x03T\"5\n\x0c\n\x05\x04\x01\
\x02\x03\x07\x12\x03T+4\n]\n\x04\x04\x01\x02\x04\x12\x03U\x04D\"P\x20use\
d\x20to\x20distinguish\x20between\x20various\x20address\x20formats\x20(n\
on-segwit,\x20segwit,\x20etc.)\n\n\x0c\n\x05\x04\x01\x02\x04\x04\x12\x03\
U\x04\x0c\n\x0c\n\x05\x04\x01\x02\x04\x06\x12\x03U\r\x1c\n\x0c\n\x05\x04\
\x01\x02\x04\x01\x12\x03U\x1d(\n\x0c\n\x05\x04\x01\x02\x04\x03\x12\x03U+\
,\n\x0c\n\x05\x04\x01\x02\x04\x08\x12\x03U-C\n\x0c\n\x05\x04\x01\x02\x04\
\x07\x12\x03U6B\nV\n\x04\x04\x01\x02\x05\x12\x03V\x04(\"I\x20ignore\x20S\
LIP-0132\x20XPUB\x20magic,\x20use\x20xpub/tpub\x20prefix\x20for\x20all\
\x20account\x20types\n\n\x0c\n\x05\x04\x01\x02\x05\x04\x12\x03V\x04\x0c\
\n\x0c\n\x05\x04\x01\x02\x05\x05\x12\x03V\r\x11\n\x0c\n\x05\x04\x01\x02\
\x05\x01\x12\x03V\x12#\n\x0c\n\x05\x04\x01\x02\x05\x03\x12\x03V&'\nT\n\
\x02\x04\x02\x12\x04]\0a\x01\x1aH*\n\x20Response:\x20Contains\x20public\
\x20key\x20derived\x20from\x20device\x20private\x20seed\n\x20@end\n\n\n\
\n\x03\x04\x02\x01\x12\x03]\x08\x11\n\x20\n\x04\x04\x02\x02\0\x12\x03^\
\x04(\"\x13\x20BIP32\x20public\x20node\n\n\x0c\n\x05\x04\x02\x02\0\x04\
\x12\x03^\x04\x0c\n\x0c\n\x05\x04\x02\x02\0\x06\x12\x03^\r\x1e\n\x0c\n\
\x05\x04\x02\x02\0\x01\x12\x03^\x1f#\n\x0c\n\x05\x04\x02\x02\0\x03\x12\
\x03^&'\n-\n\x04\x04\x02\x02\x01\x12\x03_\x04\x1d\"\x20\x20serialized\
\x20form\x20of\x20public\x20node\n\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\
\x03_\x04\x0c\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03_\r\x13\n\x0c\n\x05\
\x04\x02\x02\x01\x01\x12\x03_\x14\x18\n\x0c\n\x05\x04\x02\x02\x01\x03\
\x12\x03_\x1b\x1c\n+\n\x04\x04\x02\x02\x02\x12\x03`\x04)\"\x1e\x20master\
\x20root\x20node\x20fingerprint\n\n\x0c\n\x05\x04\x02\x02\x02\x04\x12\
\x03`\x04\x0c\n\x0c\n\x05\x04\x02\x02\x02\x05\x12\x03`\r\x13\n\x0c\n\x05\
\x04\x02\x02\x02\x01\x12\x03`\x14$\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\
\x03`'(\nu\n\x02\x04\x03\x12\x04i\0p\x01\x1ai*\n\x20Request:\x20Ask\x20d\
evice\x20for\x20address\x20corresponding\x20to\x20address_n\x20path\n\
\x20@start\n\x20@next\x20Address\n\x20@next\x20Failure\n\n\n\n\x03\x04\
\x03\x01\x12\x03i\x08\x12\n=\n\x04\x04\x03\x02\0\x12\x03j\x04\"\"0\x20BI\
P-32\x20path\x20to\x20derive\x20the\x20key\x20from\x20master\x20node\n\n\
\x0c\n\x05\x04\x03\x02\0\x04\x12\x03j\x04\x0c\n\x0c\n\x05\x04\x03\x02\0\
\x05\x12\x03j\r\x13\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03j\x14\x1d\n\x0c\
\n\x05\x04\x03\x02\0\x03\x12\x03j\x20!\n\x1a\n\x04\x04\x03\x02\x01\x12\
\x03k\x046\"\r\x20coin\x20to\x20use\n\n\x0c\n\x05\x04\x03\x02\x01\x04\
\x12\x03k\x04\x0c\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03k\r\x13\n\x0c\n\
\x05\x04\x03\x02\x01\x01\x12\x03k\x14\x1d\n\x0c\n\x05\x04\x03\x02\x01\
\x03\x12\x03k\x20!\n\x0c\n\x05\x04\x03\x02\x01\x08\x12\x03k\"5\n\x0c\n\
\x05\x04\x03\x02\x01\x07\x12\x03k+4\nC\n\x04\x04\x03\x02\x02\x12\x03l\
\x04#\"6\x20optionally\x20show\x20on\x20display\x20before\x20sending\x20\
the\x20result\n\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\x03l\x04\x0c\n\x0c\n\
\x05\x04\x03\x02\x02\x05\x12\x03l\r\x11\n\x0c\n\x05\x04\x03\x02\x02\x01\
\x12\x03l\x12\x1e\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03l!\"\n:\n\x04\
\x04\x03\x02\x03\x12\x03m\x043\"-\x20filled\x20if\x20we\x20are\x20showin\
g\x20a\x20multisig\x20address\n\n\x0c\n\x05\x04\x03\x02\x03\x04\x12\x03m\
\x04\x0c\n\x0c\n\x05\x04\x03\x02\x03\x06\x12\x03m\r%\n\x0c\n\x05\x04\x03\
\x02\x03\x01\x12\x03m&.\n\x0c\n\x05\x04\x03\x02\x03\x03\x12\x03m12\n]\n\
\x04\x04\x03\x02\x04\x12\x03n\x04D\"P\x20used\x20to\x20distinguish\x20be\
tween\x20various\x20address\x20formats\x20(non-segwit,\x20segwit,\x20etc\
.)\n\n\x0c\n\x05\x04\x03\x02\x04\x04\x12\x03n\x04\x0c\n\x0c\n\x05\x04\
\x03\x02\x04\x06\x12\x03n\r\x1c\n\x0c\n\x05\x04\x03\x02\x04\x01\x12\x03n\
\x1d(\n\x0c\n\x05\x04\x03\x02\x04\x03\x12\x03n+,\n\x0c\n\x05\x04\x03\x02\
\x04\x08\x12\x03n-C\n\x0c\n\x05\x04\x03\x02\x04\x07\x12\x03n6B\nV\n\x04\
\x04\x03\x02\x05\x12\x03o\x04(\"I\x20ignore\x20SLIP-0132\x20XPUB\x20magi\
c,\x20use\x20xpub/tpub\x20prefix\x20for\x20all\x20account\x20types\n\n\
\x0c\n\x05\x04\x03\x02\x05\x04\x12\x03o\x04\x0c\n\x0c\n\x05\x04\x03\x02\
\x05\x05\x12\x03o\r\x11\n\x0c\n\x05\x04\x03\x02\x05\x01\x12\x03o\x12#\n\
\x0c\n\x05\x04\x03\x02\x05\x03\x12\x03o&'\nQ\n\x02\x04\x04\x12\x04v\0x\
\x01\x1aE*\n\x20Response:\x20Contains\x20address\x20derived\x20from\x20d\
evice\x20private\x20seed\n\x20@end\n\n\n\n\x03\x04\x04\x01\x12\x03v\x08\
\x0f\n.\n\x04\x04\x04\x02\0\x12\x03w\x04\x20\"!\x20Coin\x20address\x20in\
\x20Base58\x20encoding\n\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x03w\x04\x0c\
\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03w\r\x13\n\x0c\n\x05\x04\x04\x02\0\
\x01\x12\x03w\x14\x1b\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03w\x1e\x1f\n\
\x9a\x01\n\x02\x04\x05\x12\x06\x80\x01\0\x85\x01\x01\x1a\x8b\x01*\n\x20R\
equest:\x20Ask\x20device\x20for\x20ownership\x20identifier\x20correspond\
ing\x20to\x20scriptPubKey\x20for\x20address_n\x20path\n\x20@start\n\x20@\
next\x20OwnershipId\n\x20@next\x20Failure\n\n\x0b\n\x03\x04\x05\x01\x12\
\x04\x80\x01\x08\x16\n>\n\x04\x04\x05\x02\0\x12\x04\x81\x01\x04\"\"0\x20\
BIP-32\x20path\x20to\x20derive\x20the\x20key\x20from\x20master\x20node\n\
\n\r\n\x05\x04\x05\x02\0\x04\x12\x04\x81\x01\x04\x0c\n\r\n\x05\x04\x05\
\x02\0\x05\x12\x04\x81\x01\r\x13\n\r\n\x05\x04\x05\x02\0\x01\x12\x04\x81\
\x01\x14\x1d\n\r\n\x05\x04\x05\x02\0\x03\x12\x04\x81\x01\x20!\n\x1b\n\
\x04\x04\x05\x02\x01\x12\x04\x82\x01\x046\"\r\x20coin\x20to\x20use\n\n\r\
\n\x05\x04\x05\x02\x01\x04\x12\x04\x82\x01\x04\x0c\n\r\n\x05\x04\x05\x02\
\x01\x05\x12\x04\x82\x01\r\x13\n\r\n\x05\x04\x05\x02\x01\x01\x12\x04\x82\
\x01\x14\x1d\n\r\n\x05\x04\x05\x02\x01\x03\x12\x04\x82\x01\x20!\n\r\n\
\x05\x04\x05\x02\x01\x08\x12\x04\x82\x01\"5\n\r\n\x05\x04\x05\x02\x01\
\x07\x12\x04\x82\x01+4\nE\n\x04\x04\x05\x02\x02\x12\x04\x83\x01\x043\"7\
\x20filled\x20if\x20we\x20are\x20dealing\x20with\x20a\x20multisig\x20scr\
iptPubKey\n\n\r\n\x05\x04\x05\x02\x02\x04\x12\x04\x83\x01\x04\x0c\n\r\n\
\x05\x04\x05\x02\x02\x06\x12\x04\x83\x01\r%\n\r\n\x05\x04\x05\x02\x02\
\x01\x12\x04\x83\x01&.\n\r\n\x05\x04\x05\x02\x02\x03\x12\x04\x83\x0112\n\
^\n\x04\x04\x05\x02\x03\x12\x04\x84\x01\x04D\"P\x20used\x20to\x20disting\
uish\x20between\x20various\x20address\x20formats\x20(non-segwit,\x20segw\
it,\x20etc.)\n\n\r\n\x05\x04\x05\x02\x03\x04\x12\x04\x84\x01\x04\x0c\n\r\
\n\x05\x04\x05\x02\x03\x06\x12\x04\x84\x01\r\x1c\n\r\n\x05\x04\x05\x02\
\x03\x01\x12\x04\x84\x01\x1d(\n\r\n\x05\x04\x05\x02\x03\x03\x12\x04\x84\
\x01+,\n\r\n\x05\x04\x05\x02\x03\x08\x12\x04\x84\x01-C\n\r\n\x05\x04\x05\
\x02\x03\x07\x12\x04\x84\x016B\np\n\x02\x04\x06\x12\x06\x8b\x01\0\x8d\
\x01\x01\x1ab*\n\x20Response:\x20Contains\x20the\x20ownership\x20identif\
ier\x20for\x20the\x20scriptPubKey\x20and\x20device\x20private\x20seed\n\
\x20@end\n\n\x0b\n\x03\x04\x06\x01\x12\x04\x8b\x01\x08\x13\n$\n\x04\x04\
\x06\x02\0\x12\x04\x8c\x01\x04$\"\x16\x20ownership\x20identifier\n\n\r\n\
\x05\x04\x06\x02\0\x04\x12\x04\x8c\x01\x04\x0c\n\r\n\x05\x04\x06\x02\0\
\x05\x12\x04\x8c\x01\r\x12\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\x8c\x01\
\x13\x1f\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\x8c\x01\"#\nd\n\x02\x04\x07\
\x12\x06\x95\x01\0\x9b\x01\x01\x1aV*\n\x20Request:\x20Ask\x20device\x20t\
o\x20sign\x20message\n\x20@start\n\x20@next\x20MessageSignature\n\x20@ne\
xt\x20Failure\n\n\x0b\n\x03\x04\x07\x01\x12\x04\x95\x01\x08\x13\n>\n\x04\
\x04\x07\x02\0\x12\x04\x96\x01\x04\"\"0\x20BIP-32\x20path\x20to\x20deriv\
e\x20the\x20key\x20from\x20master\x20node\n\n\r\n\x05\x04\x07\x02\0\x04\
\x12\x04\x96\x01\x04\x0c\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\x96\x01\r\
\x13\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\x96\x01\x14\x1d\n\r\n\x05\x04\
\x07\x02\0\x03\x12\x04\x96\x01\x20!\n$\n\x04\x04\x07\x02\x01\x12\x04\x97\
\x01\x04\x1f\"\x16\x20message\x20to\x20be\x20signed\n\n\r\n\x05\x04\x07\
\x02\x01\x04\x12\x04\x97\x01\x04\x0c\n\r\n\x05\x04\x07\x02\x01\x05\x12\
\x04\x97\x01\r\x12\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\x97\x01\x13\x1a\
\n\r\n\x05\x04\x07\x02\x01\x03\x12\x04\x97\x01\x1d\x1e\n'\n\x04\x04\x07\
\x02\x02\x12\x04\x98\x01\x046\"\x19\x20coin\x20to\x20use\x20for\x20signi\
ng\n\n\r\n\x05\x04\x07\x02\x02\x04\x12\x04\x98\x01\x04\x0c\n\r\n\x05\x04\
\x07\x02\x02\x05\x12\x04\x98\x01\r\x13\n\r\n\x05\x04\x07\x02\x02\x01\x12\
\x04\x98\x01\x14\x1d\n\r\n\x05\x04\x07\x02\x02\x03\x12\x04\x98\x01\x20!\
\n\r\n\x05\x04\x07\x02\x02\x08\x12\x04\x98\x01\"5\n\r\n\x05\x04\x07\x02\
\x02\x07\x12\x04\x98\x01+4\n^\n\x04\x04\x07\x02\x03\x12\x04\x99\x01\x04D\
\"P\x20used\x20to\x20distinguish\x20between\x20various\x20address\x20for\
mats\x20(non-segwit,\x20segwit,\x20etc.)\n\n\r\n\x05\x04\x07\x02\x03\x04\
\x12\x04\x99\x01\x04\x0c\n\r\n\x05\x04\x07\x02\x03\x06\x12\x04\x99\x01\r\
\x1c\n\r\n\x05\x04\x07\x02\x03\x01\x12\x04\x99\x01\x1d(\n\r\n\x05\x04\
\x07\x02\x03\x03\x12\x04\x99\x01+,\n\r\n\x05\x04\x07\x02\x03\x08\x12\x04\
\x99\x01-C\n\r\n\x05\x04\x07\x02\x03\x07\x12\x04\x99\x016B\nt\n\x04\x04\
\x07\x02\x04\x12\x04\x9a\x01\x04%\"f\x20don't\x20include\x20script\x20ty\
pe\x20information\x20in\x20the\x20recovery\x20byte\x20of\x20the\x20signa\
ture,\x20same\x20as\x20in\x20Bitcoin\x20Core\n\n\r\n\x05\x04\x07\x02\x04\
\x04\x12\x04\x9a\x01\x04\x0c\n\r\n\x05\x04\x07\x02\x04\x05\x12\x04\x9a\
\x01\r\x11\n\r\n\x05\x04\x07\x02\x04\x01\x12\x04\x9a\x01\x12\x20\n\r\n\
\x05\x04\x07\x02\x04\x03\x12\x04\x9a\x01#$\n0\n\x02\x04\x08\x12\x06\xa1\
\x01\0\xa4\x01\x01\x1a\"*\n\x20Response:\x20Signed\x20message\n\x20@end\
\n\n\x0b\n\x03\x04\x08\x01\x12\x04\xa1\x01\x08\x18\n0\n\x04\x04\x08\x02\
\0\x12\x04\xa2\x01\x04\x20\"\"\x20address\x20used\x20to\x20sign\x20the\
\x20message\n\n\r\n\x05\x04\x08\x02\0\x04\x12\x04\xa2\x01\x04\x0c\n\r\n\
\x05\x04\x08\x02\0\x05\x12\x04\xa2\x01\r\x13\n\r\n\x05\x04\x08\x02\0\x01\
\x12\x04\xa2\x01\x14\x1b\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\xa2\x01\x1e\
\x1f\n(\n\x04\x04\x08\x02\x01\x12\x04\xa3\x01\x04!\"\x1a\x20signature\
\x20of\x20the\x20message\n\n\r\n\x05\x04\x08\x02\x01\x04\x12\x04\xa3\x01\
\x04\x0c\n\r\n\x05\x04\x08\x02\x01\x05\x12\x04\xa3\x01\r\x12\n\r\n\x05\
\x04\x08\x02\x01\x01\x12\x04\xa3\x01\x13\x1c\n\r\n\x05\x04\x08\x02\x01\
\x03\x12\x04\xa3\x01\x1f\x20\n]\n\x02\x04\t\x12\x06\xac\x01\0\xb1\x01\
\x01\x1aO*\n\x20Request:\x20Ask\x20device\x20to\x20verify\x20message\n\
\x20@start\n\x20@next\x20Success\n\x20@next\x20Failure\n\n\x0b\n\x03\x04\
\t\x01\x12\x04\xac\x01\x08\x15\n!\n\x04\x04\t\x02\0\x12\x04\xad\x01\x04\
\x20\"\x13\x20address\x20to\x20verify\n\n\r\n\x05\x04\t\x02\0\x04\x12\
\x04\xad\x01\x04\x0c\n\r\n\x05\x04\t\x02\0\x05\x12\x04\xad\x01\r\x13\n\r\
\n\x05\x04\t\x02\0\x01\x12\x04\xad\x01\x14\x1b\n\r\n\x05\x04\t\x02\0\x03\
\x12\x04\xad\x01\x1e\x1f\n#\n\x04\x04\t\x02\x01\x12\x04\xae\x01\x04!\"\
\x15\x20signature\x20to\x20verify\n\n\r\n\x05\x04\t\x02\x01\x04\x12\x04\
\xae\x01\x04\x0c\n\r\n\x05\x04\t\x02\x01\x05\x12\x04\xae\x01\r\x12\n\r\n\
\x05\x04\t\x02\x01\x01\x12\x04\xae\x01\x13\x1c\n\r\n\x05\x04\t\x02\x01\
\x03\x12\x04\xae\x01\x1f\x20\n!\n\x04\x04\t\x02\x02\x12\x04\xaf\x01\x04\
\x1f\"\x13\x20message\x20to\x20verify\n\n\r\n\x05\x04\t\x02\x02\x04\x12\
\x04\xaf\x01\x04\x0c\n\r\n\x05\x04\t\x02\x02\x05\x12\x04\xaf\x01\r\x12\n\
\r\n\x05\x04\t\x02\x02\x01\x12\x04\xaf\x01\x13\x1a\n\r\n\x05\x04\t\x02\
\x02\x03\x12\x04\xaf\x01\x1d\x1e\n)\n\x04\x04\t\x02\x03\x12\x04\xb0\x01\
\x046\"\x1b\x20coin\x20to\x20use\x20for\x20verifying\n\n\r\n\x05\x04\t\
\x02\x03\x04\x12\x04\xb0\x01\x04\x0c\n\r\n\x05\x04\t\x02\x03\x05\x12\x04\
\xb0\x01\r\x13\n\r\n\x05\x04\t\x02\x03\x01\x12\x04\xb0\x01\x14\x1d\n\r\n\
\x05\x04\t\x02\x03\x03\x12\x04\xb0\x01\x20!\n\r\n\x05\x04\t\x02\x03\x08\
\x12\x04\xb0\x01\"5\n\r\n\x05\x04\t\x02\x03\x07\x12\x04\xb0\x01+4\na\n\
\x02\x04\n\x12\x06\xb9\x01\0\xc6\x01\x01\x1aS*\n\x20Request:\x20Ask\x20d\
evice\x20to\x20sign\x20transaction\n\x20@start\n\x20@next\x20TxRequest\n\
\x20@next\x20Failure\n\n\x0b\n\x03\x04\n\x01\x12\x04\xb9\x01\x08\x0e\n-\
\n\x04\x04\n\x02\0\x12\x04\xba\x01\x04&\"\x1f\x20number\x20of\x20transac\
tion\x20outputs\n\n\r\n\x05\x04\n\x02\0\x04\x12\x04\xba\x01\x04\x0c\n\r\
\n\x05\x04\n\x02\0\x05\x12\x04\xba\x01\r\x13\n\r\n\x05\x04\n\x02\0\x01\
\x12\x04\xba\x01\x14!\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xba\x01$%\n,\n\
\x04\x04\n\x02\x01\x12\x04\xbb\x01\x04%\"\x1e\x20number\x20of\x20transac\
tion\x20inputs\n\n\r\n\x05\x04\n\x02\x01\x04\x12\x04\xbb\x01\x04\x0c\n\r\
\n\x05\x04\n\x02\x01\x05\x12\x04\xbb\x01\r\x13\n\r\n\x05\x04\n\x02\x01\
\x01\x12\x04\xbb\x01\x14\x20\n\r\n\x05\x04\n\x02\x01\x03\x12\x04\xbb\x01\
#$\n\x1b\n\x04\x04\n\x02\x02\x12\x04\xbc\x01\x046\"\r\x20coin\x20to\x20u\
se\n\n\r\n\x05\x04\n\x02\x02\x04\x12\x04\xbc\x01\x04\x0c\n\r\n\x05\x04\n\
\x02\x02\x05\x12\x04\xbc\x01\r\x13\n\r\n\x05\x04\n\x02\x02\x01\x12\x04\
\xbc\x01\x14\x1d\n\r\n\x05\x04\n\x02\x02\x03\x12\x04\xbc\x01\x20!\n\r\n\
\x05\x04\n\x02\x02\x08\x12\x04\xbc\x01\"5\n\r\n\x05\x04\n\x02\x02\x07\
\x12\x04\xbc\x01+4\n#\n\x04\x04\n\x02\x03\x12\x04\xbd\x01\x04,\"\x15\x20\
transaction\x20version\n\n\r\n\x05\x04\n\x02\x03\x04\x12\x04\xbd\x01\x04\
\x0c\n\r\n\x05\x04\n\x02\x03\x05\x12\x04\xbd\x01\r\x13\n\r\n\x05\x04\n\
\x02\x03\x01\x12\x04\xbd\x01\x14\x1b\n\r\n\x05\x04\n\x02\x03\x03\x12\x04\
\xbd\x01\x1e\x1f\n\r\n\x05\x04\n\x02\x03\x08\x12\x04\xbd\x01\x20+\n\r\n\
\x05\x04\n\x02\x03\x07\x12\x04\xbd\x01)*\n%\n\x04\x04\n\x02\x04\x12\x04\
\xbe\x01\x04.\"\x17\x20transaction\x20lock_time\n\n\r\n\x05\x04\n\x02\
\x04\x04\x12\x04\xbe\x01\x04\x0c\n\r\n\x05\x04\n\x02\x04\x05\x12\x04\xbe\
\x01\r\x13\n\r\n\x05\x04\n\x02\x04\x01\x12\x04\xbe\x01\x14\x1d\n\r\n\x05\
\x04\n\x02\x04\x03\x12\x04\xbe\x01\x20!\n\r\n\x05\x04\n\x02\x04\x08\x12\
\x04\xbe\x01\"-\n\r\n\x05\x04\n\x02\x04\x07\x12\x04\xbe\x01+,\n)\n\x04\
\x04\n\x02\x05\x12\x04\xbf\x01\x04\x1f\"\x1b\x20only\x20for\x20Decred\
\x20and\x20Zcash\n\n\r\n\x05\x04\n\x02\x05\x04\x12\x04\xbf\x01\x04\x0c\n\
\r\n\x05\x04\n\x02\x05\x05\x12\x04\xbf\x01\r\x13\n\r\n\x05\x04\n\x02\x05\
\x01\x12\x04\xbf\x01\x14\x1a\n\r\n\x05\x04\n\x02\x05\x03\x12\x04\xbf\x01\
\x1d\x1e\n`\n\x04\x04\n\x02\x06\x12\x04\xc0\x01\x045\"R\x20deprecated\
\x20in\x202.3.2,\x20the\x20field\x20is\x20not\x20needed\x20as\x20it\x20c\
an\x20be\x20derived\x20from\x20`version`\n\n\r\n\x05\x04\n\x02\x06\x04\
\x12\x04\xc0\x01\x04\x0c\n\r\n\x05\x04\n\x02\x06\x05\x12\x04\xc0\x01\r\
\x11\n\r\n\x05\x04\n\x02\x06\x01\x12\x04\xc0\x01\x12\x1e\n\r\n\x05\x04\n\
\x02\x06\x03\x12\x04\xc0\x01!\"\n\r\n\x05\x04\n\x02\x06\x08\x12\x04\xc0\
\x01#4\n\x0e\n\x06\x04\n\x02\x06\x08\x03\x12\x04\xc0\x01$3\n/\n\x04\x04\
\n\x02\x07\x12\x04\xc1\x01\x04)\"!\x20only\x20for\x20Zcash,\x20nVersionG\
roupId\n\n\r\n\x05\x04\n\x02\x07\x04\x12\x04\xc1\x01\x04\x0c\n\r\n\x05\
\x04\n\x02\x07\x05\x12\x04\xc1\x01\r\x13\n\r\n\x05\x04\n\x02\x07\x01\x12\
\x04\xc1\x01\x14$\n\r\n\x05\x04\n\x02\x07\x03\x12\x04\xc1\x01'(\n!\n\x04\
\x04\n\x02\x08\x12\x04\xc2\x01\x04\"\"\x13\x20only\x20for\x20Peercoin\n\
\n\r\n\x05\x04\n\x02\x08\x04\x12\x04\xc2\x01\x04\x0c\n\r\n\x05\x04\n\x02\
\x08\x05\x12\x04\xc2\x01\r\x13\n\r\n\x05\x04\n\x02\x08\x01\x12\x04\xc2\
\x01\x14\x1d\n\r\n\x05\x04\n\x02\x08\x03\x12\x04\xc2\x01\x20!\n)\n\x04\
\x04\n\x02\t\x12\x04\xc3\x01\x04#\"\x1b\x20only\x20for\x20Zcash,\x20BRAN\
CH_ID\n\n\r\n\x05\x04\n\x02\t\x04\x12\x04\xc3\x01\x04\x0c\n\r\n\x05\x04\
\n\x02\t\x05\x12\x04\xc3\x01\r\x13\n\r\n\x05\x04\n\x02\t\x01\x12\x04\xc3\
\x01\x14\x1d\n\r\n\x05\x04\n\x02\t\x03\x12\x04\xc3\x01\x20\"\n\x1f\n\x04\
\x04\n\x02\n\x12\x04\xc4\x01\x04;\"\x11\x20show\x20amounts\x20in\n\n\r\n\
\x05\x04\n\x02\n\x04\x12\x04\xc4\x01\x04\x0c\n\r\n\x05\x04\n\x02\n\x06\
\x12\x04\xc4\x01\r\x17\n\r\n\x05\x04\n\x02\n\x01\x12\x04\xc4\x01\x18#\n\
\r\n\x05\x04\n\x02\n\x03\x12\x04\xc4\x01&(\n\r\n\x05\x04\n\x02\n\x08\x12\
\x04\xc4\x01):\n\r\n\x05\x04\n\x02\n\x07\x12\x04\xc4\x0129\nB\n\x04\x04\
\n\x02\x0b\x12\x04\xc5\x01\x04=\"4\x20only\x20for\x20Decred,\x20this\x20\
is\x20signing\x20a\x20ticket\x20purchase\n\n\r\n\x05\x04\n\x02\x0b\x04\
\x12\x04\xc5\x01\x04\x0c\n\r\n\x05\x04\n\x02\x0b\x05\x12\x04\xc5\x01\r\
\x11\n\r\n\x05\x04\n\x02\x0b\x01\x12\x04\xc5\x01\x12'\n\r\n\x05\x04\n\
\x02\x0b\x03\x12\x04\xc5\x01*,\n\r\n\x05\x04\n\x02\x0b\x08\x12\x04\xc5\
\x01-<\n\r\n\x05\x04\n\x02\x0b\x07\x12\x04\xc5\x016;\n\x99\x03\n\x02\x04\
\x0b\x12\x06\xd4\x01\0\xf5\x01\x01\x1a\x8a\x03*\n\x20Response:\x20Device\
\x20asks\x20for\x20information\x20for\x20signing\x20transaction\x20or\
\x20returns\x20the\x20last\x20result\n\x20If\x20request_index\x20is\x20s\
et,\x20device\x20awaits\x20TxAck<any>\x20matching\x20the\x20request\x20t\
ype.\n\x20If\x20signature_index\x20is\x20set,\x20'signature'\x20contains\
\x20signed\x20input\x20of\x20signature_index's\x20input\n\x20@end\n\x20@\
next\x20TxAckInput\n\x20@next\x20TxAckOutput\n\x20@next\x20TxAckPrevMeta\
\n\x20@next\x20TxAckPrevInput\n\x20@next\x20TxAckPrevOutput\n\x20@next\
\x20TxAckPrevExtraData\n\n\x0b\n\x03\x04\x0b\x01\x12\x04\xd4\x01\x08\x11\
\n7\n\x04\x04\x0b\x02\0\x12\x04\xd5\x01\x04*\")\x20what\x20should\x20be\
\x20filled\x20in\x20TxAck\x20message?\n\n\r\n\x05\x04\x0b\x02\0\x04\x12\
\x04\xd5\x01\x04\x0c\n\r\n\x05\x04\x0b\x02\0\x06\x12\x04\xd5\x01\r\x18\n\
\r\n\x05\x04\x0b\x02\0\x01\x12\x04\xd5\x01\x19%\n\r\n\x05\x04\x0b\x02\0\
\x03\x12\x04\xd5\x01()\n&\n\x04\x04\x0b\x02\x01\x12\x04\xd6\x01\x04.\"\
\x18\x20request\x20for\x20tx\x20details\n\n\r\n\x05\x04\x0b\x02\x01\x04\
\x12\x04\xd6\x01\x04\x0c\n\r\n\x05\x04\x0b\x02\x01\x06\x12\x04\xd6\x01\r\
!\n\r\n\x05\x04\x0b\x02\x01\x01\x12\x04\xd6\x01\")\n\r\n\x05\x04\x0b\x02\
\x01\x03\x12\x04\xd6\x01,-\n4\n\x04\x04\x0b\x02\x02\x12\x04\xd7\x01\x044\
\"&\x20serialized\x20data\x20and\x20request\x20for\x20next\n\n\r\n\x05\
\x04\x0b\x02\x02\x04\x12\x04\xd7\x01\x04\x0c\n\r\n\x05\x04\x0b\x02\x02\
\x06\x12\x04\xd7\x01\r$\n\r\n\x05\x04\x0b\x02\x02\x01\x12\x04\xd7\x01%/\
\n\r\n\x05\x04\x0b\x02\x02\x03\x12\x04\xd7\x0123\nO\n\x04\x04\x0b\x04\0\
\x12\x06\xdb\x01\x04\xe3\x01\x05\x1a?*\n\x20Type\x20of\x20information\
\x20required\x20by\x20transaction\x20signing\x20process\n\n\r\n\x05\x04\
\x0b\x04\0\x01\x12\x04\xdb\x01\t\x14\n\x0e\n\x06\x04\x0b\x04\0\x02\0\x12\
\x04\xdc\x01\x08\x14\n\x0f\n\x07\x04\x0b\x04\0\x02\0\x01\x12\x04\xdc\x01\
\x08\x0f\n\x0f\n\x07\x04\x0b\x04\0\x02\0\x02\x12\x04\xdc\x01\x12\x13\n\
\x0e\n\x06\x04\x0b\x04\0\x02\x01\x12\x04\xdd\x01\x08\x15\n\x0f\n\x07\x04\
\x0b\x04\0\x02\x01\x01\x12\x04\xdd\x01\x08\x10\n\x0f\n\x07\x04\x0b\x04\0\
\x02\x01\x02\x12\x04\xdd\x01\x13\x14\n\x0e\n\x06\x04\x0b\x04\0\x02\x02\
\x12\x04\xde\x01\x08\x13\n\x0f\n\x07\x04\x0b\x04\0\x02\x02\x01\x12\x04\
\xde\x01\x08\x0e\n\x0f\n\x07\x04\x0b\x04\0\x02\x02\x02\x12\x04\xde\x01\
\x11\x12\n\x0e\n\x06\x04\x0b\x04\0\x02\x03\x12\x04\xdf\x01\x08\x17\n\x0f\
\n\x07\x04\x0b\x04\0\x02\x03\x01\x12\x04\xdf\x01\x08\x12\n\x0f\n\x07\x04\
\x0b\x04\0\x02\x03\x02\x12\x04\xdf\x01\x15\x16\n\x0e\n\x06\x04\x0b\x04\0\
\x02\x04\x12\x04\xe0\x01\x08\x18\n\x0f\n\x07\x04\x0b\x04\0\x02\x04\x01\
\x12\x04\xe0\x01\x08\x13\n\x0f\n\x07\x04\x0b\x04\0\x02\x04\x02\x12\x04\
\xe0\x01\x16\x17\n\x0e\n\x06\x04\x0b\x04\0\x02\x05\x12\x04\xe1\x01\x08\
\x18\n\x0f\n\x07\x04\x0b\x04\0\x02\x05\x01\x12\x04\xe1\x01\x08\x13\n\x0f\
\n\x07\x04\x0b\x04\0\x02\x05\x02\x12\x04\xe1\x01\x16\x17\n\x0e\n\x06\x04\
\x0b\x04\0\x02\x06\x12\x04\xe2\x01\x08\x19\n\x0f\n\x07\x04\x0b\x04\0\x02\
\x06\x01\x12\x04\xe2\x01\x08\x14\n\x0f\n\x07\x04\x0b\x04\0\x02\x06\x02\
\x12\x04\xe2\x01\x17\x18\n:\n\x04\x04\x0b\x03\0\x12\x06\xe7\x01\x04\xec\
\x01\x05\x1a**\n\x20Structure\x20representing\x20request\x20details\n\n\
\r\n\x05\x04\x0b\x03\0\x01\x12\x04\xe7\x01\x0c\x20\n@\n\x06\x04\x0b\x03\
\0\x02\0\x12\x04\xe8\x01\x08*\"0\x20device\x20expects\x20TxAck\x20messag\
e\x20from\x20the\x20computer\n\n\x0f\n\x07\x04\x0b\x03\0\x02\0\x04\x12\
\x04\xe8\x01\x08\x10\n\x0f\n\x07\x04\x0b\x03\0\x02\0\x05\x12\x04\xe8\x01\
\x11\x17\n\x0f\n\x07\x04\x0b\x03\0\x02\0\x01\x12\x04\xe8\x01\x18%\n\x0f\
\n\x07\x04\x0b\x03\0\x02\0\x03\x12\x04\xe8\x01()\n2\n\x06\x04\x0b\x03\0\
\x02\x01\x12\x04\xe9\x01\x08#\"\"\x20tx_hash\x20of\x20requested\x20trans\
action\n\n\x0f\n\x07\x04\x0b\x03\0\x02\x01\x04\x12\x04\xe9\x01\x08\x10\n\
\x0f\n\x07\x04\x0b\x03\0\x02\x01\x05\x12\x04\xe9\x01\x11\x16\n\x0f\n\x07\
\x04\x0b\x03\0\x02\x01\x01\x12\x04\xe9\x01\x17\x1e\n\x0f\n\x07\x04\x0b\
\x03\0\x02\x01\x03\x12\x04\xe9\x01!\"\nG\n\x06\x04\x0b\x03\0\x02\x02\x12\
\x04\xea\x01\x08+\"7\x20length\x20of\x20requested\x20extra\x20data\x20(o\
nly\x20for\x20Dash,\x20Zcash)\n\n\x0f\n\x07\x04\x0b\x03\0\x02\x02\x04\
\x12\x04\xea\x01\x08\x10\n\x0f\n\x07\x04\x0b\x03\0\x02\x02\x05\x12\x04\
\xea\x01\x11\x17\n\x0f\n\x07\x04\x0b\x03\0\x02\x02\x01\x12\x04\xea\x01\
\x18&\n\x0f\n\x07\x04\x0b\x03\0\x02\x02\x03\x12\x04\xea\x01)*\nG\n\x06\
\x04\x0b\x03\0\x02\x03\x12\x04\xeb\x01\x08.\"7\x20offset\x20of\x20reques\
ted\x20extra\x20data\x20(only\x20for\x20Dash,\x20Zcash)\n\n\x0f\n\x07\
\x04\x0b\x03\0\x02\x03\x04\x12\x04\xeb\x01\x08\x10\n\x0f\n\x07\x04\x0b\
\x03\0\x02\x03\x05\x12\x04\xeb\x01\x11\x17\n\x0f\n\x07\x04\x0b\x03\0\x02\
\x03\x01\x12\x04\xeb\x01\x18)\n\x0f\n\x07\x04\x0b\x03\0\x02\x03\x03\x12\
\x04\xeb\x01,-\n:\n\x04\x04\x0b\x03\x01\x12\x06\xf0\x01\x04\xf4\x01\x05\
\x1a**\n\x20Structure\x20representing\x20serialized\x20data\n\n\r\n\x05\
\x04\x0b\x03\x01\x01\x12\x04\xf0\x01\x0c#\nG\n\x06\x04\x0b\x03\x01\x02\0\
\x12\x04\xf1\x01\x08,\"7\x20'signature'\x20field\x20contains\x20signed\
\x20input\x20of\x20this\x20index\n\n\x0f\n\x07\x04\x0b\x03\x01\x02\0\x04\
\x12\x04\xf1\x01\x08\x10\n\x0f\n\x07\x04\x0b\x03\x01\x02\0\x05\x12\x04\
\xf1\x01\x11\x17\n\x0f\n\x07\x04\x0b\x03\x01\x02\0\x01\x12\x04\xf1\x01\
\x18'\n\x0f\n\x07\x04\x0b\x03\x01\x02\0\x03\x12\x04\xf1\x01*+\n8\n\x06\
\x04\x0b\x03\x01\x02\x01\x12\x04\xf2\x01\x08%\"(\x20signature\x20of\x20t\
he\x20signature_index\x20input\n\n\x0f\n\x07\x04\x0b\x03\x01\x02\x01\x04\
\x12\x04\xf2\x01\x08\x10\n\x0f\n\x07\x04\x0b\x03\x01\x02\x01\x05\x12\x04\
\xf2\x01\x11\x16\n\x0f\n\x07\x04\x0b\x03\x01\x02\x01\x01\x12\x04\xf2\x01\
\x17\x20\n\x0f\n\x07\x04\x0b\x03\x01\x02\x01\x03\x12\x04\xf2\x01#$\n;\n\
\x06\x04\x0b\x03\x01\x02\x02\x12\x04\xf3\x01\x08)\"+\x20part\x20of\x20se\
rialized\x20and\x20signed\x20transaction\n\n\x0f\n\x07\x04\x0b\x03\x01\
\x02\x02\x04\x12\x04\xf3\x01\x08\x10\n\x0f\n\x07\x04\x0b\x03\x01\x02\x02\
\x05\x12\x04\xf3\x01\x11\x16\n\x0f\n\x07\x04\x0b\x03\x01\x02\x02\x01\x12\
\x04\xf3\x01\x17$\n\x0f\n\x07\x04\x0b\x03\x01\x02\x02\x03\x12\x04\xf3\
\x01'(\n\xf0\x03\n\x02\x04\x0c\x12\x06\x83\x02\0\xca\x02\x01\x1a\xe1\x03\
*\n\x20Request:\x20Reported\x20transaction\x20data\x20(legacy)\n\n\x20Th\
is\x20message\x20contains\x20all\x20possible\x20field\x20that\x20can\x20\
be\x20sent\x20in\x20response\x20to\x20a\x20TxRequest.\n\x20Depending\x20\
on\x20the\x20request_type,\x20the\x20host\x20is\x20supposed\x20to\x20fil\
l\x20some\x20of\x20these\x20fields.\n\n\x20The\x20interface\x20is\x20wir\
e-compatible\x20with\x20the\x20new\x20method\x20of\x20specialized\x20TxA\
ck\x20subtypes,\n\x20so\x20it\x20can\x20be\x20used\x20in\x20the\x20old\
\x20way.\x20However,\x20it\x20is\x20now\x20recommended\x20to\x20use\x20m\
ore\n\x20specialized\x20messages,\x20which\x20have\x20better-configured\
\x20constraints\x20on\x20field\x20values.\n\n\x20@next\x20TxRequest\n\n\
\x0b\n\x03\x04\x0c\x01\x12\x04\x83\x02\x08\r\n\x0b\n\x03\x04\x0c\x07\x12\
\x04\x84\x02\x04\x1d\n\x0c\n\x04\x04\x0c\x07\x03\x12\x04\x84\x02\x04\x1d\
\n\x0c\n\x04\x04\x0c\x02\0\x12\x04\x86\x02\x04$\n\r\n\x05\x04\x0c\x02\0\
\x04\x12\x04\x86\x02\x04\x0c\n\r\n\x05\x04\x0c\x02\0\x06\x12\x04\x86\x02\
\r\x1c\n\r\n\x05\x04\x0c\x02\0\x01\x12\x04\x86\x02\x1d\x1f\n\r\n\x05\x04\
\x0c\x02\0\x03\x12\x04\x86\x02\"#\n6\n\x04\x04\x0c\x03\0\x12\x06\x8a\x02\
\x04\xc9\x02\x05\x1a&*\n\x20Structure\x20representing\x20transaction\n\n\
\r\n\x05\x04\x0c\x03\0\x01\x12\x04\x8a\x02\x0c\x1b\n\x0e\n\x06\x04\x0c\
\x03\0\x02\0\x12\x04\x8b\x02\x08$\n\x0f\n\x07\x04\x0c\x03\0\x02\0\x04\
\x12\x04\x8b\x02\x08\x10\n\x0f\n\x07\x04\x0c\x03\0\x02\0\x05\x12\x04\x8b\
\x02\x11\x17\n\x0f\n\x07\x04\x0c\x03\0\x02\0\x01\x12\x04\x8b\x02\x18\x1f\
\n\x0f\n\x07\x04\x0c\x03\0\x02\0\x03\x12\x04\x8b\x02\"#\n\x0e\n\x06\x04\
\x0c\x03\0\x02\x01\x12\x04\x8c\x02\x08(\n\x0f\n\x07\x04\x0c\x03\0\x02\
\x01\x04\x12\x04\x8c\x02\x08\x10\n\x0f\n\x07\x04\x0c\x03\0\x02\x01\x06\
\x12\x04\x8c\x02\x11\x1c\n\x0f\n\x07\x04\x0c\x03\0\x02\x01\x01\x12\x04\
\x8c\x02\x1d#\n\x0f\n\x07\x04\x0c\x03\0\x02\x01\x03\x12\x04\x8c\x02&'\n\
\x0e\n\x06\x04\x0c\x03\0\x02\x02\x12\x04\x8d\x02\x081\n\x0f\n\x07\x04\
\x0c\x03\0\x02\x02\x04\x12\x04\x8d\x02\x08\x10\n\x0f\n\x07\x04\x0c\x03\0\
\x02\x02\x06\x12\x04\x8d\x02\x11\x20\n\x0f\n\x07\x04\x0c\x03\0\x02\x02\
\x01\x12\x04\x8d\x02!,\n\x0f\n\x07\x04\x0c\x03\0\x02\x02\x03\x12\x04\x8d\
\x02/0\n\x0e\n\x06\x04\x0c\x03\0\x02\x03\x12\x04\x8e\x02\x08&\n\x0f\n\
\x07\x04\x0c\x03\0\x02\x03\x04\x12\x04\x8e\x02\x08\x10\n\x0f\n\x07\x04\
\x0c\x03\0\x02\x03\x05\x12\x04\x8e\x02\x11\x17\n\x0f\n\x07\x04\x0c\x03\0\
\x02\x03\x01\x12\x04\x8e\x02\x18!\n\x0f\n\x07\x04\x0c\x03\0\x02\x03\x03\
\x12\x04\x8e\x02$%\n\x0e\n\x06\x04\x0c\x03\0\x02\x04\x12\x04\x8f\x02\x08\
*\n\x0f\n\x07\x04\x0c\x03\0\x02\x04\x04\x12\x04\x8f\x02\x08\x10\n\x0f\n\
\x07\x04\x0c\x03\0\x02\x04\x06\x12\x04\x8f\x02\x11\x1d\n\x0f\n\x07\x04\
\x0c\x03\0\x02\x04\x01\x12\x04\x8f\x02\x1e%\n\x0f\n\x07\x04\x0c\x03\0\
\x02\x04\x03\x12\x04\x8f\x02()\n\x0e\n\x06\x04\x0c\x03\0\x02\x05\x12\x04\
\x90\x02\x08'\n\x0f\n\x07\x04\x0c\x03\0\x02\x05\x04\x12\x04\x90\x02\x08\
\x10\n\x0f\n\x07\x04\x0c\x03\0\x02\x05\x05\x12\x04\x90\x02\x11\x17\n\x0f\
\n\x07\x04\x0c\x03\0\x02\x05\x01\x12\x04\x90\x02\x18\"\n\x0f\n\x07\x04\
\x0c\x03\0\x02\x05\x03\x12\x04\x90\x02%&\n\x0e\n\x06\x04\x0c\x03\0\x02\
\x06\x12\x04\x91\x02\x08(\n\x0f\n\x07\x04\x0c\x03\0\x02\x06\x04\x12\x04\
\x91\x02\x08\x10\n\x0f\n\x07\x04\x0c\x03\0\x02\x06\x05\x12\x04\x91\x02\
\x11\x17\n\x0f\n\x07\x04\x0c\x03\0\x02\x06\x01\x12\x04\x91\x02\x18#\n\
\x0f\n\x07\x04\x0c\x03\0\x02\x06\x03\x12\x04\x91\x02&'\n&\n\x06\x04\x0c\
\x03\0\x02\x07\x12\x04\x92\x02\x08&\"\x16\x20only\x20for\x20Dash,\x20Zca\
sh\n\n\x0f\n\x07\x04\x0c\x03\0\x02\x07\x04\x12\x04\x92\x02\x08\x10\n\x0f\
\n\x07\x04\x0c\x03\0\x02\x07\x05\x12\x04\x92\x02\x11\x16\n\x0f\n\x07\x04\
\x0c\x03\0\x02\x07\x01\x12\x04\x92\x02\x17!\n\x0f\n\x07\x04\x0c\x03\0\
\x02\x07\x03\x12\x04\x92\x02$%\n&\n\x06\x04\x0c\x03\0\x02\x08\x12\x04\
\x93\x02\x08+\"\x16\x20only\x20for\x20Dash,\x20Zcash\n\n\x0f\n\x07\x04\
\x0c\x03\0\x02\x08\x04\x12\x04\x93\x02\x08\x10\n\x0f\n\x07\x04\x0c\x03\0\
\x02\x08\x05\x12\x04\x93\x02\x11\x17\n\x0f\n\x07\x04\x0c\x03\0\x02\x08\
\x01\x12\x04\x93\x02\x18&\n\x0f\n\x07\x04\x0c\x03\0\x02\x08\x03\x12\x04\
\x93\x02)*\n+\n\x06\x04\x0c\x03\0\x02\t\x12\x04\x94\x02\x08$\"\x1b\x20on\
ly\x20for\x20Decred\x20and\x20Zcash\n\n\x0f\n\x07\x04\x0c\x03\0\x02\t\
\x04\x12\x04\x94\x02\x08\x10\n\x0f\n\x07\x04\x0c\x03\0\x02\t\x05\x12\x04\
\x94\x02\x11\x17\n\x0f\n\x07\x04\x0c\x03\0\x02\t\x01\x12\x04\x94\x02\x18\
\x1e\n\x0f\n\x07\x04\x0c\x03\0\x02\t\x03\x12\x04\x94\x02!#\nl\n\x06\x04\
\x0c\x03\0\x02\n\x12\x04\x95\x02\x08:\"\\\x20Zcash\x20only;\x20deprecate\
d\x20in\x202.3.2,\x20the\x20field\x20is\x20not\x20needed,\x20it\x20can\
\x20be\x20derived\x20from\x20`version`\n\n\x0f\n\x07\x04\x0c\x03\0\x02\n\
\x04\x12\x04\x95\x02\x08\x10\n\x0f\n\x07\x04\x0c\x03\0\x02\n\x05\x12\x04\
\x95\x02\x11\x15\n\x0f\n\x07\x04\x0c\x03\0\x02\n\x01\x12\x04\x95\x02\x16\
\"\n\x0f\n\x07\x04\x0c\x03\0\x02\n\x03\x12\x04\x95\x02%'\n\x0f\n\x07\x04\
\x0c\x03\0\x02\n\x08\x12\x04\x95\x02(9\n\x10\n\x08\x04\x0c\x03\0\x02\n\
\x08\x03\x12\x04\x95\x02)8\n1\n\x06\x04\x0c\x03\0\x02\x0b\x12\x04\x96\
\x02\x08.\"!\x20only\x20for\x20Zcash,\x20nVersionGroupId\n\n\x0f\n\x07\
\x04\x0c\x03\0\x02\x0b\x04\x12\x04\x96\x02\x08\x10\n\x0f\n\x07\x04\x0c\
\x03\0\x02\x0b\x05\x12\x04\x96\x02\x11\x17\n\x0f\n\x07\x04\x0c\x03\0\x02\
\x0b\x01\x12\x04\x96\x02\x18(\n\x0f\n\x07\x04\x0c\x03\0\x02\x0b\x03\x12\
\x04\x96\x02+-\n#\n\x06\x04\x0c\x03\0\x02\x0c\x12\x04\x97\x02\x08'\"\x13\
\x20only\x20for\x20Peercoin\n\n\x0f\n\x07\x04\x0c\x03\0\x02\x0c\x04\x12\
\x04\x97\x02\x08\x10\n\x0f\n\x07\x04\x0c\x03\0\x02\x0c\x05\x12\x04\x97\
\x02\x11\x17\n\x0f\n\x07\x04\x0c\x03\0\x02\x0c\x01\x12\x04\x97\x02\x18!\
\n\x0f\n\x07\x04\x0c\x03\0\x02\x0c\x03\x12\x04\x97\x02$&\n+\n\x06\x04\
\x0c\x03\0\x02\r\x12\x04\x98\x02\x08'\"\x1b\x20only\x20for\x20Zcash,\x20\
BRANCH_ID\n\n\x0f\n\x07\x04\x0c\x03\0\x02\r\x04\x12\x04\x98\x02\x08\x10\
\n\x0f\n\x07\x04\x0c\x03\0\x02\r\x05\x12\x04\x98\x02\x11\x17\n\x0f\n\x07\
\x04\x0c\x03\0\x02\r\x01\x12\x04\x98\x02\x18!\n\x0f\n\x07\x04\x0c\x03\0\
\x02\r\x03\x12\x04\x98\x02$&\n>\n\x06\x04\x0c\x03\0\x03\0\x12\x06\x9c\
\x02\x08\xb0\x02\t\x1a,*\n\x20Structure\x20representing\x20transaction\
\x20input\n\n\x0f\n\x07\x04\x0c\x03\0\x03\0\x01\x12\x04\x9c\x02\x10\x1b\
\nB\n\x08\x04\x0c\x03\0\x03\0\x02\0\x12\x04\x9d\x02\x0c*\"0\x20BIP-32\
\x20path\x20to\x20derive\x20the\x20key\x20from\x20master\x20node\n\n\x11\
\n\t\x04\x0c\x03\0\x03\0\x02\0\x04\x12\x04\x9d\x02\x0c\x14\n\x11\n\t\x04\
\x0c\x03\0\x03\0\x02\0\x05\x12\x04\x9d\x02\x15\x1b\n\x11\n\t\x04\x0c\x03\
\0\x03\0\x02\0\x01\x12\x04\x9d\x02\x1c%\n\x11\n\t\x04\x0c\x03\0\x03\0\
\x02\0\x03\x12\x04\x9d\x02()\nN\n\x08\x04\x0c\x03\0\x03\0\x02\x01\x12\
\x04\x9e\x02\x0c)\"<\x20hash\x20of\x20previous\x20transaction\x20output\
\x20to\x20spend\x20by\x20this\x20input\n\n\x11\n\t\x04\x0c\x03\0\x03\0\
\x02\x01\x04\x12\x04\x9e\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\
\x01\x05\x12\x04\x9e\x02\x15\x1a\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x01\
\x01\x12\x04\x9e\x02\x1b$\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x01\x03\x12\
\x04\x9e\x02'(\n5\n\x08\x04\x0c\x03\0\x03\0\x02\x02\x12\x04\x9f\x02\x0c+\
\"#\x20index\x20of\x20previous\x20output\x20to\x20spend\n\n\x11\n\t\x04\
\x0c\x03\0\x03\0\x02\x02\x04\x12\x04\x9f\x02\x0c\x14\n\x11\n\t\x04\x0c\
\x03\0\x03\0\x02\x02\x05\x12\x04\x9f\x02\x15\x1b\n\x11\n\t\x04\x0c\x03\0\
\x03\0\x02\x02\x01\x12\x04\x9f\x02\x1c&\n\x11\n\t\x04\x0c\x03\0\x03\0\
\x02\x02\x03\x12\x04\x9f\x02)*\n:\n\x08\x04\x0c\x03\0\x03\0\x02\x03\x12\
\x04\xa0\x02\x0c*\"(\x20script\x20signature,\x20unset\x20for\x20tx\x20to\
\x20sign\n\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x03\x04\x12\x04\xa0\x02\x0c\
\x14\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x03\x05\x12\x04\xa0\x02\x15\x1a\n\
\x11\n\t\x04\x0c\x03\0\x03\0\x02\x03\x01\x12\x04\xa0\x02\x1b%\n\x11\n\t\
\x04\x0c\x03\0\x03\0\x02\x03\x03\x12\x04\xa0\x02()\n1\n\x08\x04\x0c\x03\
\0\x03\0\x02\x04\x12\x04\xa1\x02\x0c>\"\x1f\x20sequence\x20(default=0xff\
ffffff)\n\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x04\x04\x12\x04\xa1\x02\x0c\
\x14\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x04\x05\x12\x04\xa1\x02\x15\x1b\n\
\x11\n\t\x04\x0c\x03\0\x03\0\x02\x04\x01\x12\x04\xa1\x02\x1c$\n\x11\n\t\
\x04\x0c\x03\0\x03\0\x02\x04\x03\x12\x04\xa1\x02'(\n\x11\n\t\x04\x0c\x03\
\0\x03\0\x02\x04\x08\x12\x04\xa1\x02)=\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\
\x04\x07\x12\x04\xa1\x022<\n4\n\x08\x04\x0c\x03\0\x03\0\x02\x05\x12\x04\
\xa2\x02\x0cL\"\"\x20defines\x20template\x20of\x20input\x20script\n\n\
\x11\n\t\x04\x0c\x03\0\x03\0\x02\x05\x04\x12\x04\xa2\x02\x0c\x14\n\x11\n\
\t\x04\x0c\x03\0\x03\0\x02\x05\x06\x12\x04\xa2\x02\x15$\n\x11\n\t\x04\
\x0c\x03\0\x03\0\x02\x05\x01\x12\x04\xa2\x02%0\n\x11\n\t\x04\x0c\x03\0\
\x03\0\x02\x05\x03\x12\x04\xa2\x0234\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\
\x05\x08\x12\x04\xa2\x025K\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x05\x07\x12\
\x04\xa2\x02>J\nA\n\x08\x04\x0c\x03\0\x03\0\x02\x06\x12\x04\xa3\x02\x0c;\
\"/\x20Filled\x20if\x20input\x20is\x20going\x20to\x20spend\x20multisig\
\x20tx\n\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x06\x04\x12\x04\xa3\x02\x0c\
\x14\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x06\x06\x12\x04\xa3\x02\x15-\n\
\x11\n\t\x04\x0c\x03\0\x03\0\x02\x06\x01\x12\x04\xa3\x02.6\n\x11\n\t\x04\
\x0c\x03\0\x03\0\x02\x06\x03\x12\x04\xa3\x029:\nK\n\x08\x04\x0c\x03\0\
\x03\0\x02\x07\x12\x04\xa4\x02\x0c'\"9\x20amount\x20of\x20previous\x20tr\
ansaction\x20output\x20(for\x20segwit\x20only)\n\n\x11\n\t\x04\x0c\x03\0\
\x03\0\x02\x07\x04\x12\x04\xa4\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\0\
\x02\x07\x05\x12\x04\xa4\x02\x15\x1b\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\
\x07\x01\x12\x04\xa4\x02\x1c\"\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x07\x03\
\x12\x04\xa4\x02%&\n]\n\x08\x04\x0c\x03\0\x03\0\x02\x08\x12\x04\xa5\x02\
\x0c,\"K\x20only\x20for\x20Decred,\x200\x20is\x20a\x20normal\x20transact\
ion\x20while\x201\x20is\x20a\x20stake\x20transaction\n\n\x11\n\t\x04\x0c\
\x03\0\x03\0\x02\x08\x04\x12\x04\xa5\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\
\x03\0\x02\x08\x05\x12\x04\xa5\x02\x15\x1b\n\x11\n\t\x04\x0c\x03\0\x03\0\
\x02\x08\x01\x12\x04\xa5\x02\x1c'\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x08\
\x03\x12\x04\xa5\x02*+\n\xd7\x02\n\x08\x04\x0c\x03\0\x03\0\x02\t\x12\x04\
\xa9\x02\x0c(\x1a\x96\x02\x20optional\x20uint32\x20decred_script_version\
\x20=\x2010;\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20//\x20only\x20for\x20Decred\x20\
\x20//\x20deprecated\x20->\x20only\x200\x20is\x20supported\n\x20optional\
\x20bytes\x20prev_block_hash_bip115\x20=\x2011;\x20\x20\x20\x20\x20//\
\x20BIP-115\x20support\x20dropped\n\x20optional\x20uint32\x20prev_block_\
height_bip115\x20=\x2012;\x20\x20//\x20BIP-115\x20support\x20dropped\n\"\
,\x20witness\x20data,\x20only\x20set\x20for\x20EXTERNAL\x20inputs\n\n\
\x11\n\t\x04\x0c\x03\0\x03\0\x02\t\x04\x12\x04\xa9\x02\x0c\x14\n\x11\n\t\
\x04\x0c\x03\0\x03\0\x02\t\x05\x12\x04\xa9\x02\x15\x1a\n\x11\n\t\x04\x0c\
\x03\0\x03\0\x02\t\x01\x12\x04\xa9\x02\x1b\"\n\x11\n\t\x04\x0c\x03\0\x03\
\0\x02\t\x03\x12\x04\xa9\x02%'\nN\n\x08\x04\x0c\x03\0\x03\0\x02\n\x12\
\x04\xaa\x02\x0c0\"<\x20SLIP-0019\x20proof\x20of\x20ownership,\x20only\
\x20set\x20for\x20EXTERNAL\x20inputs\n\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\
\n\x04\x12\x04\xaa\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\n\x05\
\x12\x04\xaa\x02\x15\x1a\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\n\x01\x12\x04\
\xaa\x02\x1b*\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\n\x03\x12\x04\xaa\x02-/\
\nQ\n\x08\x04\x0c\x03\0\x03\0\x02\x0b\x12\x04\xab\x02\x0c0\"?\x20optiona\
l\x20commitment\x20data\x20for\x20the\x20SLIP-0019\x20proof\x20of\x20own\
ership\n\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x0b\x04\x12\x04\xab\x02\x0c\
\x14\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x0b\x05\x12\x04\xab\x02\x15\x1a\n\
\x11\n\t\x04\x0c\x03\0\x03\0\x02\x0b\x01\x12\x04\xab\x02\x1b*\n\x11\n\t\
\x04\x0c\x03\0\x03\0\x02\x0b\x03\x12\x04\xab\x02-/\n\x81\x01\n\x08\x04\
\x0c\x03\0\x03\0\x02\x0c\x12\x04\xac\x02\x0c*\"o\x20tx_hash\x20of\x20the\
\x20original\x20transaction\x20where\x20this\x20input\x20was\x20spent\
\x20(used\x20when\x20creating\x20a\x20replacement\x20transaction)\n\n\
\x11\n\t\x04\x0c\x03\0\x03\0\x02\x0c\x04\x12\x04\xac\x02\x0c\x14\n\x11\n\
\t\x04\x0c\x03\0\x03\0\x02\x0c\x05\x12\x04\xac\x02\x15\x1a\n\x11\n\t\x04\
\x0c\x03\0\x03\0\x02\x0c\x01\x12\x04\xac\x02\x1b$\n\x11\n\t\x04\x0c\x03\
\0\x03\0\x02\x0c\x03\x12\x04\xac\x02')\nq\n\x08\x04\x0c\x03\0\x03\0\x02\
\r\x12\x04\xad\x02\x0c,\"_\x20index\x20of\x20the\x20input\x20in\x20the\
\x20original\x20transaction\x20(used\x20when\x20creating\x20a\x20replace\
ment\x20transaction)\n\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\r\x04\x12\x04\
\xad\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\r\x05\x12\x04\xad\x02\
\x15\x1b\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\r\x01\x12\x04\xad\x02\x1c&\n\
\x11\n\t\x04\x0c\x03\0\x03\0\x02\r\x03\x12\x04\xad\x02)+\nb\n\x08\x04\
\x0c\x03\0\x03\0\x02\x0e\x12\x04\xae\x02\x0cF\"P\x20if\x20not\x20None\
\x20this\x20holds\x20the\x20type\x20of\x20stake\x20spend:\x20revocation\
\x20or\x20stake\x20generation\n\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x0e\
\x04\x12\x04\xae\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x0e\x06\
\x12\x04\xae\x02\x15+\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x0e\x01\x12\x04\
\xae\x02,@\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x0e\x03\x12\x04\xae\x02CE\n\
h\n\x08\x04\x0c\x03\0\x03\0\x02\x0f\x12\x04\xaf\x02\x0c.\"V\x20scriptPub\
Key\x20of\x20the\x20previous\x20output\x20spent\x20by\x20this\x20input,\
\x20only\x20set\x20of\x20EXTERNAL\x20inputs\n\n\x11\n\t\x04\x0c\x03\0\
\x03\0\x02\x0f\x04\x12\x04\xaf\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\0\
\x02\x0f\x05\x12\x04\xaf\x02\x15\x1a\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\
\x0f\x01\x12\x04\xaf\x02\x1b(\n\x11\n\t\x04\x0c\x03\0\x03\0\x02\x0f\x03\
\x12\x04\xaf\x02+-\nH\n\x06\x04\x0c\x03\0\x03\x01\x12\x06\xb4\x02\x08\
\xb8\x02\t\x1a6*\n\x20Structure\x20representing\x20compiled\x20transacti\
on\x20output\n\n\x0f\n\x07\x04\x0c\x03\0\x03\x01\x01\x12\x04\xb4\x02\x10\
\x1f\n\x10\n\x08\x04\x0c\x03\0\x03\x01\x02\0\x12\x04\xb5\x02\x0c'\n\x11\
\n\t\x04\x0c\x03\0\x03\x01\x02\0\x04\x12\x04\xb5\x02\x0c\x14\n\x11\n\t\
\x04\x0c\x03\0\x03\x01\x02\0\x05\x12\x04\xb5\x02\x15\x1b\n\x11\n\t\x04\
\x0c\x03\0\x03\x01\x02\0\x01\x12\x04\xb5\x02\x1c\"\n\x11\n\t\x04\x0c\x03\
\0\x03\x01\x02\0\x03\x12\x04\xb5\x02%&\n\x10\n\x08\x04\x0c\x03\0\x03\x01\
\x02\x01\x12\x04\xb6\x02\x0c-\n\x11\n\t\x04\x0c\x03\0\x03\x01\x02\x01\
\x04\x12\x04\xb6\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\x01\x02\x01\x05\
\x12\x04\xb6\x02\x15\x1a\n\x11\n\t\x04\x0c\x03\0\x03\x01\x02\x01\x01\x12\
\x04\xb6\x02\x1b(\n\x11\n\t\x04\x0c\x03\0\x03\x01\x02\x01\x03\x12\x04\
\xb6\x02+,\nB\n\x08\x04\x0c\x03\0\x03\x01\x02\x02\x12\x04\xb7\x02\x0c6\"\
0\x20only\x20for\x20Decred,\x20currently\x20only\x200\x20is\x20supported\
\n\n\x11\n\t\x04\x0c\x03\0\x03\x01\x02\x02\x04\x12\x04\xb7\x02\x0c\x14\n\
\x11\n\t\x04\x0c\x03\0\x03\x01\x02\x02\x05\x12\x04\xb7\x02\x15\x1b\n\x11\
\n\t\x04\x0c\x03\0\x03\x01\x02\x02\x01\x12\x04\xb7\x02\x1c1\n\x11\n\t\
\x04\x0c\x03\0\x03\x01\x02\x02\x03\x12\x04\xb7\x0245\n?\n\x06\x04\x0c\
\x03\0\x03\x02\x12\x06\xbc\x02\x08\xc8\x02\t\x1a-*\n\x20Structure\x20rep\
resenting\x20transaction\x20output\n\n\x0f\n\x07\x04\x0c\x03\0\x03\x02\
\x01\x12\x04\xbc\x02\x10\x1c\n:\n\x08\x04\x0c\x03\0\x03\x02\x02\0\x12\
\x04\xbd\x02\x0c(\"(\x20target\x20coin\x20address\x20in\x20Base58\x20enc\
oding\n\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\0\x04\x12\x04\xbd\x02\x0c\
\x14\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\0\x05\x12\x04\xbd\x02\x15\x1b\n\
\x11\n\t\x04\x0c\x03\0\x03\x02\x02\0\x01\x12\x04\xbd\x02\x1c#\n\x11\n\t\
\x04\x0c\x03\0\x03\x02\x02\0\x03\x12\x04\xbd\x02&'\nf\n\x08\x04\x0c\x03\
\0\x03\x02\x02\x01\x12\x04\xbe\x02\x0c*\"T\x20BIP-32\x20path\x20to\x20de\
rive\x20the\x20key\x20from\x20master\x20node;\x20has\x20higher\x20priori\
ty\x20than\x20\"address\"\n\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x01\x04\
\x12\x04\xbe\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x01\x05\x12\
\x04\xbe\x02\x15\x1b\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x01\x01\x12\x04\
\xbe\x02\x1c%\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x01\x03\x12\x04\xbe\
\x02()\n/\n\x08\x04\x0c\x03\0\x03\x02\x02\x02\x12\x04\xbf\x02\x0c'\"\x1d\
\x20amount\x20to\x20spend\x20in\x20satoshis\n\n\x11\n\t\x04\x0c\x03\0\
\x03\x02\x02\x02\x04\x12\x04\xbf\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\
\x02\x02\x02\x05\x12\x04\xbf\x02\x15\x1b\n\x11\n\t\x04\x0c\x03\0\x03\x02\
\x02\x02\x01\x12\x04\xbf\x02\x1c\"\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\
\x02\x03\x12\x04\xbf\x02%&\n&\n\x08\x04\x0c\x03\0\x03\x02\x02\x03\x12\
\x04\xc0\x02\x0cM\"\x14\x20output\x20script\x20type\n\n\x11\n\t\x04\x0c\
\x03\0\x03\x02\x02\x03\x04\x12\x04\xc0\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\
\0\x03\x02\x02\x03\x06\x12\x04\xc0\x02\x15%\n\x11\n\t\x04\x0c\x03\0\x03\
\x02\x02\x03\x01\x12\x04\xc0\x02&1\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\
\x03\x03\x12\x04\xc0\x0245\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x03\x08\
\x12\x04\xc0\x026L\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x03\x07\x12\x04\
\xc0\x02?K\nO\n\x08\x04\x0c\x03\0\x03\x02\x02\x04\x12\x04\xc1\x02\x0c;\"\
=\x20defines\x20multisig\x20address;\x20script_type\x20must\x20be\x20PAY\
TOMULTISIG\n\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x04\x04\x12\x04\xc1\x02\
\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x04\x06\x12\x04\xc1\x02\x15\
-\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x04\x01\x12\x04\xc1\x02.6\n\x11\n\
\t\x04\x0c\x03\0\x03\x02\x02\x04\x03\x12\x04\xc1\x029:\n_\n\x08\x04\x0c\
\x03\0\x03\x02\x02\x05\x12\x04\xc2\x02\x0c.\"M\x20defines\x20op_return\
\x20data;\x20script_type\x20must\x20be\x20PAYTOOPRETURN,\x20amount\x20mu\
st\x20be\x200\n\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x05\x04\x12\x04\xc2\
\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x05\x05\x12\x04\xc2\x02\
\x15\x1a\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x05\x01\x12\x04\xc2\x02\x1b\
)\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x05\x03\x12\x04\xc2\x02,-\n\x83\
\x03\n\x08\x04\x0c\x03\0\x03\x02\x02\x06\x12\x04\xc6\x02\x0c*\x1a\xfc\
\x01\x20optional\x20uint32\x20decred_script_version\x20=\x207;\x20\x20\
\x20\x20\x20\x20//\x20only\x20for\x20Decred\x20\x20//\x20deprecated\x20-\
>\x20only\x200\x20is\x20supported\n\x20optional\x20bytes\x20block_hash_b\
ip115\x20=\x208;\x20\x20\x20\x20\x20\x20\x20\x20//\x20BIP-115\x20support\
\x20dropped\n\x20optional\x20uint32\x20block_height_bip115\x20=\x209;\
\x20\x20\x20\x20\x20//\x20BIP-115\x20support\x20dropped\n\"r\x20tx_hash\
\x20of\x20the\x20original\x20transaction\x20where\x20this\x20output\x20w\
as\x20present\x20(used\x20when\x20creating\x20a\x20replacement\x20transa\
ction)\n\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x06\x04\x12\x04\xc6\x02\x0c\
\x14\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x06\x05\x12\x04\xc6\x02\x15\x1a\
\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\x06\x01\x12\x04\xc6\x02\x1b$\n\x11\
\n\t\x04\x0c\x03\0\x03\x02\x02\x06\x03\x12\x04\xc6\x02')\nr\n\x08\x04\
\x0c\x03\0\x03\x02\x02\x07\x12\x04\xc7\x02\x0c,\"`\x20index\x20of\x20the\
\x20output\x20in\x20the\x20original\x20transaction\x20(used\x20when\x20c\
reating\x20a\x20replacement\x20transaction)\n\n\x11\n\t\x04\x0c\x03\0\
\x03\x02\x02\x07\x04\x12\x04\xc7\x02\x0c\x14\n\x11\n\t\x04\x0c\x03\0\x03\
\x02\x02\x07\x05\x12\x04\xc7\x02\x15\x1b\n\x11\n\t\x04\x0c\x03\0\x03\x02\
\x02\x07\x01\x12\x04\xc7\x02\x1c&\n\x11\n\t\x04\x0c\x03\0\x03\x02\x02\
\x07\x03\x12\x04\xc7\x02)+\n\x86\x01\n\x02\x04\r\x12\x06\xd2\x02\0\xe4\
\x02\x01\x1ax*\x20Data\x20type\x20for\x20transaction\x20input\x20to\x20b\
e\x20signed.\n\n\x20When\x20adding\x20fields,\x20take\x20care\x20to\x20n\
ot\x20conflict\x20with\x20PrevInput\n\n\x20@embed\n\n\x0b\n\x03\x04\r\
\x01\x12\x04\xd2\x02\x08\x0f\n>\n\x04\x04\r\x02\0\x12\x04\xd3\x02\x04\"\
\"0\x20BIP-32\x20path\x20to\x20derive\x20the\x20key\x20from\x20master\
\x20node\n\n\r\n\x05\x04\r\x02\0\x04\x12\x04\xd3\x02\x04\x0c\n\r\n\x05\
\x04\r\x02\0\x05\x12\x04\xd3\x02\r\x13\n\r\n\x05\x04\r\x02\0\x01\x12\x04\
\xd3\x02\x14\x1d\n\r\n\x05\x04\r\x02\0\x03\x12\x04\xd3\x02\x20!\nJ\n\x04\
\x04\r\x02\x01\x12\x04\xd4\x02\x04!\"<\x20hash\x20of\x20previous\x20tran\
saction\x20output\x20to\x20spend\x20by\x20this\x20input\n\n\r\n\x05\x04\
\r\x02\x01\x04\x12\x04\xd4\x02\x04\x0c\n\r\n\x05\x04\r\x02\x01\x05\x12\
\x04\xd4\x02\r\x12\n\r\n\x05\x04\r\x02\x01\x01\x12\x04\xd4\x02\x13\x1c\n\
\r\n\x05\x04\r\x02\x01\x03\x12\x04\xd4\x02\x1f\x20\n1\n\x04\x04\r\x02\
\x02\x12\x04\xd5\x02\x04#\"#\x20index\x20of\x20previous\x20output\x20to\
\x20spend\n\n\r\n\x05\x04\r\x02\x02\x04\x12\x04\xd5\x02\x04\x0c\n\r\n\
\x05\x04\r\x02\x02\x05\x12\x04\xd5\x02\r\x13\n\r\n\x05\x04\r\x02\x02\x01\
\x12\x04\xd5\x02\x14\x1e\n\r\n\x05\x04\r\x02\x02\x03\x12\x04\xd5\x02!\"\
\n>\n\x04\x04\r\x02\x03\x12\x04\xd6\x02\x04\"\"0\x20script\x20signature,\
\x20only\x20set\x20for\x20EXTERNAL\x20inputs\n\n\r\n\x05\x04\r\x02\x03\
\x04\x12\x04\xd6\x02\x04\x0c\n\r\n\x05\x04\r\x02\x03\x05\x12\x04\xd6\x02\
\r\x12\n\r\n\x05\x04\r\x02\x03\x01\x12\x04\xd6\x02\x13\x1d\n\r\n\x05\x04\
\r\x02\x03\x03\x12\x04\xd6\x02\x20!\n\x18\n\x04\x04\r\x02\x04\x12\x04\
\xd7\x02\x046\"\n\x20sequence\n\n\r\n\x05\x04\r\x02\x04\x04\x12\x04\xd7\
\x02\x04\x0c\n\r\n\x05\x04\r\x02\x04\x05\x12\x04\xd7\x02\r\x13\n\r\n\x05\
\x04\r\x02\x04\x01\x12\x04\xd7\x02\x14\x1c\n\r\n\x05\x04\r\x02\x04\x03\
\x12\x04\xd7\x02\x1f\x20\n\r\n\x05\x04\r\x02\x04\x08\x12\x04\xd7\x02!5\n\
\r\n\x05\x04\r\x02\x04\x07\x12\x04\xd7\x02*4\n0\n\x04\x04\r\x02\x05\x12\
\x04\xd8\x02\x04D\"\"\x20defines\x20template\x20of\x20input\x20script\n\
\n\r\n\x05\x04\r\x02\x05\x04\x12\x04\xd8\x02\x04\x0c\n\r\n\x05\x04\r\x02\
\x05\x06\x12\x04\xd8\x02\r\x1c\n\r\n\x05\x04\r\x02\x05\x01\x12\x04\xd8\
\x02\x1d(\n\r\n\x05\x04\r\x02\x05\x03\x12\x04\xd8\x02+,\n\r\n\x05\x04\r\
\x02\x05\x08\x12\x04\xd8\x02-C\n\r\n\x05\x04\r\x02\x05\x07\x12\x04\xd8\
\x026B\n=\n\x04\x04\r\x02\x06\x12\x04\xd9\x02\x043\"/\x20Filled\x20if\
\x20input\x20is\x20going\x20to\x20spend\x20multisig\x20tx\n\n\r\n\x05\
\x04\r\x02\x06\x04\x12\x04\xd9\x02\x04\x0c\n\r\n\x05\x04\r\x02\x06\x06\
\x12\x04\xd9\x02\r%\n\r\n\x05\x04\r\x02\x06\x01\x12\x04\xd9\x02&.\n\r\n\
\x05\x04\r\x02\x06\x03\x12\x04\xd9\x0212\n5\n\x04\x04\r\x02\x07\x12\x04\
\xda\x02\x04\x1f\"'\x20amount\x20of\x20previous\x20transaction\x20output\
\n\n\r\n\x05\x04\r\x02\x07\x04\x12\x04\xda\x02\x04\x0c\n\r\n\x05\x04\r\
\x02\x07\x05\x12\x04\xda\x02\r\x13\n\r\n\x05\x04\r\x02\x07\x01\x12\x04\
\xda\x02\x14\x1a\n\r\n\x05\x04\r\x02\x07\x03\x12\x04\xda\x02\x1d\x1e\nY\
\n\x04\x04\r\x02\x08\x12\x04\xdb\x02\x04$\"K\x20only\x20for\x20Decred,\
\x200\x20is\x20a\x20normal\x20transaction\x20while\x201\x20is\x20a\x20st\
ake\x20transaction\n\n\r\n\x05\x04\r\x02\x08\x04\x12\x04\xdb\x02\x04\x0c\
\n\r\n\x05\x04\r\x02\x08\x05\x12\x04\xdb\x02\r\x13\n\r\n\x05\x04\r\x02\
\x08\x01\x12\x04\xdb\x02\x14\x1f\n\r\n\x05\x04\r\x02\x08\x03\x12\x04\xdb\
\x02\"#\nP\n\x03\x04\r\t\x12\x04\xdc\x02\r\x18\"C\x20fields\x20which\x20\
are\x20in\x20use,\x20or\x20have\x20been\x20in\x20the\x20past,\x20in\x20T\
xInputType\n\n\x0c\n\x04\x04\r\t\0\x12\x04\xdc\x02\r\x0f\n\r\n\x05\x04\r\
\t\0\x01\x12\x04\xdc\x02\r\x0f\n\r\n\x05\x04\r\t\0\x02\x12\x04\xdc\x02\r\
\x0f\n\x0c\n\x04\x04\r\t\x01\x12\x04\xdc\x02\x11\x13\n\r\n\x05\x04\r\t\
\x01\x01\x12\x04\xdc\x02\x11\x13\n\r\n\x05\x04\r\t\x01\x02\x12\x04\xdc\
\x02\x11\x13\n\x0c\n\x04\x04\r\t\x02\x12\x04\xdc\x02\x15\x17\n\r\n\x05\
\x04\r\t\x02\x01\x12\x04\xdc\x02\x15\x17\n\r\n\x05\x04\r\t\x02\x02\x12\
\x04\xdc\x02\x15\x17\n:\n\x04\x04\r\x02\t\x12\x04\xdd\x02\x04\x20\",\x20\
witness\x20data,\x20only\x20set\x20for\x20EXTERNAL\x20inputs\n\n\r\n\x05\
\x04\r\x02\t\x04\x12\x04\xdd\x02\x04\x0c\n\r\n\x05\x04\r\x02\t\x05\x12\
\x04\xdd\x02\r\x12\n\r\n\x05\x04\r\x02\t\x01\x12\x04\xdd\x02\x13\x1a\n\r\
\n\x05\x04\r\x02\t\x03\x12\x04\xdd\x02\x1d\x1f\nJ\n\x04\x04\r\x02\n\x12\
\x04\xde\x02\x04(\"<\x20SLIP-0019\x20proof\x20of\x20ownership,\x20only\
\x20set\x20for\x20EXTERNAL\x20inputs\n\n\r\n\x05\x04\r\x02\n\x04\x12\x04\
\xde\x02\x04\x0c\n\r\n\x05\x04\r\x02\n\x05\x12\x04\xde\x02\r\x12\n\r\n\
\x05\x04\r\x02\n\x01\x12\x04\xde\x02\x13\"\n\r\n\x05\x04\r\x02\n\x03\x12\
\x04\xde\x02%'\nM\n\x04\x04\r\x02\x0b\x12\x04\xdf\x02\x04(\"?\x20optiona\
l\x20commitment\x20data\x20for\x20the\x20SLIP-0019\x20proof\x20of\x20own\
ership\n\n\r\n\x05\x04\r\x02\x0b\x04\x12\x04\xdf\x02\x04\x0c\n\r\n\x05\
\x04\r\x02\x0b\x05\x12\x04\xdf\x02\r\x12\n\r\n\x05\x04\r\x02\x0b\x01\x12\
\x04\xdf\x02\x13\"\n\r\n\x05\x04\r\x02\x0b\x03\x12\x04\xdf\x02%'\n}\n\
\x04\x04\r\x02\x0c\x12\x04\xe0\x02\x04\"\"o\x20tx_hash\x20of\x20the\x20o\
riginal\x20transaction\x20where\x20this\x20input\x20was\x20spent\x20(use\
d\x20when\x20creating\x20a\x20replacement\x20transaction)\n\n\r\n\x05\
\x04\r\x02\x0c\x04\x12\x04\xe0\x02\x04\x0c\n\r\n\x05\x04\r\x02\x0c\x05\
\x12\x04\xe0\x02\r\x12\n\r\n\x05\x04\r\x02\x0c\x01\x12\x04\xe0\x02\x13\
\x1c\n\r\n\x05\x04\r\x02\x0c\x03\x12\x04\xe0\x02\x1f!\nm\n\x04\x04\r\x02\
\r\x12\x04\xe1\x02\x04$\"_\x20index\x20of\x20the\x20input\x20in\x20the\
\x20original\x20transaction\x20(used\x20when\x20creating\x20a\x20replace\
ment\x20transaction)\n\n\r\n\x05\x04\r\x02\r\x04\x12\x04\xe1\x02\x04\x0c\
\n\r\n\x05\x04\r\x02\r\x05\x12\x04\xe1\x02\r\x13\n\r\n\x05\x04\r\x02\r\
\x01\x12\x04\xe1\x02\x14\x1e\n\r\n\x05\x04\r\x02\r\x03\x12\x04\xe1\x02!#\
\n^\n\x04\x04\r\x02\x0e\x12\x04\xe2\x02\x04>\"P\x20if\x20not\x20None\x20\
this\x20holds\x20the\x20type\x20of\x20stake\x20spend:\x20revocation\x20o\
r\x20stake\x20generation\n\n\r\n\x05\x04\r\x02\x0e\x04\x12\x04\xe2\x02\
\x04\x0c\n\r\n\x05\x04\r\x02\x0e\x06\x12\x04\xe2\x02\r#\n\r\n\x05\x04\r\
\x02\x0e\x01\x12\x04\xe2\x02$8\n\r\n\x05\x04\r\x02\x0e\x03\x12\x04\xe2\
\x02;=\nd\n\x04\x04\r\x02\x0f\x12\x04\xe3\x02\x04&\"V\x20scriptPubKey\
\x20of\x20the\x20previous\x20output\x20spent\x20by\x20this\x20input,\x20\
only\x20set\x20of\x20EXTERNAL\x20inputs\n\n\r\n\x05\x04\r\x02\x0f\x04\
\x12\x04\xe3\x02\x04\x0c\n\r\n\x05\x04\r\x02\x0f\x05\x12\x04\xe3\x02\r\
\x12\n\r\n\x05\x04\r\x02\x0f\x01\x12\x04\xe3\x02\x13\x20\n\r\n\x05\x04\r\
\x02\x0f\x03\x12\x04\xe3\x02#%\nG\n\x02\x04\x0e\x12\x06\xe9\x02\0\xf3\
\x02\x01\x1a9*\x20Data\x20type\x20for\x20transaction\x20output\x20to\x20\
be\x20signed.\n\x20@embed\n\n\x0b\n\x03\x04\x0e\x01\x12\x04\xe9\x02\x08\
\x10\nX\n\x04\x04\x0e\x02\0\x12\x04\xea\x02\x04\x20\"J\x20destination\
\x20address\x20in\x20Base58\x20encoding;\x20script_type\x20must\x20be\
\x20PAYTOADDRESS\n\n\r\n\x05\x04\x0e\x02\0\x04\x12\x04\xea\x02\x04\x0c\n\
\r\n\x05\x04\x0e\x02\0\x05\x12\x04\xea\x02\r\x13\n\r\n\x05\x04\x0e\x02\0\
\x01\x12\x04\xea\x02\x14\x1b\n\r\n\x05\x04\x0e\x02\0\x03\x12\x04\xea\x02\
\x1e\x1f\nQ\n\x04\x04\x0e\x02\x01\x12\x04\xeb\x02\x04\"\"C\x20BIP-32\x20\
path\x20to\x20derive\x20the\x20destination\x20(used\x20for\x20change\x20\
addresses)\n\n\r\n\x05\x04\x0e\x02\x01\x04\x12\x04\xeb\x02\x04\x0c\n\r\n\
\x05\x04\x0e\x02\x01\x05\x12\x04\xeb\x02\r\x13\n\r\n\x05\x04\x0e\x02\x01\
\x01\x12\x04\xeb\x02\x14\x1d\n\r\n\x05\x04\x0e\x02\x01\x03\x12\x04\xeb\
\x02\x20!\n+\n\x04\x04\x0e\x02\x02\x12\x04\xec\x02\x04\x1f\"\x1d\x20amou\
nt\x20to\x20spend\x20in\x20satoshis\n\n\r\n\x05\x04\x0e\x02\x02\x04\x12\
\x04\xec\x02\x04\x0c\n\r\n\x05\x04\x0e\x02\x02\x05\x12\x04\xec\x02\r\x13\
\n\r\n\x05\x04\x0e\x02\x02\x01\x12\x04\xec\x02\x14\x1a\n\r\n\x05\x04\x0e\
\x02\x02\x03\x12\x04\xec\x02\x1d\x1e\n\"\n\x04\x04\x0e\x02\x03\x12\x04\
\xed\x02\x04E\"\x14\x20output\x20script\x20type\n\n\r\n\x05\x04\x0e\x02\
\x03\x04\x12\x04\xed\x02\x04\x0c\n\r\n\x05\x04\x0e\x02\x03\x06\x12\x04\
\xed\x02\r\x1d\n\r\n\x05\x04\x0e\x02\x03\x01\x12\x04\xed\x02\x1e)\n\r\n\
\x05\x04\x0e\x02\x03\x03\x12\x04\xed\x02,-\n\r\n\x05\x04\x0e\x02\x03\x08\
\x12\x04\xed\x02.D\n\r\n\x05\x04\x0e\x02\x03\x07\x12\x04\xed\x027C\nK\n\
\x04\x04\x0e\x02\x04\x12\x04\xee\x02\x043\"=\x20defines\x20multisig\x20a\
ddress;\x20script_type\x20must\x20be\x20PAYTOMULTISIG\n\n\r\n\x05\x04\
\x0e\x02\x04\x04\x12\x04\xee\x02\x04\x0c\n\r\n\x05\x04\x0e\x02\x04\x06\
\x12\x04\xee\x02\r%\n\r\n\x05\x04\x0e\x02\x04\x01\x12\x04\xee\x02&.\n\r\
\n\x05\x04\x0e\x02\x04\x03\x12\x04\xee\x0212\n[\n\x04\x04\x0e\x02\x05\
\x12\x04\xef\x02\x04&\"M\x20defines\x20op_return\x20data;\x20script_type\
\x20must\x20be\x20PAYTOOPRETURN,\x20amount\x20must\x20be\x200\n\n\r\n\
\x05\x04\x0e\x02\x05\x04\x12\x04\xef\x02\x04\x0c\n\r\n\x05\x04\x0e\x02\
\x05\x05\x12\x04\xef\x02\r\x12\n\r\n\x05\x04\x0e\x02\x05\x01\x12\x04\xef\
\x02\x13!\n\r\n\x05\x04\x0e\x02\x05\x03\x12\x04\xef\x02$%\nQ\n\x03\x04\
\x0e\t\x12\x04\xf0\x02\r\x15\"D\x20fields\x20which\x20are\x20in\x20use,\
\x20or\x20have\x20been\x20in\x20the\x20past,\x20in\x20TxOutputType\n\n\
\x0c\n\x04\x04\x0e\t\0\x12\x04\xf0\x02\r\x0e\n\r\n\x05\x04\x0e\t\0\x01\
\x12\x04\xf0\x02\r\x0e\n\r\n\x05\x04\x0e\t\0\x02\x12\x04\xf0\x02\r\x0e\n\
\x0c\n\x04\x04\x0e\t\x01\x12\x04\xf0\x02\x10\x11\n\r\n\x05\x04\x0e\t\x01\
\x01\x12\x04\xf0\x02\x10\x11\n\r\n\x05\x04\x0e\t\x01\x02\x12\x04\xf0\x02\
\x10\x11\n\x0c\n\x04\x04\x0e\t\x02\x12\x04\xf0\x02\x13\x14\n\r\n\x05\x04\
\x0e\t\x02\x01\x12\x04\xf0\x02\x13\x14\n\r\n\x05\x04\x0e\t\x02\x02\x12\
\x04\xf0\x02\x13\x14\n\x80\x01\n\x04\x04\x0e\x02\x06\x12\x04\xf1\x02\x04\
\"\"r\x20tx_hash\x20of\x20the\x20original\x20transaction\x20where\x20thi\
s\x20output\x20was\x20present\x20(used\x20when\x20creating\x20a\x20repla\
cement\x20transaction)\n\n\r\n\x05\x04\x0e\x02\x06\x04\x12\x04\xf1\x02\
\x04\x0c\n\r\n\x05\x04\x0e\x02\x06\x05\x12\x04\xf1\x02\r\x12\n\r\n\x05\
\x04\x0e\x02\x06\x01\x12\x04\xf1\x02\x13\x1c\n\r\n\x05\x04\x0e\x02\x06\
\x03\x12\x04\xf1\x02\x1f!\nn\n\x04\x04\x0e\x02\x07\x12\x04\xf2\x02\x04$\
\"`\x20index\x20of\x20the\x20output\x20in\x20the\x20original\x20transact\
ion\x20(used\x20when\x20creating\x20a\x20replacement\x20transaction)\n\n\
\r\n\x05\x04\x0e\x02\x07\x04\x12\x04\xf2\x02\x04\x0c\n\r\n\x05\x04\x0e\
\x02\x07\x05\x12\x04\xf2\x02\r\x13\n\r\n\x05\x04\x0e\x02\x07\x01\x12\x04\
\xf2\x02\x14\x1e\n\r\n\x05\x04\x0e\x02\x07\x03\x12\x04\xf2\x02!#\no\n\
\x02\x04\x0f\x12\x06\xf8\x02\0\x85\x03\x01\x1aa*\x20Data\x20type\x20for\
\x20metadata\x20about\x20previous\x20transaction\x20which\x20contains\
\x20the\x20UTXO\x20being\x20spent.\n\x20@embed\n\n\x0b\n\x03\x04\x0f\x01\
\x12\x04\xf8\x02\x08\x0e\n\x0c\n\x04\x04\x0f\x02\0\x12\x04\xf9\x02\x04\
\x20\n\r\n\x05\x04\x0f\x02\0\x04\x12\x04\xf9\x02\x04\x0c\n\r\n\x05\x04\
\x0f\x02\0\x05\x12\x04\xf9\x02\r\x13\n\r\n\x05\x04\x0f\x02\0\x01\x12\x04\
\xf9\x02\x14\x1b\n\r\n\x05\x04\x0f\x02\0\x03\x12\x04\xf9\x02\x1e\x1f\n\
\x0c\n\x04\x04\x0f\x02\x01\x12\x04\xfa\x02\x04\"\n\r\n\x05\x04\x0f\x02\
\x01\x04\x12\x04\xfa\x02\x04\x0c\n\r\n\x05\x04\x0f\x02\x01\x05\x12\x04\
\xfa\x02\r\x13\n\r\n\x05\x04\x0f\x02\x01\x01\x12\x04\xfa\x02\x14\x1d\n\r\
\n\x05\x04\x0f\x02\x01\x03\x12\x04\xfa\x02\x20!\n\x0c\n\x04\x04\x0f\x02\
\x02\x12\x04\xfb\x02\x04%\n\r\n\x05\x04\x0f\x02\x02\x04\x12\x04\xfb\x02\
\x04\x0c\n\r\n\x05\x04\x0f\x02\x02\x05\x12\x04\xfb\x02\r\x13\n\r\n\x05\
\x04\x0f\x02\x02\x01\x12\x04\xfb\x02\x14\x20\n\r\n\x05\x04\x0f\x02\x02\
\x03\x12\x04\xfb\x02#$\n\x0c\n\x04\x04\x0f\x02\x03\x12\x04\xfc\x02\x04&\
\n\r\n\x05\x04\x0f\x02\x03\x04\x12\x04\xfc\x02\x04\x0c\n\r\n\x05\x04\x0f\
\x02\x03\x05\x12\x04\xfc\x02\r\x13\n\r\n\x05\x04\x0f\x02\x03\x01\x12\x04\
\xfc\x02\x14!\n\r\n\x05\x04\x0f\x02\x03\x03\x12\x04\xfc\x02$%\n$\n\x04\
\x04\x0f\x02\x04\x12\x04\xfd\x02\x043\"\x16\x20only\x20for\x20Dash,\x20Z\
cash\n\n\r\n\x05\x04\x0f\x02\x04\x04\x12\x04\xfd\x02\x04\x0c\n\r\n\x05\
\x04\x0f\x02\x04\x05\x12\x04\xfd\x02\r\x13\n\r\n\x05\x04\x0f\x02\x04\x01\
\x12\x04\xfd\x02\x14\"\n\r\n\x05\x04\x0f\x02\x04\x03\x12\x04\xfd\x02%&\n\
\r\n\x05\x04\x0f\x02\x04\x08\x12\x04\xfd\x02'2\n\r\n\x05\x04\x0f\x02\x04\
\x07\x12\x04\xfd\x0201\n)\n\x04\x04\x0f\x02\x05\x12\x04\xfe\x02\x04\x20\
\"\x1b\x20only\x20for\x20Decred\x20and\x20Zcash\n\n\r\n\x05\x04\x0f\x02\
\x05\x04\x12\x04\xfe\x02\x04\x0c\n\r\n\x05\x04\x0f\x02\x05\x05\x12\x04\
\xfe\x02\r\x13\n\r\n\x05\x04\x0f\x02\x05\x01\x12\x04\xfe\x02\x14\x1a\n\r\
\n\x05\x04\x0f\x02\x05\x03\x12\x04\xfe\x02\x1d\x1f\n/\n\x04\x04\x0f\x02\
\x06\x12\x04\xff\x02\x04*\"!\x20only\x20for\x20Zcash,\x20nVersionGroupId\
\n\n\r\n\x05\x04\x0f\x02\x06\x04\x12\x04\xff\x02\x04\x0c\n\r\n\x05\x04\
\x0f\x02\x06\x05\x12\x04\xff\x02\r\x13\n\r\n\x05\x04\x0f\x02\x06\x01\x12\
\x04\xff\x02\x14$\n\r\n\x05\x04\x0f\x02\x06\x03\x12\x04\xff\x02')\n!\n\
\x04\x04\x0f\x02\x07\x12\x04\x80\x03\x04#\"\x13\x20only\x20for\x20Peerco\
in\n\n\r\n\x05\x04\x0f\x02\x07\x04\x12\x04\x80\x03\x04\x0c\n\r\n\x05\x04\
\x0f\x02\x07\x05\x12\x04\x80\x03\r\x13\n\r\n\x05\x04\x0f\x02\x07\x01\x12\
\x04\x80\x03\x14\x1d\n\r\n\x05\x04\x0f\x02\x07\x03\x12\x04\x80\x03\x20\"\
\n)\n\x04\x04\x0f\x02\x08\x12\x04\x81\x03\x04#\"\x1b\x20only\x20for\x20Z\
cash,\x20BRANCH_ID\n\n\r\n\x05\x04\x0f\x02\x08\x04\x12\x04\x81\x03\x04\
\x0c\n\r\n\x05\x04\x0f\x02\x08\x05\x12\x04\x81\x03\r\x13\n\r\n\x05\x04\
\x0f\x02\x08\x01\x12\x04\x81\x03\x14\x1d\n\r\n\x05\x04\x0f\x02\x08\x03\
\x12\x04\x81\x03\x20\"\nT\n\x03\x04\x0f\t\x12\x04\x84\x03\r\x1c\x1aG\x20\
fields\x20which\x20are\x20in\x20use,\x20or\x20have\x20been\x20in\x20the\
\x20past,\x20in\x20TransactionType\n\n\x0c\n\x04\x04\x0f\t\0\x12\x04\x84\
\x03\r\x0e\n\r\n\x05\x04\x0f\t\0\x01\x12\x04\x84\x03\r\x0e\n\r\n\x05\x04\
\x0f\t\0\x02\x12\x04\x84\x03\r\x0e\n\x0c\n\x04\x04\x0f\t\x01\x12\x04\x84\
\x03\x10\x11\n\r\n\x05\x04\x0f\t\x01\x01\x12\x04\x84\x03\x10\x11\n\r\n\
\x05\x04\x0f\t\x01\x02\x12\x04\x84\x03\x10\x11\n\x0c\n\x04\x04\x0f\t\x02\
\x12\x04\x84\x03\x13\x14\n\r\n\x05\x04\x0f\t\x02\x01\x12\x04\x84\x03\x13\
\x14\n\r\n\x05\x04\x0f\t\x02\x02\x12\x04\x84\x03\x13\x14\n\x0c\n\x04\x04\
\x0f\t\x03\x12\x04\x84\x03\x16\x17\n\r\n\x05\x04\x0f\t\x03\x01\x12\x04\
\x84\x03\x16\x17\n\r\n\x05\x04\x0f\t\x03\x02\x12\x04\x84\x03\x16\x17\n\
\x0c\n\x04\x04\x0f\t\x04\x12\x04\x84\x03\x19\x1b\n\r\n\x05\x04\x0f\t\x04\
\x01\x12\x04\x84\x03\x19\x1b\n\r\n\x05\x04\x0f\t\x04\x02\x12\x04\x84\x03\
\x19\x1b\n\x84\x01\n\x02\x04\x10\x12\x06\x8c\x03\0\x95\x03\x01\x1av*\x20\
Data\x20type\x20for\x20inputs\x20of\x20previous\x20transactions.\n\n\x20\
When\x20adding\x20fields,\x20take\x20care\x20to\x20not\x20conflict\x20wi\
th\x20TxInput\n\x20@embed\n\n\x0b\n\x03\x04\x10\x01\x12\x04\x8c\x03\x08\
\x11\nJ\n\x04\x04\x10\x02\0\x12\x04\x8d\x03\x04!\"<\x20hash\x20of\x20pre\
vious\x20transaction\x20output\x20to\x20spend\x20by\x20this\x20input\n\n\
\r\n\x05\x04\x10\x02\0\x04\x12\x04\x8d\x03\x04\x0c\n\r\n\x05\x04\x10\x02\
\0\x05\x12\x04\x8d\x03\r\x12\n\r\n\x05\x04\x10\x02\0\x01\x12\x04\x8d\x03\
\x13\x1c\n\r\n\x05\x04\x10\x02\0\x03\x12\x04\x8d\x03\x1f\x20\n1\n\x04\
\x04\x10\x02\x01\x12\x04\x8e\x03\x04#\"#\x20index\x20of\x20previous\x20o\
utput\x20to\x20spend\n\n\r\n\x05\x04\x10\x02\x01\x04\x12\x04\x8e\x03\x04\
\x0c\n\r\n\x05\x04\x10\x02\x01\x05\x12\x04\x8e\x03\r\x13\n\r\n\x05\x04\
\x10\x02\x01\x01\x12\x04\x8e\x03\x14\x1e\n\r\n\x05\x04\x10\x02\x01\x03\
\x12\x04\x8e\x03!\"\n\x20\n\x04\x04\x10\x02\x02\x12\x04\x8f\x03\x04\"\"\
\x12\x20script\x20signature\n\n\r\n\x05\x04\x10\x02\x02\x04\x12\x04\x8f\
\x03\x04\x0c\n\r\n\x05\x04\x10\x02\x02\x05\x12\x04\x8f\x03\r\x12\n\r\n\
\x05\x04\x10\x02\x02\x01\x12\x04\x8f\x03\x13\x1d\n\r\n\x05\x04\x10\x02\
\x02\x03\x12\x04\x8f\x03\x20!\n\x18\n\x04\x04\x10\x02\x03\x12\x04\x90\
\x03\x04!\"\n\x20sequence\n\n\r\n\x05\x04\x10\x02\x03\x04\x12\x04\x90\
\x03\x04\x0c\n\r\n\x05\x04\x10\x02\x03\x05\x12\x04\x90\x03\r\x13\n\r\n\
\x05\x04\x10\x02\x03\x01\x12\x04\x90\x03\x14\x1c\n\r\n\x05\x04\x10\x02\
\x03\x03\x12\x04\x90\x03\x1f\x20\n\x1f\n\x04\x04\x10\x02\x04\x12\x04\x91\
\x03\x04$\"\x11\x20only\x20for\x20Decred\n\n\r\n\x05\x04\x10\x02\x04\x04\
\x12\x04\x91\x03\x04\x0c\n\r\n\x05\x04\x10\x02\x04\x05\x12\x04\x91\x03\r\
\x13\n\r\n\x05\x04\x10\x02\x04\x01\x12\x04\x91\x03\x14\x1f\n\r\n\x05\x04\
\x10\x02\x04\x03\x12\x04\x91\x03\"#\nO\n\x03\x04\x10\t\x12\x04\x94\x03\r\
@\x1aB\x20fields\x20that\x20are\x20in\x20use,\x20or\x20have\x20been\x20i\
n\x20the\x20past,\x20in\x20TxInputType\n\n\x0c\n\x04\x04\x10\t\0\x12\x04\
\x94\x03\r\x0e\n\r\n\x05\x04\x10\t\0\x01\x12\x04\x94\x03\r\x0e\n\r\n\x05\
\x04\x10\t\0\x02\x12\x04\x94\x03\r\x0e\n\x0c\n\x04\x04\x10\t\x01\x12\x04\
\x94\x03\x10\x11\n\r\n\x05\x04\x10\t\x01\x01\x12\x04\x94\x03\x10\x11\n\r\
\n\x05\x04\x10\t\x01\x02\x12\x04\x94\x03\x10\x11\n\x0c\n\x04\x04\x10\t\
\x02\x12\x04\x94\x03\x13\x14\n\r\n\x05\x04\x10\t\x02\x01\x12\x04\x94\x03\
\x13\x14\n\r\n\x05\x04\x10\t\x02\x02\x12\x04\x94\x03\x13\x14\n\x0c\n\x04\
\x04\x10\t\x03\x12\x04\x94\x03\x16\x17\n\r\n\x05\x04\x10\t\x03\x01\x12\
\x04\x94\x03\x16\x17\n\r\n\x05\x04\x10\t\x03\x02\x12\x04\x94\x03\x16\x17\
\n\x0c\n\x04\x04\x10\t\x04\x12\x04\x94\x03\x19\x1b\n\r\n\x05\x04\x10\t\
\x04\x01\x12\x04\x94\x03\x19\x1b\n\r\n\x05\x04\x10\t\x04\x02\x12\x04\x94\
\x03\x19\x1b\n\x0c\n\x04\x04\x10\t\x05\x12\x04\x94\x03\x1d\x1f\n\r\n\x05\
\x04\x10\t\x05\x01\x12\x04\x94\x03\x1d\x1f\n\r\n\x05\x04\x10\t\x05\x02\
\x12\x04\x94\x03\x1d\x1f\n\x0c\n\x04\x04\x10\t\x06\x12\x04\x94\x03!#\n\r\
\n\x05\x04\x10\t\x06\x01\x12\x04\x94\x03!#\n\r\n\x05\x04\x10\t\x06\x02\
\x12\x04\x94\x03!#\n\x0c\n\x04\x04\x10\t\x07\x12\x04\x94\x03%'\n\r\n\x05\
\x04\x10\t\x07\x01\x12\x04\x94\x03%'\n\r\n\x05\x04\x10\t\x07\x02\x12\x04\
\x94\x03%'\n\x0c\n\x04\x04\x10\t\x08\x12\x04\x94\x03)+\n\r\n\x05\x04\x10\
\t\x08\x01\x12\x04\x94\x03)+\n\r\n\x05\x04\x10\t\x08\x02\x12\x04\x94\x03\
)+\n\x0c\n\x04\x04\x10\t\t\x12\x04\x94\x03-/\n\r\n\x05\x04\x10\t\t\x01\
\x12\x04\x94\x03-/\n\r\n\x05\x04\x10\t\t\x02\x12\x04\x94\x03-/\n\x0c\n\
\x04\x04\x10\t\n\x12\x04\x94\x0313\n\r\n\x05\x04\x10\t\n\x01\x12\x04\x94\
\x0313\n\r\n\x05\x04\x10\t\n\x02\x12\x04\x94\x0313\n\x0c\n\x04\x04\x10\t\
\x0b\x12\x04\x94\x0357\n\r\n\x05\x04\x10\t\x0b\x01\x12\x04\x94\x0357\n\r\
\n\x05\x04\x10\t\x0b\x02\x12\x04\x94\x0357\n\x0c\n\x04\x04\x10\t\x0c\x12\
\x04\x94\x039;\n\r\n\x05\x04\x10\t\x0c\x01\x12\x04\x94\x039;\n\r\n\x05\
\x04\x10\t\x0c\x02\x12\x04\x94\x039;\n\x0c\n\x04\x04\x10\t\r\x12\x04\x94\
\x03=?\n\r\n\x05\x04\x10\t\r\x01\x12\x04\x94\x03=?\n\r\n\x05\x04\x10\t\r\
\x02\x12\x04\x94\x03=?\nH\n\x02\x04\x11\x12\x06\x9a\x03\0\x9e\x03\x01\
\x1a:*\x20Data\x20type\x20for\x20outputs\x20of\x20previous\x20transactio\
ns.\n\x20@embed\n\n\x0b\n\x03\x04\x11\x01\x12\x04\x9a\x03\x08\x12\n*\n\
\x04\x04\x11\x02\0\x12\x04\x9b\x03\x04\x1f\"\x1c\x20amount\x20sent\x20to\
\x20this\x20output\n\n\r\n\x05\x04\x11\x02\0\x04\x12\x04\x9b\x03\x04\x0c\
\n\r\n\x05\x04\x11\x02\0\x05\x12\x04\x9b\x03\r\x13\n\r\n\x05\x04\x11\x02\
\0\x01\x12\x04\x9b\x03\x14\x1a\n\r\n\x05\x04\x11\x02\0\x03\x12\x04\x9b\
\x03\x1d\x1e\n+\n\x04\x04\x11\x02\x01\x12\x04\x9c\x03\x04%\"\x1d\x20scri\
ptPubkey\x20of\x20this\x20output\n\n\r\n\x05\x04\x11\x02\x01\x04\x12\x04\
\x9c\x03\x04\x0c\n\r\n\x05\x04\x11\x02\x01\x05\x12\x04\x9c\x03\r\x12\n\r\
\n\x05\x04\x11\x02\x01\x01\x12\x04\x9c\x03\x13\x20\n\r\n\x05\x04\x11\x02\
\x01\x03\x12\x04\x9c\x03#$\n\x1f\n\x04\x04\x11\x02\x02\x12\x04\x9d\x03\
\x04.\"\x11\x20only\x20for\x20Decred\n\n\r\n\x05\x04\x11\x02\x02\x04\x12\
\x04\x9d\x03\x04\x0c\n\r\n\x05\x04\x11\x02\x02\x05\x12\x04\x9d\x03\r\x13\
\n\r\n\x05\x04\x11\x02\x02\x01\x12\x04\x9d\x03\x14)\n\r\n\x05\x04\x11\
\x02\x02\x03\x12\x04\x9d\x03,-\n\xd2\x01\n\x02\x04\x12\x12\x06\xa9\x03\0\
\xb1\x03\x01\x1a\xc3\x01*\n\x20Request:\x20Data\x20about\x20input\x20to\
\x20be\x20signed.\n\x20Wire-alias\x20of\x20TxAck.\n\n\x20Do\x20not\x20ed\
it\x20this\x20type\x20without\x20considering\x20compatibility\x20with\
\x20TxAck.\n\x20Prefer\x20to\x20modify\x20the\x20inner\x20TxInput\x20typ\
e.\n\n\x20@next\x20TxRequest\n\n\x0b\n\x03\x04\x12\x01\x12\x04\xa9\x03\
\x08\x12\n\x0b\n\x03\x04\x12\x07\x12\x04\xaa\x03\x04\x1c\n\x0e\n\x06\x04\
\x12\x07\xa2\x96\x03\x12\x04\xaa\x03\x04\x1c\n\x0c\n\x04\x04\x12\x02\0\
\x12\x04\xac\x03\x04&\n\r\n\x05\x04\x12\x02\0\x04\x12\x04\xac\x03\x04\
\x0c\n\r\n\x05\x04\x12\x02\0\x06\x12\x04\xac\x03\r\x1e\n\r\n\x05\x04\x12\
\x02\0\x01\x12\x04\xac\x03\x1f!\n\r\n\x05\x04\x12\x02\0\x03\x12\x04\xac\
\x03$%\n\x0e\n\x04\x04\x12\x03\0\x12\x06\xae\x03\x04\xb0\x03\x05\n\r\n\
\x05\x04\x12\x03\0\x01\x12\x04\xae\x03\x0c\x1d\n\x0e\n\x06\x04\x12\x03\0\
\x02\0\x12\x04\xaf\x03\x08#\n\x0f\n\x07\x04\x12\x03\0\x02\0\x04\x12\x04\
\xaf\x03\x08\x10\n\x0f\n\x07\x04\x12\x03\0\x02\0\x06\x12\x04\xaf\x03\x11\
\x18\n\x0f\n\x07\x04\x12\x03\0\x02\0\x01\x12\x04\xaf\x03\x19\x1e\n\x0f\n\
\x07\x04\x12\x03\0\x02\0\x03\x12\x04\xaf\x03!\"\n\xd4\x01\n\x02\x04\x13\
\x12\x06\xbc\x03\0\xc4\x03\x01\x1a\xc5\x01*\n\x20Request:\x20Data\x20abo\
ut\x20output\x20to\x20be\x20signed.\n\x20Wire-alias\x20of\x20TxAck.\n\n\
\x20Do\x20not\x20edit\x20this\x20type\x20without\x20considering\x20compa\
tibility\x20with\x20TxAck.\n\x20Prefer\x20to\x20modify\x20the\x20inner\
\x20TxOutput\x20type.\n\n\x20@next\x20TxRequest\n\n\x0b\n\x03\x04\x13\
\x01\x12\x04\xbc\x03\x08\x13\n\x0b\n\x03\x04\x13\x07\x12\x04\xbd\x03\x04\
\x1c\n\x0e\n\x06\x04\x13\x07\xa2\x96\x03\x12\x04\xbd\x03\x04\x1c\n\x0c\n\
\x04\x04\x13\x02\0\x12\x04\xbf\x03\x04'\n\r\n\x05\x04\x13\x02\0\x04\x12\
\x04\xbf\x03\x04\x0c\n\r\n\x05\x04\x13\x02\0\x06\x12\x04\xbf\x03\r\x1f\n\
\r\n\x05\x04\x13\x02\0\x01\x12\x04\xbf\x03\x20\"\n\r\n\x05\x04\x13\x02\0\
\x03\x12\x04\xbf\x03%&\n\x0e\n\x04\x04\x13\x03\0\x12\x06\xc1\x03\x04\xc3\
\x03\x05\n\r\n\x05\x04\x13\x03\0\x01\x12\x04\xc1\x03\x0c\x1e\n\x0e\n\x06\
\x04\x13\x03\0\x02\0\x12\x04\xc2\x03\x08%\n\x0f\n\x07\x04\x13\x03\0\x02\
\0\x04\x12\x04\xc2\x03\x08\x10\n\x0f\n\x07\x04\x13\x03\0\x02\0\x06\x12\
\x04\xc2\x03\x11\x19\n\x0f\n\x07\x04\x13\x03\0\x02\0\x01\x12\x04\xc2\x03\
\x1a\x20\n\x0f\n\x07\x04\x13\x03\0\x02\0\x03\x12\x04\xc2\x03#$\n\xdb\x01\
\n\x02\x04\x14\x12\x06\xcf\x03\0\xd3\x03\x01\x1a\xcc\x01*\n\x20Request:\
\x20Data\x20about\x20previous\x20transaction\x20metadata\n\x20Wire-alias\
\x20of\x20TxAck.\n\n\x20Do\x20not\x20edit\x20this\x20type\x20without\x20\
considering\x20compatibility\x20with\x20TxAck.\n\x20Prefer\x20to\x20modi\
fy\x20the\x20inner\x20PrevTx\x20type.\n\n\x20@next\x20TxRequest\n\n\x0b\
\n\x03\x04\x14\x01\x12\x04\xcf\x03\x08\x15\n\x0b\n\x03\x04\x14\x07\x12\
\x04\xd0\x03\x04\x1c\n\x0e\n\x06\x04\x14\x07\xa2\x96\x03\x12\x04\xd0\x03\
\x04\x1c\n\x0c\n\x04\x04\x14\x02\0\x12\x04\xd2\x03\x04\x1b\n\r\n\x05\x04\
\x14\x02\0\x04\x12\x04\xd2\x03\x04\x0c\n\r\n\x05\x04\x14\x02\0\x06\x12\
\x04\xd2\x03\r\x13\n\r\n\x05\x04\x14\x02\0\x01\x12\x04\xd2\x03\x14\x16\n\
\r\n\x05\x04\x14\x02\0\x03\x12\x04\xd2\x03\x19\x1a\n\xdb\x01\n\x02\x04\
\x15\x12\x06\xde\x03\0\xe7\x03\x01\x1a\xcc\x01*\n\x20Request:\x20Data\
\x20about\x20previous\x20transaction\x20input\n\x20Wire-alias\x20of\x20T\
xAck.\n\n\x20Do\x20not\x20edit\x20this\x20type\x20without\x20considering\
\x20compatibility\x20with\x20TxAck.\n\x20Prefer\x20to\x20modify\x20the\
\x20inner\x20PrevInput\x20type.\n\n\x20@next\x20TxRequest\n\n\x0b\n\x03\
\x04\x15\x01\x12\x04\xde\x03\x08\x16\n\x0b\n\x03\x04\x15\x07\x12\x04\xdf\
\x03\x04\x1c\n\x0e\n\x06\x04\x15\x07\xa2\x96\x03\x12\x04\xdf\x03\x04\x1c\
\n\x0c\n\x04\x04\x15\x02\0\x12\x04\xe1\x03\x04*\n\r\n\x05\x04\x15\x02\0\
\x04\x12\x04\xe1\x03\x04\x0c\n\r\n\x05\x04\x15\x02\0\x06\x12\x04\xe1\x03\
\r\"\n\r\n\x05\x04\x15\x02\0\x01\x12\x04\xe1\x03#%\n\r\n\x05\x04\x15\x02\
\0\x03\x12\x04\xe1\x03()\n\x0e\n\x04\x04\x15\x03\0\x12\x06\xe3\x03\x04\
\xe6\x03\x05\n\r\n\x05\x04\x15\x03\0\x01\x12\x04\xe3\x03\x0c!\n\x0e\n\
\x06\x04\x15\x03\0\x02\0\x12\x04\xe4\x03\x08%\n\x0f\n\x07\x04\x15\x03\0\
\x02\0\x04\x12\x04\xe4\x03\x08\x10\n\x0f\n\x07\x04\x15\x03\0\x02\0\x06\
\x12\x04\xe4\x03\x11\x1a\n\x0f\n\x07\x04\x15\x03\0\x02\0\x01\x12\x04\xe4\
\x03\x1b\x20\n\x0f\n\x07\x04\x15\x03\0\x02\0\x03\x12\x04\xe4\x03#$\n\xdd\
\x01\n\x02\x04\x16\x12\x06\xf2\x03\0\xfa\x03\x01\x1a\xce\x01*\n\x20Reque\
st:\x20Data\x20about\x20previous\x20transaction\x20output\n\x20Wire-alia\
s\x20of\x20TxAck.\n\n\x20Do\x20not\x20edit\x20this\x20type\x20without\
\x20considering\x20compatibility\x20with\x20TxAck.\n\x20Prefer\x20to\x20\
modify\x20the\x20inner\x20PrevOutput\x20type.\n\n\x20@next\x20TxRequest\
\n\n\x0b\n\x03\x04\x16\x01\x12\x04\xf2\x03\x08\x17\n\x0b\n\x03\x04\x16\
\x07\x12\x04\xf3\x03\x04\x1c\n\x0e\n\x06\x04\x16\x07\xa2\x96\x03\x12\x04\
\xf3\x03\x04\x1c\n\x0c\n\x04\x04\x16\x02\0\x12\x04\xf5\x03\x04+\n\r\n\
\x05\x04\x16\x02\0\x04\x12\x04\xf5\x03\x04\x0c\n\r\n\x05\x04\x16\x02\0\
\x06\x12\x04\xf5\x03\r#\n\r\n\x05\x04\x16\x02\0\x01\x12\x04\xf5\x03$&\n\
\r\n\x05\x04\x16\x02\0\x03\x12\x04\xf5\x03)*\n\x0e\n\x04\x04\x16\x03\0\
\x12\x06\xf7\x03\x04\xf9\x03\x05\n\r\n\x05\x04\x16\x03\0\x01\x12\x04\xf7\
\x03\x0c\"\n\x0e\n\x06\x04\x16\x03\0\x02\0\x12\x04\xf8\x03\x08'\n\x0f\n\
\x07\x04\x16\x03\0\x02\0\x04\x12\x04\xf8\x03\x08\x10\n\x0f\n\x07\x04\x16\
\x03\0\x02\0\x06\x12\x04\xf8\x03\x11\x1b\n\x0f\n\x07\x04\x16\x03\0\x02\0\
\x01\x12\x04\xf8\x03\x1c\"\n\x0f\n\x07\x04\x16\x03\0\x02\0\x03\x12\x04\
\xf8\x03%&\n\xbd\x01\n\x02\x04\x17\x12\x06\x84\x04\0\x8c\x04\x01\x1a\xae\
\x01*\n\x20Request:\x20Content\x20of\x20the\x20extra\x20data\x20of\x20a\
\x20previous\x20transaction\n\x20Wire-alias\x20of\x20TxAck.\n\n\x20Do\
\x20not\x20edit\x20this\x20type\x20without\x20considering\x20compatibili\
ty\x20with\x20TxAck.\n\n\x20@next\x20TxRequest\n\n\x0b\n\x03\x04\x17\x01\
\x12\x04\x84\x04\x08\x1a\n\x0b\n\x03\x04\x17\x07\x12\x04\x85\x04\x04\x1c\
\n\x0e\n\x06\x04\x17\x07\xa2\x96\x03\x12\x04\x85\x04\x04\x1c\n\x0c\n\x04\
\x04\x17\x02\0\x12\x04\x87\x04\x04.\n\r\n\x05\x04\x17\x02\0\x04\x12\x04\
\x87\x04\x04\x0c\n\r\n\x05\x04\x17\x02\0\x06\x12\x04\x87\x04\r&\n\r\n\
\x05\x04\x17\x02\0\x01\x12\x04\x87\x04')\n\r\n\x05\x04\x17\x02\0\x03\x12\
\x04\x87\x04,-\n\x0e\n\x04\x04\x17\x03\0\x12\x06\x89\x04\x04\x8b\x04\x05\
\n\r\n\x05\x04\x17\x03\0\x01\x12\x04\x89\x04\x0c%\n\x0e\n\x06\x04\x17\
\x03\0\x02\0\x12\x04\x8a\x04\x08,\n\x0f\n\x07\x04\x17\x03\0\x02\0\x04\
\x12\x04\x8a\x04\x08\x10\n\x0f\n\x07\x04\x17\x03\0\x02\0\x05\x12\x04\x8a\
\x04\x11\x16\n\x0f\n\x07\x04\x17\x03\0\x02\0\x01\x12\x04\x8a\x04\x17'\n\
\x0f\n\x07\x04\x17\x03\0\x02\0\x03\x12\x04\x8a\x04*+\n\x8b\x01\n\x02\x04\
\x18\x12\x06\x94\x04\0\x9c\x04\x01\x1a}*\n\x20Request:\x20Ask\x20device\
\x20for\x20a\x20proof\x20of\x20ownership\x20corresponding\x20to\x20addre\
ss_n\x20path\n\x20@start\n\x20@next\x20OwnershipProof\n\x20@next\x20Fail\
ure\n\n\x0b\n\x03\x04\x18\x01\x12\x04\x94\x04\x08\x19\n>\n\x04\x04\x18\
\x02\0\x12\x04\x95\x04\x04\"\"0\x20BIP-32\x20path\x20to\x20derive\x20the\
\x20key\x20from\x20master\x20node\n\n\r\n\x05\x04\x18\x02\0\x04\x12\x04\
\x95\x04\x04\x0c\n\r\n\x05\x04\x18\x02\0\x05\x12\x04\x95\x04\r\x13\n\r\n\
\x05\x04\x18\x02\0\x01\x12\x04\x95\x04\x14\x1d\n\r\n\x05\x04\x18\x02\0\
\x03\x12\x04\x95\x04\x20!\n\x1b\n\x04\x04\x18\x02\x01\x12\x04\x96\x04\
\x046\"\r\x20coin\x20to\x20use\n\n\r\n\x05\x04\x18\x02\x01\x04\x12\x04\
\x96\x04\x04\x0c\n\r\n\x05\x04\x18\x02\x01\x05\x12\x04\x96\x04\r\x13\n\r\
\n\x05\x04\x18\x02\x01\x01\x12\x04\x96\x04\x14\x1d\n\r\n\x05\x04\x18\x02\
\x01\x03\x12\x04\x96\x04\x20!\n\r\n\x05\x04\x18\x02\x01\x08\x12\x04\x96\
\x04\"5\n\r\n\x05\x04\x18\x02\x01\x07\x12\x04\x96\x04+4\nF\n\x04\x04\x18\
\x02\x02\x12\x04\x97\x04\x04D\"8\x20used\x20to\x20distinguish\x20between\
\x20various\x20scriptPubKey\x20types\n\n\r\n\x05\x04\x18\x02\x02\x04\x12\
\x04\x97\x04\x04\x0c\n\r\n\x05\x04\x18\x02\x02\x06\x12\x04\x97\x04\r\x1c\
\n\r\n\x05\x04\x18\x02\x02\x01\x12\x04\x97\x04\x1d(\n\r\n\x05\x04\x18\
\x02\x02\x03\x12\x04\x97\x04+,\n\r\n\x05\x04\x18\x02\x02\x08\x12\x04\x97\
\x04-C\n\r\n\x05\x04\x18\x02\x02\x07\x12\x04\x97\x046B\n9\n\x04\x04\x18\
\x02\x03\x12\x04\x98\x04\x043\"+\x20filled\x20if\x20proof\x20is\x20for\
\x20a\x20multisig\x20address\n\n\r\n\x05\x04\x18\x02\x03\x04\x12\x04\x98\
\x04\x04\x0c\n\r\n\x05\x04\x18\x02\x03\x06\x12\x04\x98\x04\r%\n\r\n\x05\
\x04\x18\x02\x03\x01\x12\x04\x98\x04&.\n\r\n\x05\x04\x18\x02\x03\x03\x12\
\x04\x98\x0412\n[\n\x04\x04\x18\x02\x04\x12\x04\x99\x04\x048\"M\x20show\
\x20a\x20confirmation\x20dialog\x20and\x20set\x20the\x20\"user\x20confir\
mation\"\x20bit\x20in\x20the\x20proof\n\n\r\n\x05\x04\x18\x02\x04\x04\
\x12\x04\x99\x04\x04\x0c\n\r\n\x05\x04\x18\x02\x04\x05\x12\x04\x99\x04\r\
\x11\n\r\n\x05\x04\x18\x02\x04\x01\x12\x04\x99\x04\x12#\n\r\n\x05\x04\
\x18\x02\x04\x03\x12\x04\x99\x04&'\n\r\n\x05\x04\x18\x02\x04\x08\x12\x04\
\x99\x04(7\n\r\n\x05\x04\x18\x02\x04\x07\x12\x04\x99\x0416\nA\n\x04\x04\
\x18\x02\x05\x12\x04\x9a\x04\x04%\"3\x20list\x20of\x20ownership\x20ident\
ifiers\x20in\x20case\x20of\x20multisig\n\n\r\n\x05\x04\x18\x02\x05\x04\
\x12\x04\x9a\x04\x04\x0c\n\r\n\x05\x04\x18\x02\x05\x05\x12\x04\x9a\x04\r\
\x12\n\r\n\x05\x04\x18\x02\x05\x01\x12\x04\x9a\x04\x13\x20\n\r\n\x05\x04\
\x18\x02\x05\x03\x12\x04\x9a\x04#$\n@\n\x04\x04\x18\x02\x06\x12\x04\x9b\
\x04\x044\"2\x20additional\x20data\x20to\x20which\x20the\x20proof\x20sho\
uld\x20commit\n\n\r\n\x05\x04\x18\x02\x06\x04\x12\x04\x9b\x04\x04\x0c\n\
\r\n\x05\x04\x18\x02\x06\x05\x12\x04\x9b\x04\r\x12\n\r\n\x05\x04\x18\x02\
\x06\x01\x12\x04\x9b\x04\x13\"\n\r\n\x05\x04\x18\x02\x06\x03\x12\x04\x9b\
\x04%&\n\r\n\x05\x04\x18\x02\x06\x08\x12\x04\x9b\x04'3\n\r\n\x05\x04\x18\
\x02\x06\x07\x12\x04\x9b\x0402\nA\n\x02\x04\x19\x12\x06\xa2\x04\0\xa5\
\x04\x01\x1a3*\n\x20Response:\x20Contains\x20the\x20proof\x20of\x20owner\
ship\n\x20@end\n\n\x0b\n\x03\x04\x19\x01\x12\x04\xa2\x04\x08\x16\n,\n\
\x04\x04\x19\x02\0\x12\x04\xa3\x04\x04'\"\x1e\x20SLIP-0019\x20proof\x20o\
f\x20ownership\n\n\r\n\x05\x04\x19\x02\0\x04\x12\x04\xa3\x04\x04\x0c\n\r\
\n\x05\x04\x19\x02\0\x05\x12\x04\xa3\x04\r\x12\n\r\n\x05\x04\x19\x02\0\
\x01\x12\x04\xa3\x04\x13\"\n\r\n\x05\x04\x19\x02\0\x03\x12\x04\xa3\x04%&\
\n&\n\x04\x04\x19\x02\x01\x12\x04\xa4\x04\x04!\"\x18\x20signature\x20of\
\x20the\x20proof\n\n\r\n\x05\x04\x19\x02\x01\x04\x12\x04\xa4\x04\x04\x0c\
\n\r\n\x05\x04\x19\x02\x01\x05\x12\x04\xa4\x04\r\x12\n\r\n\x05\x04\x19\
\x02\x01\x01\x12\x04\xa4\x04\x13\x1c\n\r\n\x05\x04\x19\x02\x01\x03\x12\
\x04\xa4\x04\x1f\x20\n\x82\x01\n\x02\x04\x1a\x12\x06\xad\x04\0\xb7\x04\
\x01\x1at*\n\x20Request:\x20Ask\x20device\x20to\x20prompt\x20the\x20user\
\x20to\x20authorize\x20a\x20CoinJoin\x20transaction\n\x20@start\n\x20@ne\
xt\x20Success\n\x20@next\x20Failure\n\n\x0b\n\x03\x04\x1a\x01\x12\x04\
\xad\x04\x08\x19\n\x0b\n\x03\x04\x1a\x07\x12\x04\xae\x04\x04\x1d\n\x0e\n\
\x06\x04\x1a\x07\xa1\x96\x03\x12\x04\xae\x04\x04\x1d\nk\n\x04\x04\x1a\
\x02\0\x12\x04\xb0\x04\x04$\"]\x20coordinator\x20identifier\x20to\x20app\
rove\x20as\x20a\x20prefix\x20in\x20commitment\x20data\x20(max.\x2018\x20\
ASCII\x20characters)\n\n\r\n\x05\x04\x1a\x02\0\x04\x12\x04\xb0\x04\x04\
\x0c\n\r\n\x05\x04\x1a\x02\0\x05\x12\x04\xb0\x04\r\x13\n\r\n\x05\x04\x1a\
\x02\0\x01\x12\x04\xb0\x04\x14\x1f\n\r\n\x05\x04\x1a\x02\0\x03\x12\x04\
\xb0\x04\"#\n\"\n\x04\x04\x1a\x02\x01\x12\x04\xb1\x04\x04&\"\x14\x20maxi\
mum\x20total\x20fees\n\n\r\n\x05\x04\x1a\x02\x01\x04\x12\x04\xb1\x04\x04\
\x0c\n\r\n\x05\x04\x1a\x02\x01\x05\x12\x04\xb1\x04\r\x13\n\r\n\x05\x04\
\x1a\x02\x01\x01\x12\x04\xb1\x04\x14!\n\r\n\x05\x04\x1a\x02\x01\x03\x12\
\x04\xb1\x04$%\n?\n\x04\x04\x1a\x02\x02\x12\x04\xb2\x04\x046\"1\x20fee\
\x20per\x20anonymity\x20set\x20in\x20units\x20of\x2010^-9\x20percent\n\n\
\r\n\x05\x04\x1a\x02\x02\x04\x12\x04\xb2\x04\x04\x0c\n\r\n\x05\x04\x1a\
\x02\x02\x05\x12\x04\xb2\x04\r\x13\n\r\n\x05\x04\x1a\x02\x02\x01\x12\x04\
\xb2\x04\x14%\n\r\n\x05\x04\x1a\x02\x02\x03\x12\x04\xb2\x04()\n\r\n\x05\
\x04\x1a\x02\x02\x08\x12\x04\xb2\x04*5\n\r\n\x05\x04\x1a\x02\x02\x07\x12\
\x04\xb2\x0434\ng\n\x04\x04\x1a\x02\x03\x12\x04\xb3\x04\x04\"\"Y\x20pref\
ix\x20of\x20the\x20BIP-32\x20path\x20leading\x20to\x20the\x20account\x20\
(m\x20/\x20purpose'\x20/\x20coin_type'\x20/\x20account')\n\n\r\n\x05\x04\
\x1a\x02\x03\x04\x12\x04\xb3\x04\x04\x0c\n\r\n\x05\x04\x1a\x02\x03\x05\
\x12\x04\xb3\x04\r\x13\n\r\n\x05\x04\x1a\x02\x03\x01\x12\x04\xb3\x04\x14\
\x1d\n\r\n\x05\x04\x1a\x02\x03\x03\x12\x04\xb3\x04\x20!\n\x1b\n\x04\x04\
\x1a\x02\x04\x12\x04\xb4\x04\x046\"\r\x20coin\x20to\x20use\n\n\r\n\x05\
\x04\x1a\x02\x04\x04\x12\x04\xb4\x04\x04\x0c\n\r\n\x05\x04\x1a\x02\x04\
\x05\x12\x04\xb4\x04\r\x13\n\r\n\x05\x04\x1a\x02\x04\x01\x12\x04\xb4\x04\
\x14\x1d\n\r\n\x05\x04\x1a\x02\x04\x03\x12\x04\xb4\x04\x20!\n\r\n\x05\
\x04\x1a\x02\x04\x08\x12\x04\xb4\x04\"5\n\r\n\x05\x04\x1a\x02\x04\x07\
\x12\x04\xb4\x04+4\n^\n\x04\x04\x1a\x02\x05\x12\x04\xb5\x04\x04D\"P\x20u\
sed\x20to\x20distinguish\x20between\x20various\x20address\x20formats\x20\
(non-segwit,\x20segwit,\x20etc.)\n\n\r\n\x05\x04\x1a\x02\x05\x04\x12\x04\
\xb5\x04\x04\x0c\n\r\n\x05\x04\x1a\x02\x05\x06\x12\x04\xb5\x04\r\x1c\n\r\
\n\x05\x04\x1a\x02\x05\x01\x12\x04\xb5\x04\x1d(\n\r\n\x05\x04\x1a\x02\
\x05\x03\x12\x04\xb5\x04+,\n\r\n\x05\x04\x1a\x02\x05\x08\x12\x04\xb5\x04\
-C\n\r\n\x05\x04\x1a\x02\x05\x07\x12\x04\xb5\x046B\n\x1f\n\x04\x04\x1a\
\x02\x06\x12\x04\xb6\x04\x04;\"\x11\x20show\x20amounts\x20in\n\n\r\n\x05\
\x04\x1a\x02\x06\x04\x12\x04\xb6\x04\x04\x0c\n\r\n\x05\x04\x1a\x02\x06\
\x06\x12\x04\xb6\x04\r\x17\n\r\n\x05\x04\x1a\x02\x06\x01\x12\x04\xb6\x04\
\x18#\n\r\n\x05\x04\x1a\x02\x06\x03\x12\x04\xb6\x04&(\n\r\n\x05\x04\x1a\
\x02\x06\x08\x12\x04\xb6\x04):\n\r\n\x05\x04\x1a\x02\x06\x07\x12\x04\xb6\
\x0429\
";
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()
})
}